Fixes compiler warning when built with -std=c++0x.

include/gtest/gtest-printers.h

@@ -121,7 +121,7 @@ enum TypeKind {
   kProtobuf,              // a protobuf type
   kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
                           // (e.g. a named or unnamed enum type)
-  kOtherType,             // anything else
+  kOtherType              // anything else
 };
 
 // TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called

include/gtest/gtest.h

@@ -281,20 +281,33 @@ class GTEST_API_ AssertionResult {
   // assertion's expectation). When nothing has been streamed into the
   // object, returns an empty string.
   const char* message() const {
-    return message_.get() != NULL && message_->c_str() != NULL ?
+    return message_.get() != NULL ?  message_->c_str() : "";
-           message_->c_str() : "";
   }
   // TODO(vladl@google.com): Remove this after making sure no clients use it.
   // Deprecated; please use message() instead.
   const char* failure_message() const { return message(); }
 
   // Streams a custom failure message into this object.
-  template <typename T> AssertionResult& operator<<(const T& value);
+  template <typename T> AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
 
  private:
-  // No implementation - we want AssertionResult to be
+  // Appends the contents of message to message_.
-  // copy-constructible but not assignable.
+  void AppendMessage(const Message& a_message) {
-  void operator=(const AssertionResult& other);
+    if (message_.get() == NULL)
+      message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
 
   // Stores result of the assertion predicate.
   bool success_;
@@ -302,19 +315,10 @@ class GTEST_API_ AssertionResult {
   // construct is not satisfied with the predicate's outcome.
   // Referenced via a pointer to avoid taking too much stack frame space
   // with test assertions.
-  internal::scoped_ptr<internal::String> message_;
+  internal::scoped_ptr< ::std::string> message_;
-};  // class AssertionResult
 
-// Streams a custom failure message into this object.
+  GTEST_DISALLOW_ASSIGN_(AssertionResult);
-template <typename T>
+};
-AssertionResult& AssertionResult::operator<<(const T& value) {
-  Message msg;
-  if (message_.get() != NULL)
-    msg << *message_;
-  msg << value;
-  message_.reset(new internal::String(msg.GetString()));
-  return *this;
-}
 
 // Makes a successful assertion result.
 GTEST_API_ AssertionResult AssertionSuccess();

src/gtest.cc

@@ -945,8 +945,8 @@ Message& Message::operator <<(const ::wstring& wstr) {
 AssertionResult::AssertionResult(const AssertionResult& other)
     : success_(other.success_),
       message_(other.message_.get() != NULL ?
-               new internal::String(*other.message_) :
+               new ::std::string(*other.message_) :
-               static_cast<internal::String*>(NULL)) {
+               static_cast< ::std::string*>(NULL)) {
 }
 
 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.

test/gtest_unittest.cc

@@ -34,6 +34,7 @@
 
 #include "gtest/gtest.h"
 #include <vector>
+#include <ostream>
 
 // Verifies that the command line flag variables can be accessed
 // in code once <gtest/gtest.h> has been #included.
@@ -4902,7 +4903,7 @@ TEST(AssertionResultTest, ConstructionWorks) {
   EXPECT_STREQ("ghi", r5.message());
 }
 
-// Tests that the negation fips the predicate result but keeps the message.
+// Tests that the negation flips the predicate result but keeps the message.
 TEST(AssertionResultTest, NegationWorks) {
   AssertionResult r1 = AssertionSuccess() << "abc";
   EXPECT_FALSE(!r1);
@@ -4919,6 +4920,12 @@ TEST(AssertionResultTest, StreamingWorks) {
   EXPECT_STREQ("abcd0true", r.message());
 }
 
+TEST(AssertionResultTest, CanStreamOstreamManipulators) {
+  AssertionResult r = AssertionSuccess();
+  r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
+  EXPECT_STREQ("Data\n\\0Will be visible", r.message());
+}
+
 // Tests streaming a user type whose definition and operator << are
 // both in the global namespace.
 class Base {