Update to current gtest/gmock.

testing/gmock/test/gmock-internal-utils_test.cc

 // Copyright 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 520 matching lines @@
   EXPECT_FALSE(LogIsVisible(INFO));
   EXPECT_FALSE(LogIsVisible(WARNING));
 }
 
 TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
   GMOCK_FLAG(verbose) = kWarningVerbosity;
   EXPECT_FALSE(LogIsVisible(INFO));
   EXPECT_TRUE(LogIsVisible(WARNING));
 }
 
-// TODO(wan@google.com): find a way to re-enable these tests.
-#if 0
+#if GTEST_HAS_STREAM_REDIRECTION_
 
 // Tests the Log() function.
 
 // Verifies that Log() behaves correctly for the given verbosity level
 // and log severity.
 void TestLogWithSeverity(const string& verbosity, LogSeverity severity,
                          bool should_print) {
   const string old_flag = GMOCK_FLAG(verbose);
   GMOCK_FLAG(verbose) = verbosity;
-  CaptureTestStdout();
+  CaptureStdout();
   Log(severity, "Test log.\n", 0);
   if (should_print) {
-    EXPECT_PRED2(RE::FullMatch,
-                 GetCapturedTestStdout(),
-                 severity == WARNING ?
-                 "\nGMOCK WARNING:\nTest log\\.\nStack trace:\n[\\s\\S]*" :
-                 "\nTest log\\.\nStack trace:\n[\\s\\S]*");
+    EXPECT_THAT(GetCapturedStdout().c_str(),
+                ContainsRegex(
+                    severity == WARNING ?
+                    "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" :
+                    "^\nTest log\\.\nStack trace:\n"));
   } else {
-    EXPECT_EQ("", GetCapturedTestStdout());
+    EXPECT_STREQ("", GetCapturedStdout().c_str());
   }
   GMOCK_FLAG(verbose) = old_flag;
 }
 
 // Tests that when the stack_frames_to_skip parameter is negative,
 // Log() doesn't include the stack trace in the output.
 TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
   GMOCK_FLAG(verbose) = kInfoVerbosity;
-  CaptureTestStdout();
+  CaptureStdout();
   Log(INFO, "Test log.\n", -1);
-  EXPECT_EQ("\nTest log.\n", GetCapturedTestStdout());
+  EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str());
 }
 
 // Tests that in opt mode, a positive stack_frames_to_skip argument is
 // treated as 0.
 TEST(LogTest, NoSkippingStackFrameInOptMode) {
-  CaptureTestStdout();
+  CaptureStdout();
   Log(WARNING, "Test log.\n", 100);
-  const string log = GetCapturedTestStdout();
-#ifdef NDEBUG
+  const String log = GetCapturedStdout();
+#if defined(NDEBUG) && GTEST_GOOGLE3_MODE_
   // In opt mode, no stack frame should be skipped.
   EXPECT_THAT(log, ContainsRegex("\nGMOCK WARNING:\n"
                                  "Test log\\.\n"
                                  "Stack trace:\n"
                                  ".+"));
 #else
   // In dbg mode, the stack frames should be skipped.
-  EXPECT_EQ("\nGMOCK WARNING:\n"
-            "Test log.\n"
-            "Stack trace:\n", log);
-#endif  // NDEBUG
+  EXPECT_STREQ("\nGMOCK WARNING:\n"
+               "Test log.\n"
+               "Stack trace:\n", log.c_str());
+#endif
 }
 
 // Tests that all logs are printed when the value of the
 // --gmock_verbose flag is "info".
 TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
   TestLogWithSeverity(kInfoVerbosity, INFO, true);
   TestLogWithSeverity(kInfoVerbosity, WARNING, true);
 }
 
 // Tests that only warnings are printed when the value of the
@@ skipping 10 matching lines @@
   TestLogWithSeverity(kErrorVerbosity, WARNING, false);
 }
 
 // Tests that only warnings are printed when the value of the
 // --gmock_verbose flag is invalid.
 TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
   TestLogWithSeverity("invalid", INFO, false);
   TestLogWithSeverity("invalid", WARNING, true);
 }
 
