Googletest export

googletest/include/gtest/gtest-printers.h

@@ -639,7 +639,15 @@ inline void PrintTo(absl::string_view sp, ::std::ostream* os) {
 #endif  // GTEST_HAS_ABSL
 
 #if GTEST_LANG_CXX11
+
 inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
+
+template <typename T>
+void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
+  // Delegate to wrapped value.
+  PrintTo(ref.get(), os);
+}
+
 #endif  // GTEST_LANG_CXX11
 
 #if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_

googletest/include/gtest/internal/gtest-internal.h

@@ -1189,19 +1189,6 @@ class NativeArray {
   GTEST_DISALLOW_ASSIGN_(NativeArray);
 };
 
-class AdditionalMessage
-{
-public:
-  AdditionalMessage(const char* message) : value(message) {}
-  void set(const std::string& message) { value = message; }
-  operator bool() const { return true; }
-
-  const std::string& get() const { return value; }
-
-private:
-  std::string value;
-};
-
 }  // namespace internal
 }  // namespace testing
 
@@ -1229,56 +1216,43 @@ private:
 
 #define GTEST_TEST_THROW_(statement, expected_exception, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AdditionalMessage message = "") { \
+  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
     bool gtest_caught_expected = false; \
     try { \
-      try { \
-        GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-      } \
-      catch (expected_exception const&) { \
-        gtest_caught_expected = true; \
-        throw; \
-      } \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
     } \
-    catch (const std::exception& e) { \
-      if (!gtest_caught_expected) { \
-        message.set("it throws a different type " \
-            "with message: " + std::string(e.what())); \
-        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-      } \
+    catch (expected_exception const&) { \
+      gtest_caught_expected = true; \
     } \
     catch (...) { \
-      if (!gtest_caught_expected) { \
-        message.set("it throws a different type."); \
-        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
-      } \
+      gtest_msg.value = \
+          "Expected: " #statement " throws an exception of type " \
+          #expected_exception ".\n  Actual: it throws a different type."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
     } \
     if (!gtest_caught_expected) { \
-      message.set("it throws nothing."); \
+      gtest_msg.value = \
+          "Expected: " #statement " throws an exception of type " \
+          #expected_exception ".\n  Actual: it throws nothing."; \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
     } \
   } else \
     GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
-      fail(("Expected: " #statement " throws an exception of type " \
-            #expected_exception ".\n  Actual: " + message.get()).c_str())
+      fail(gtest_msg.value)
 
 #define GTEST_TEST_NO_THROW_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::AdditionalMessage message = ".") { \
+  if (::testing::internal::AlwaysTrue()) { \
     try { \
       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
     } \
-    catch (const std::exception& e) { \
-      message.set(std::string(": ") + e.what()); \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
-    } \
     catch (...) { \
       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
     } \
   } else \
     GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail(("Expected: " #statement " doesn't throw an exception.\n" \
-           "  Actual: it throws" + message.get()).c_str())
+      fail("Expected: " #statement " doesn't throw an exception.\n" \
+           "  Actual: it throws.")
 
 #define GTEST_TEST_ANY_THROW_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \

googletest/test/googletest-printers-test.cc

@@ -1112,9 +1112,25 @@ TEST(PrintStdTupleTest, NestedTuple) {
 #endif  // GTEST_LANG_CXX11
 
 #if GTEST_LANG_CXX11
+
 TEST(PrintNullptrT, Basic) {
   EXPECT_EQ("(nullptr)", Print(nullptr));
 }
+
+TEST(PrintReferenceWrapper, Printable) {
+  int x = 5;
+  EXPECT_EQ("5", Print(std::ref(x)));
+  EXPECT_EQ("5", Print(std::cref(x)));
+}
+
+TEST(PrintReferenceWrapper, Unprintable) {
+  ::foo::UnprintableInFoo up;
+  EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
+            Print(std::ref(up)));
+  EXPECT_EQ("16-byte object <EF-12 00-00 34-AB 00-00 00-00 00-00 00-00 00-00>",
+            Print(std::cref(up)));
+}
+
 #endif  // GTEST_LANG_CXX11
 
 // Tests printing user-defined unprintable types.

googletest/test/gtest_unittest.cc

@@ -3328,9 +3328,6 @@ TEST_F(SingleEvaluationTest, OtherCases) {
 void ThrowAnInteger() {
   throw 1;
 }
-void ThrowAnException(const char* what) {
-  throw std::runtime_error(what);
-}
 
 // Tests that assertion arguments are evaluated exactly once.
 TEST_F(SingleEvaluationTest, ExceptionTests) {
@@ -3373,20 +3370,6 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
   // failed EXPECT_ANY_THROW
   EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
   EXPECT_EQ(7, a_);
-
-  // failed EXPECT_THROW std::exception, throws different
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnInteger();
-  }, std::exception), "throws a different type");
-  EXPECT_EQ(8, a_);
-
-  // failed EXPECT_THROW, throws std::exception
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW({  // NOLINT
-    a_++;
-    ThrowAnException("blablubb");
-  }, bool), "throws a different type with message: blablubb");
-  EXPECT_EQ(9, a_);
 }
 
 #endif  // GTEST_HAS_EXCEPTIONS
