Changed char* constraint behaviour to be comparable to another char*

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

test/detail/test_check.cpp

@@ -30,3 +30,48 @@ BOOST_AUTO_TEST_CASE( ref_to_int_and_int_can_be_compared )
     BOOST_CHECK( check( 3, boost::cref( 3 ) ) );
     BOOST_CHECK( ! check( 4, boost::cref( 3 ) ) );
 }
+
+namespace
+{
+    struct fixture
+    {
+        fixture()
+            : text( "same text" )
+            , actual( text.c_str() )
+        {
+            const char* static_string = "same text";
+            BOOST_REQUIRE( actual != static_string );
+            BOOST_REQUIRE( actual == std::string( static_string ) );
+        }
+        std::string text;
+        const char* actual;
+    };
+}
+
+BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_pointer_can_be_compared, fixture )
+{
+    const char* expected = "same text";
+    BOOST_CHECK( check( expected, actual ) );
+    const char* unexpected = "different text";
+    BOOST_CHECK( ! check( actual, unexpected ) );
+}
+
+BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_string_literal_can_be_compared, fixture )
+{
+    BOOST_CHECK( check( "same text", actual ) );
+    BOOST_CHECK( ! check( "different text", actual ) );
+}
+
+BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_const_char_array_can_be_compared, fixture )
+{
+    const char expected[10] = "same text";
+    BOOST_CHECK( check( expected, actual ) );
+    const char unexpected[15] = "different text";
+    BOOST_CHECK( ! check( unexpected, actual ) );
+}
+
+BOOST_FIXTURE_TEST_CASE( const_char_pointer_and_std_string_can_be_compared, fixture )
+{
+    BOOST_CHECK( check( std::string( "same text" ), actual ) );
+    BOOST_CHECK( ! check( std::string( "different text" ), actual ) );
+}

turtle/detail/check.hpp

@@ -15,6 +15,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/ref.hpp>
+#include <cstring>
 
 namespace mock
 {
@@ -57,6 +58,26 @@ namespace detail
         Expected expected_;
     };
 
+    template<>
+    class check< const char*, const char* > : public check_base< const char* >
+    {
+    public:
+        explicit check( const char* expected )
+            : expected_( expected )
+        {}
+        virtual bool operator()( const char* actual )
+        {
+            return std::strcmp( actual, expected_ ) == 0;
+        }
+    private:
+        virtual void serialize( std::ostream& s ) const
+        {
+            s << mock::format( expected_ );
+        }
+    private:
+        const char* expected_;
+    };
+
     template< typename Actual, typename Constraint >
     class check< Actual, mock::constraint< Constraint > >
         : public check_base< Actual >