Adds more tests for using SetArgumentPointee with protobufs; works around a…

include/gmock/gmock-printers.h

@@ -211,7 +211,9 @@ class UniversalPrinter;
 // Used to print an STL-style container when the user doesn't define
 // a PrintTo() for it.
 template <typename C>
-void DefaultPrintTo(IsContainer, const C& container, ::std::ostream* os) {
+void DefaultPrintTo(IsContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const C& container, ::std::ostream* os) {
   const size_t kMaxCount = 32;  // The maximum number of elements to print.
   *os << '{';
   size_t count = 0;
@@ -234,9 +236,31 @@ void DefaultPrintTo(IsContainer, const C& container, ::std::ostream* os) {
   *os << '}';
 }
 
-// Used to print a value when the user doesn't define PrintTo() for it.
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
 template <typename T>
-void DefaultPrintTo(IsNotContainer, const T& value, ::std::ostream* os) {
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    true_type /* is a pointer */,
+                    T* p, ::std::ostream* os) {
+  if (p == NULL) {
+    *os << "NULL";
+  } else {
+    // We cannot use implicit_cast or static_cast here, as they don't
+    // work when p is a function pointer.
+    *os << reinterpret_cast<const void*>(p);
+  }
+}
+
+// Used to print a non-container, non-pointer value when the user
+// doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintTo(IsNotContainer /* dummy */,
+                    false_type /* is not a pointer */,
+                    const T& value, ::std::ostream* os) {
   ::testing_internal::DefaultPrintNonContainerTo(value, os);
 }
 
@@ -253,10 +277,11 @@ void DefaultPrintTo(IsNotContainer, const T& value, ::std::ostream* os) {
 // wants).
 template <typename T>
 void PrintTo(const T& value, ::std::ostream* os) {
-  // DefaultPrintTo() is overloaded.  The type of its first argument
-  // determines which version will be picked.  If T is an STL-style
-  // container, the version for container will be called.  Otherwise
-  // the generic version will be called.
+  // DefaultPrintTo() is overloaded.  The type of its first two
+  // arguments determine which version will be picked.  If T is an
+  // STL-style container, the version for container will be called; if
+  // T is a pointer, the pointer version will be called; otherwise the
+  // generic version will be called.
   //
   // Note that we check for container types here, prior to we check
   // for protocol message types in our operator<<.  The rationale is:
@@ -267,7 +292,14 @@ void PrintTo(const T& value, ::std::ostream* os) {
   // incompatible with Google Mock's format for the container
   // elements; therefore we check for container types here to ensure
   // that our format is used.
-  DefaultPrintTo(IsContainerTest<T>(0), value, os);
+  //
+  // The second argument of DefaultPrintTo() is needed to bypass a bug
+  // in Symbian's C++ compiler that prevents it from picking the right
+  // overload between:
+  //
+  //   PrintTo(const T& x, ...);
+  //   PrintTo(T* x, ...);
+  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
 }
 
 // The following list of PrintTo() overloads tells
@@ -323,22 +355,6 @@ inline void PrintTo(wchar_t* s, ::std::ostream* os) {
 }
 #endif
 
-// Overload for pointers that are neither char pointers nor member
-// pointers.  (A member variable pointer or member function pointer
-// doesn't really points to a location in the address space.  Their
-// representation is implementation-defined.  Therefore they will be
-// printed as raw bytes.)
-template <typename T>
-void PrintTo(T* p, ::std::ostream* os) {
-  if (p == NULL) {
-    *os << "NULL";
-  } else {
-    // We cannot use implicit_cast or static_cast here, as they don't
-    // work when p is a function pointer.
-    *os << reinterpret_cast<const void*>(p);
-  }
-}
-
 // Overload for C arrays.  Multi-dimensional arrays are printed
 // properly.
 

include/gmock/internal/gmock-port.h

@@ -162,7 +162,9 @@ inline To down_cast(From* f) {  // so we only accept pointers
     implicit_cast<From*, To>(0);
   }
 
+#if GTEST_HAS_RTTI
   assert(f == NULL || dynamic_cast<To>(f) != NULL);  // RTTI: debug mode only!
+#endif
   return static_cast<To>(f);
 }
 

test/gmock-actions_test.cc

@@ -646,16 +646,15 @@ TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
 
 #if GMOCK_HAS_PROTOBUF_
 
-// Tests that SetArgumentPointee<N>(proto_buffer) sets the variable
-// pointed to by the N-th (0-based) argument to proto_buffer.
+// Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf
+// variable pointed to by the N-th (0-based) argument to proto_buffer.
 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
-  typedef void MyFunction(bool, TestMessage*);
   TestMessage* const msg = new TestMessage;
   msg->set_member("yes");
   TestMessage orig_msg;
   orig_msg.CopyFrom(*msg);
 
-  Action<MyFunction> a = SetArgumentPointee<1>(*msg);
+  Action<void(bool, TestMessage*)> a = SetArgumentPointee<1>(*msg);
   // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
   // s.t. the action works even when the original proto_buffer has
   // died.  We ensure this behavior by deleting msg before using the
@@ -668,18 +667,41 @@ TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
   EXPECT_TRUE(orig_msg.Equals(dest));
 }
 
-// Tests that SetArgumentPointee<N>(proto2_buffer) sets the variable
-// pointed to by the N-th (0-based) argument to proto2_buffer.
+// Tests that SetArgumentPointee<N>(proto_buffer) sets the
+// ::ProtocolMessage variable pointed to by the N-th (0-based)
+// argument to proto_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
+  TestMessage* const msg = new TestMessage;
+  msg->set_member("yes");
+  TestMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::ProtocolMessage*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
+  // s.t. the action works even when the original proto_buffer has
+  // died.  We ensure this behavior by deleting msg before using the
+  // action.
+  delete msg;
+
+  TestMessage dest;
+  ::ProtocolMessage* const dest_base = &dest;
+  EXPECT_FALSE(orig_msg.Equals(dest));
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_TRUE(orig_msg.Equals(dest));
+}
+
+// Tests that SetArgumentPointee<N>(proto2_buffer) sets the v2
+// protobuf variable pointed to by the N-th (0-based) argument to
+// proto2_buffer.
 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
   using testing::internal::FooMessage;