@@ -3819,11 +3802,6 @@ TEST(AssertionTest, ASSERT_THROW) {
       ASSERT_THROW(ThrowNothing(), bool),
       "Expected: ThrowNothing() throws an exception of type bool.\n"
       "  Actual: it throws nothing.");
-
-  EXPECT_FATAL_FAILURE(
-      ASSERT_THROW(ThrowAnException("buuh"), bool),
-      "Expected: ThrowAnException(\"buuh\") throws an exception of type bool.\n"
-      "  Actual: it throws a different type with message: buuh");
 }
 
 // Tests ASSERT_NO_THROW.
@@ -3832,9 +3810,6 @@ TEST(AssertionTest, ASSERT_NO_THROW) {
   EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
                        "Expected: ThrowAnInteger() doesn't throw an exception."
                        "\n  Actual: it throws.");
-  EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnException("blablubb")),
-                       "Expected: ThrowAnException(\"blablubb\") doesn't throw an exception."
-                       "\n  Actual: it throws: blablubb");
 }
 
 // Tests ASSERT_ANY_THROW.
@@ -4561,16 +4536,13 @@ TEST(ExpectTest, EXPECT_GT) {
 // Tests EXPECT_THROW.
 TEST(ExpectTest, EXPECT_THROW) {
   EXPECT_THROW(ThrowAnInteger(), int);
-  EXPECT_THROW(ThrowAnException(""), std::exception);
   EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
-                          "Expected: ThrowAnInteger() throws an exception of type bool.\n"
-                          "  Actual: it throws a different type.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowNothing(), bool),
-                         "Expected: ThrowNothing() throws an exception of type bool.\n"
-                          "  Actual: it throws nothing.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnException("buuh"), bool),
-                         "Expected: ThrowAnException(\"buuh\") throws an exception of type bool.\n"
-                          "  Actual: it throws a different type with message: buuh");
+                          "Expected: ThrowAnInteger() throws an exception of "
+                          "type bool.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW(ThrowNothing(), bool),
+      "Expected: ThrowNothing() throws an exception of type bool.\n"
+      "  Actual: it throws nothing.");
 }
 
 // Tests EXPECT_NO_THROW.
@@ -4579,9 +4551,6 @@ TEST(ExpectTest, EXPECT_NO_THROW) {
   EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
                           "Expected: ThrowAnInteger() doesn't throw an "
                           "exception.\n  Actual: it throws.");
-  EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnException("blablubb")),
-                          "Expected: ThrowAnException(\"blablubb\") doesn't throw an "
-                          "exception.\n  Actual: it throws: blablubb");
 }
 
 // Tests EXPECT_ANY_THROW.