-#endif  // 0
+#endif  // GTEST_HAS_STREAM_REDIRECTION_
 
 TEST(TypeTraitsTest, true_type) {
   EXPECT_TRUE(true_type::value);
 }
 
 TEST(TypeTraitsTest, false_type) {
   EXPECT_FALSE(false_type::value);
 }
 
 TEST(TypeTraitsTest, is_reference) {
@@ skipping 16 matching lines @@
 }
 
 TEST(TypeTraitsTest, remove_reference) {
   EXPECT_TRUE((type_equals<char, remove_reference<char&>::type>::value));
   EXPECT_TRUE((type_equals<const int,
                remove_reference<const int&>::type>::value));
   EXPECT_TRUE((type_equals<int, remove_reference<int>::type>::value));
   EXPECT_TRUE((type_equals<double*, remove_reference<double*>::type>::value));
 }
 
-// TODO(wan@google.com): find a way to re-enable these tests.
-#if 0
+#if GTEST_HAS_STREAM_REDIRECTION_
 
 // Verifies that Log() behaves correctly for the given verbosity level
 // and log severity.
-string GrabOutput(void(*logger)(), const char* verbosity) {
+String GrabOutput(void(*logger)(), const char* verbosity) {
   const string saved_flag = GMOCK_FLAG(verbose);
   GMOCK_FLAG(verbose) = verbosity;
-  CaptureTestStdout();
+  CaptureStdout();
   logger();
   GMOCK_FLAG(verbose) = saved_flag;
-  return GetCapturedTestStdout();
+  return GetCapturedStdout();
 }
 
 class DummyMock {
  public:
   MOCK_METHOD0(TestMethod, void());
   MOCK_METHOD1(TestMethodArg, void(int dummy));
 };
 
 void ExpectCallLogger() {
   DummyMock mock;
   EXPECT_CALL(mock, TestMethod());
   mock.TestMethod();
 };
 
 // Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info".
 TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
   EXPECT_THAT(GrabOutput(ExpectCallLogger, kInfoVerbosity),
               HasSubstr("EXPECT_CALL(mock, TestMethod())"));
 }
 
 // Verifies that EXPECT_CALL doesn't log
 // if the --gmock_verbose flag is set to "warning".
 TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
-  EXPECT_EQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity));
+  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str());
 }
 
 // Verifies that EXPECT_CALL doesn't log
 // if the --gmock_verbose flag is set to "error".
 TEST(ExpectCallTest,  DoesNotLogWhenVerbosityIsError) {
-  EXPECT_EQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity));
+  EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str());
 }
 
 void OnCallLogger() {
   DummyMock mock;
   ON_CALL(mock, TestMethod());
 };
 
 // Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
 TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
   EXPECT_THAT(GrabOutput(OnCallLogger, kInfoVerbosity),
               HasSubstr("ON_CALL(mock, TestMethod())"));
 }
 
 // Verifies that ON_CALL doesn't log
 // if the --gmock_verbose flag is set to "warning".
 TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
-  EXPECT_EQ("", GrabOutput(OnCallLogger, kWarningVerbosity));
+  EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str());
 }
 
 // Verifies that ON_CALL doesn't log if
 // the --gmock_verbose flag is set to "error".
 TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
-  EXPECT_EQ("", GrabOutput(OnCallLogger, kErrorVerbosity));
+  EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str());
 }
 
 void OnCallAnyArgumentLogger() {
   DummyMock mock;
   ON_CALL(mock, TestMethodArg(_));
 }
 
 // Verifies that ON_CALL prints provided _ argument.
 TEST(OnCallTest, LogsAnythingArgument) {
   EXPECT_THAT(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity),
               HasSubstr("ON_CALL(mock, TestMethodArg(_)"));
 }
 
-#endif  // 0
+#endif  // GTEST_HAS_STREAM_REDIRECTION_
 
 // Tests ArrayEq().
 
 TEST(ArrayEqTest, WorksForDegeneratedArrays) {
   EXPECT_TRUE(ArrayEq(5, 5L));
   EXPECT_FALSE(ArrayEq('a', 0));
 }
 
 TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
   const int a[] = { 0, 1 };
@@ skipping 199 matching lines @@
   EXPECT_EQ(2, a3.begin()[2]);
 
   // Makes sure a1 and a3 aren't aliases.
   a1[0] = 3;
   EXPECT_EQ(0, a3.begin()[0]);
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace testing