-  typedef void MyFunction(bool, FooMessage*);
   FooMessage* const msg = new FooMessage;
   msg->set_int_field(2);
   msg->set_string_field("hi");
   FooMessage orig_msg;
   orig_msg.CopyFrom(*msg);
 
-  Action<MyFunction> a = SetArgumentPointee<1>(*msg);
+  Action<void(bool, FooMessage*)> a = SetArgumentPointee<1>(*msg);
   // SetArgumentPointee<N>(proto2_buffer) makes a copy of
   // proto2_buffer s.t. the action works even when the original
   // proto2_buffer has died.  We ensure this behavior by deleting msg
@@ -693,6 +715,32 @@ TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
   EXPECT_EQ("hi", dest.string_field());
 }
 
+// Tests that SetArgumentPointee<N>(proto2_buffer) sets the
+// proto2::Message variable pointed to by the N-th (0-based) argument
+// to proto2_buffer.
+TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
+  using testing::internal::FooMessage;
+  FooMessage* const msg = new FooMessage;
+  msg->set_int_field(2);
+  msg->set_string_field("hi");
+  FooMessage orig_msg;
+  orig_msg.CopyFrom(*msg);
+
+  Action<void(bool, ::proto2::Message*)> a = SetArgumentPointee<1>(*msg);
+  // SetArgumentPointee<N>(proto2_buffer) makes a copy of
+  // proto2_buffer s.t. the action works even when the original
+  // proto2_buffer has died.  We ensure this behavior by deleting msg
+  // before using the action.
+  delete msg;
+
+  FooMessage dest;
+  dest.set_int_field(0);
+  ::proto2::Message* const dest_base = &dest;
+  a.Perform(make_tuple(true, dest_base));
+  EXPECT_EQ(2, dest.int_field());
+  EXPECT_EQ("hi", dest.string_field());
+}
+
 #endif  // GMOCK_HAS_PROTOBUF_
 
 // Tests that SetArrayArgument<N>(first, last) sets the elements of the array