Most functors as constraints are detected automatically

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

build/vc80/turtle.vcproj

@@ -184,6 +184,10 @@
 				RelativePath="..\..\src\libraries\turtle\invocation.hpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\libraries\turtle\is_functor.hpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\libraries\turtle\matcher.hpp"
 				>

build/vc80/turtle_test.vcproj

@@ -208,6 +208,10 @@
 				RelativePath="..\..\src\tests\turtle_test\invocation_test.cpp"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\tests\turtle_test\is_functor_test.cpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\tests\turtle_test\mock_test.cpp"
 				>

src/libraries/turtle/check.hpp

@@ -11,8 +11,10 @@
 
 #include "placeholder.hpp"
 #include "constraint.hpp"
+#include "is_functor.hpp"
 #include "format.hpp"
 #include <boost/function.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <stdexcept>
 #include <ostream>
 
@@ -27,15 +29,28 @@ namespace detail
             boost::function< bool( Arg ) > functor_type;
 
     public:
+        template< typename F >
+        explicit check( const F& f,
+            BOOST_DEDUCED_TYPENAME boost::enable_if<
+                BOOST_DEDUCED_TYPENAME detail::is_functor< F >::type
+            >::type* = 0 )
+            : functor_( f )
+            , desc_   ( "?" )
+        {
+            if( !functor_ )
+                std::invalid_argument( "invalid functor" );
+        }
         template< typename T >
-        explicit check( const T& t )
+        explicit check( const T& t,
+            BOOST_DEDUCED_TYPENAME boost::disable_if<
+                BOOST_DEDUCED_TYPENAME detail::is_functor< T >::type
+            >::type* = 0 )
             : functor_( equal( t ).functor_ )
             , desc_   ( detail::format( t ) )
         {
             if( !functor_ )
                 std::invalid_argument( "invalid functor" );
         }
-
         template< typename Constraint >
         explicit check( const placeholder< Constraint >& c )
             : functor_( c.functor_ )

src/libraries/turtle/is_functor.hpp

@@ -0,0 +1,48 @@
+//
+//  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)
+//
+
+#ifndef MOCK_IS_FUNCTOR_HPP_INCLUDED
+#define MOCK_IS_FUNCTOR_HPP_INCLUDED
+
+#include <boost/function_types/is_callable_builtin.hpp>
+
+namespace mock
+{
+namespace detail
+{
+    typedef char true_type[2];
+    typedef char false_type[1];
+
+    template< typename T >
+    true_type& has_result_type_helper( T*, BOOST_DEDUCED_TYPENAME T::result_type* = 0 ) {}
+    template< typename T >
+    false_type& has_result_type_helper( T, ... ) {}
+
+    template< typename T >
+    struct has_result_type
+    {
+        static T* t();
+        enum { value = sizeof( has_result_type_helper( t() ) ) == sizeof( true_type ) };
+    };
+
+    template< typename T, bool B = has_result_type< T >::value >
+    struct is_functor
+    {
+        typedef BOOST_DEDUCED_TYPENAME boost::function_types::is_callable_builtin< T >::type type;
+        enum { value = BOOST_DEDUCED_TYPENAME type::value };
+    };
+    template< typename T >
+    struct is_functor< T, true >
+    {
+        typedef boost::true_type type;
+        enum { value = true };
+    };
+}
+}
+
+#endif // #ifndef MOCK_IS_FUNCTOR_HPP_INCLUDED

src/tests/turtle_test/expectation_test.cpp

@@ -303,12 +303,12 @@ BOOST_AUTO_TEST_CASE( triggering_an_expectation_with_failing_custom_constraint_t
 {
     {
         mock::expectation< void( int ) > e;
-        e.expect().with( mock::constraint( &custom_constraint ) );
+        e.expect().with( &custom_constraint );
         BOOST_CHECK_EXCEPTION_CONTAINS( e( 42 ), "unexpected call" );
     }
     {
         mock::expectation< int( int, const std::string& ) > e;
-        e.expect().with( mock::constraint( &custom_constraint ), "actual" );
+        e.expect().with( &custom_constraint, "actual" );
         BOOST_CHECK_EXCEPTION_CONTAINS( e( 42, "actual" ), "unexpected call" );
     }
 }
@@ -655,7 +655,7 @@ BOOST_AUTO_TEST_CASE( expectation_can_be_serialized_to_be_human_readable )
     }
     {
         mock::expectation< void( int ) > e( "my expectation" );
-        e.expect().once().with( mock::constraint( &custom_constraint ) );
+        e.expect().once().with( &custom_constraint );
         std::stringstream s;
         s << e;
         const std::string expected = "my expectation\n"

src/tests/turtle_test/is_functor_test.cpp

@@ -0,0 +1,59 @@
+//
+//  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 <turtle/is_functor.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+#include <boost/test/auto_unit_test.hpp>
+#define BOOST_LIB_NAME boost_unit_test_framework
+#include <boost/config/auto_link.hpp>
+
+namespace
+{
+    template< typename T >
+    void check( T )
+    {
+        BOOST_STATIC_ASSERT(( mock::detail::is_functor< T >::value ));
+    }
+
+    void f0 () {}
+    bool f1( int ) { return false; }
+
+    struct s
+    {
+        typedef void result_type;
+    };
+}
+
+BOOST_AUTO_TEST_CASE( function_is_functor )
+{
+    check( f0 );
+    check( f1 );
+}
+
+BOOST_AUTO_TEST_CASE( function_pointer_is_functor )
+{
+    check( &f0 );
+    check( &f1 );
+}
+
+BOOST_AUTO_TEST_CASE( boost_bind_is_functor )
+{
+    check( boost::bind( &f0 ) );
+}
+
+BOOST_AUTO_TEST_CASE( boost_function_is_functor )
+{
+    check( boost::function< void() >() );
+}
+
+BOOST_AUTO_TEST_CASE( class_with_result_type_is_functor )
+{
+    check( s() );
+}