diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc index 7dd83115..fc5d9e55 100644 --- a/test/gmock-internal-utils_test.cc +++ b/test/gmock-internal-utils_test.cc @@ -538,8 +538,7 @@ TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) { 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. @@ -549,16 +548,16 @@ 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; } @@ -567,18 +566,18 @@ void TestLogWithSeverity(const string& verbosity, LogSeverity severity, // 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" @@ -586,10 +585,10 @@ TEST(LogTest, NoSkippingStackFrameInOptMode) { ".+")); #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 @@ -620,7 +619,7 @@ TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) { TestLogWithSeverity("invalid", WARNING, true); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ TEST(TypeTraitsTest, true_type) { EXPECT_TRUE(true_type::value); @@ -657,18 +656,17 @@ TEST(TypeTraitsTest, remove_reference) { EXPECT_TRUE((type_equals::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 { @@ -692,13 +690,13 @@ TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) { // 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() { @@ -715,13 +713,13 @@ TEST(OnCallTest, LogsWhenVerbosityIsInfo) { // 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() { @@ -735,7 +733,7 @@ TEST(OnCallTest, LogsAnythingArgument) { HasSubstr("ON_CALL(mock, TestMethodArg(_)")); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ // Tests ArrayEq(). diff --git a/test/gmock-nice-strict_test.cc b/test/gmock-nice-strict_test.cc index 1d36e03e..f6f278e8 100644 --- a/test/gmock-nice-strict_test.cc +++ b/test/gmock-nice-strict_test.cc @@ -57,6 +57,11 @@ using testing::HasSubstr; using testing::NiceMock; using testing::StrictMock; +#if GTEST_HAS_STREAM_REDIRECTION_ +using testing::internal::CaptureStdout; +using testing::internal::GetCapturedStdout; +#endif // GTEST_HAS_STREAM_REDIRECTION_ + // Defines some mock classes needed by the tests. class Foo { @@ -102,17 +107,16 @@ class MockBar { GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar); }; -// TODO(wan@google.com): find a way to re-enable these tests. -#if 0 +#if GTEST_HAS_STREAM_REDIRECTION_ // Tests that a nice mock generates no warning for uninteresting calls. TEST(NiceMockTest, NoWarningForUninterestingCall) { NiceMock nice_foo; - CaptureTestStdout(); + CaptureStdout(); nice_foo.DoThis(); nice_foo.DoThat(true); - EXPECT_EQ("", GetCapturedTestStdout()); + EXPECT_STREQ("", GetCapturedStdout().c_str()); } // Tests that a nice mock generates no warning for uninteresting calls @@ -123,9 +127,9 @@ TEST(NiceMockTest, NoWarningForUninterestingCallAfterDeath) { ON_CALL(*nice_foo, DoThis()) .WillByDefault(Invoke(nice_foo, &MockFoo::Delete)); - CaptureTestStdout(); + CaptureStdout(); nice_foo->DoThis(); - EXPECT_EQ("", GetCapturedTestStdout()); + EXPECT_STREQ("", GetCapturedStdout().c_str()); } // Tests that a nice mock generates informational logs for @@ -134,18 +138,18 @@ TEST(NiceMockTest, InfoForUninterestingCall) { NiceMock nice_foo; GMOCK_FLAG(verbose) = "info"; - CaptureTestStdout(); + CaptureStdout(); nice_foo.DoThis(); - EXPECT_THAT(GetCapturedTestStdout(), + EXPECT_THAT(GetCapturedStdout(), HasSubstr("Uninteresting mock function call")); - CaptureTestStdout(); + CaptureStdout(); nice_foo.DoThat(true); - EXPECT_THAT(GetCapturedTestStdout(), + EXPECT_THAT(GetCapturedStdout(), HasSubstr("Uninteresting mock function call")); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ // Tests that a nice mock allows expected calls. TEST(NiceMockTest, AllowsExpectedCall) { diff --git a/test/gmock-spec-builders_test.cc b/test/gmock-spec-builders_test.cc index 3a7b4189..e5fc2ec9 100644 --- a/test/gmock-spec-builders_test.cc +++ b/test/gmock-spec-builders_test.cc @@ -87,13 +87,20 @@ using testing::Mock; using testing::Ne; using testing::Return; using testing::Sequence; +using testing::internal::ExpectationTester; using testing::internal::g_gmock_mutex; using testing::internal::kErrorVerbosity; using testing::internal::kInfoVerbosity; using testing::internal::kWarningVerbosity; -using testing::internal::ExpectationTester; +using testing::internal::String; using testing::internal::string; +#if GTEST_HAS_STREAM_REDIRECTION_ +using testing::HasSubstr; +using testing::internal::CaptureStdout; +using testing::internal::GetCapturedStdout; +#endif // GTEST_HAS_STREAM_REDIRECTION_ + class Result {}; class MockA { @@ -511,13 +518,12 @@ TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) { }, "to be called once"); } -// TODO(wan@google.com): find a way to re-enable these tests. -#if 0 +#if GTEST_HAS_STREAM_REDIRECTION_ // Tests that Google Mock doesn't print a warning when the number of // WillOnce() is adequate. TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) { - CaptureTestStdout(); + CaptureStdout(); { MockB b; @@ -547,14 +553,13 @@ TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) { b.DoB(2); b.DoB(3); } - const string& output = GetCapturedTestStdout(); - EXPECT_EQ("", output); + EXPECT_STREQ("", GetCapturedStdout().c_str()); } // Tests that Google Mock warns on having too many actions in an // expectation compared to its cardinality. TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) { - CaptureTestStdout(); + CaptureStdout(); { MockB b; @@ -586,7 +591,7 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) { b.DoB(1); b.DoB(2); } - const string& output = GetCapturedTestStdout(); + const String output = GetCapturedStdout(); EXPECT_PRED_FORMAT2( IsSubstring, "Too many actions specified in EXPECT_CALL(b, DoB())...\n" @@ -626,9 +631,9 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) { .Times(Between(2, 3)) .WillOnce(Return(1)); - CaptureTestStdout(); + CaptureStdout(); b.DoB(); - const string& output = GetCapturedTestStdout(); + const String output = GetCapturedStdout(); EXPECT_PRED_FORMAT2( IsSubstring, "Too few actions specified in EXPECT_CALL(b, DoB())...\n" @@ -638,7 +643,7 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) { b.DoB(); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ // Tests the semantics of ON_CALL(). @@ -792,8 +797,7 @@ TEST(ExpectCallTest, NthMatchTakesNthAction) { EXPECT_EQ(3, b.DoB()); } -// TODO(wan@google.com): find a way to re-enable these tests. -#if 0 +#if GTEST_HAS_STREAM_REDIRECTION_ // Tests that the default action is taken when the WillOnce(...) list is // exhausted and there is no WillRepeatedly(). @@ -806,29 +810,29 @@ TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) { .WillOnce(Return(1)) .WillOnce(Return(2)); - CaptureTestStdout(); + CaptureStdout(); EXPECT_EQ(0, b.DoB(1)); // Shouldn't generate a warning as the // expectation has no action clause at all. EXPECT_EQ(1, b.DoB()); EXPECT_EQ(2, b.DoB()); - const string& output1 = GetCapturedTestStdout(); - EXPECT_EQ("", output1); + const String output1 = GetCapturedStdout(); + EXPECT_STREQ("", output1.c_str()); - CaptureTestStdout(); + CaptureStdout(); EXPECT_EQ(0, b.DoB()); EXPECT_EQ(0, b.DoB()); - const string& output2 = GetCapturedTestStdout(); - EXPECT_PRED2(RE::PartialMatch, output2, - "Actions ran out\\.\n" - "Called 3 times, but only 2 WillOnce\\(\\)s are specified - " - "returning default value\\."); - EXPECT_PRED2(RE::PartialMatch, output2, - "Actions ran out\\.\n" - "Called 4 times, but only 2 WillOnce\\(\\)s are specified - " - "returning default value\\."); + const String output2 = GetCapturedStdout(); + EXPECT_THAT(output2.c_str(), + HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n" + "Called 3 times, but only 2 WillOnce()s are specified" + " - returning default value.")); + EXPECT_THAT(output2.c_str(), + HasSubstr("Actions ran out in EXPECT_CALL(b, DoB())...\n" + "Called 4 times, but only 2 WillOnce()s are specified" + " - returning default value.")); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ // Tests that the WillRepeatedly() action is taken when the WillOnce(...) // list is exhausted. @@ -1779,16 +1783,15 @@ class MockC { GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC); }; -// TODO(wan@google.com): find a way to re-enable these tests. -#if 0 +#if GTEST_HAS_STREAM_REDIRECTION_ // Tests that an uninteresting mock function call generates a warning // containing the stack trace. TEST(FunctionCallMessageTest, UninterestingCallGeneratesFyiWithStackTrace) { MockC c; - CaptureTestStdout(); + CaptureStdout(); c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable()); - const string& output = GetCapturedTestStdout(); + const String output = GetCapturedStdout(); EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output); EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output); #ifndef NDEBUG @@ -1797,14 +1800,14 @@ TEST(FunctionCallMessageTest, UninterestingCallGeneratesFyiWithStackTrace) { // Verifies that a void mock function's name appears in the stack // trace. - EXPECT_PRED_FORMAT2(IsSubstring, "::MockC::VoidMethod(", output); + EXPECT_PRED_FORMAT2(IsSubstring, "VoidMethod(", output); // Verifies that a non-void mock function's name appears in the // stack trace. - CaptureTestStdout(); + CaptureStdout(); c.NonVoidMethod(); - const string& output2 = GetCapturedTestStdout(); - EXPECT_PRED_FORMAT2(IsSubstring, "::MockC::NonVoidMethod(", output2); + const String output2 = GetCapturedStdout(); + EXPECT_PRED_FORMAT2(IsSubstring, "NonVoidMethod(", output2); #endif // NDEBUG } @@ -1813,26 +1816,27 @@ TEST(FunctionCallMessageTest, UninterestingCallGeneratesFyiWithStackTrace) { TEST(FunctionCallMessageTest, UninterestingCallPrintsArgumentsAndReturnValue) { // A non-void mock function. MockB b; - CaptureTestStdout(); + CaptureStdout(); b.DoB(); - const string& output1 = GetCapturedTestStdout(); + const String output1 = GetCapturedStdout(); EXPECT_PRED_FORMAT2( IsSubstring, "Uninteresting mock function call - returning default value.\n" " Function call: DoB()\n" - " Returns: 0\n", output1); + " Returns: 0\n", output1.c_str()); // Makes sure the return value is printed. // A void mock function. MockC c; - CaptureTestStdout(); + CaptureStdout(); c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable()); - const string& output2 = GetCapturedTestStdout(); - EXPECT_PRED2(RE::PartialMatch, output2, - "Uninteresting mock function call - returning directly\\.\n" - " Function call: VoidMethod" - "\\(false, 5, \"Hi\", NULL, @0x\\w+ " - "Printable, 4-byte object <0000 0000>\\)"); + const String output2 = GetCapturedStdout(); + EXPECT_THAT(output2.c_str(), + ContainsRegex( + "Uninteresting mock function call - returning directly\\.\n" + " Function call: VoidMethod" + "\\(false, 5, \"Hi\", NULL, @.+ " + "Printable, 4-byte object <0000 0000>\\)")); // A void function has no return value to print. } @@ -1844,18 +1848,21 @@ class GMockVerboseFlagTest : public testing::Test { // should_print is true, the output should match the given regex and // contain the given function name in the stack trace. When it's // false, the output should be empty.) - void VerifyOutput(const string& output, bool should_print, - const string& regex, + void VerifyOutput(const String& output, bool should_print, + const string& expected_substring, const string& function_name) { if (should_print) { - EXPECT_PRED2(RE::PartialMatch, output, regex); + EXPECT_THAT(output.c_str(), HasSubstr(expected_substring)); #ifndef NDEBUG // We check the stack trace content in dbg-mode only, as opt-mode // may inline the call we are interested in seeing. - EXPECT_PRED_FORMAT2(IsSubstring, function_name, output); + EXPECT_THAT(output.c_str(), HasSubstr(function_name)); +#else + // Suppresses 'unused function parameter' warnings. + static_cast(function_name); #endif // NDEBUG } else { - EXPECT_EQ("", output); + EXPECT_STREQ("", output.c_str()); } } @@ -1867,27 +1874,27 @@ class GMockVerboseFlagTest : public testing::Test { .WillOnce(Return(true)); // A void-returning function. - CaptureTestStdout(); + CaptureStdout(); a.DoA(5); VerifyOutput( - GetCapturedTestStdout(), + GetCapturedStdout(), should_print, - "Expected mock function call\\.\n" - " Function call: DoA\\(5\\)\n" - "Stack trace:", - "MockA::DoA"); + "Mock function call matches EXPECT_CALL(a, DoA(5))...\n" + " Function call: DoA(5)\n" + "Stack trace:\n", + "DoA"); // A non-void-returning function. - CaptureTestStdout(); + CaptureStdout(); a.Binary(2, 1); VerifyOutput( - GetCapturedTestStdout(), + GetCapturedStdout(), should_print, - "Expected mock function call\\.\n" - " Function call: Binary\\(2, 1\\)\n" + "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n" + " Function call: Binary(2, 1)\n" " Returns: true\n" - "Stack trace:", - "MockA::Binary"); + "Stack trace:\n", + "Binary"); } // Tests how the flag affects uninteresting calls. @@ -1895,31 +1902,29 @@ class GMockVerboseFlagTest : public testing::Test { MockA a; // A void-returning function. - CaptureTestStdout(); + CaptureStdout(); a.DoA(5); VerifyOutput( - GetCapturedTestStdout(), + GetCapturedStdout(), should_print, "\nGMOCK WARNING:\n" - "Uninteresting mock function call - returning directly\\.\n" - " Function call: DoA\\(5\\)\n" - "Stack trace:\n" - "[\\s\\S]*", - "MockA::DoA"); + "Uninteresting mock function call - returning directly.\n" + " Function call: DoA(5)\n" + "Stack trace:\n", + "DoA"); // A non-void-returning function. - CaptureTestStdout(); + CaptureStdout(); a.Binary(2, 1); VerifyOutput( - GetCapturedTestStdout(), + GetCapturedStdout(), should_print, "\nGMOCK WARNING:\n" - "Uninteresting mock function call - returning default value\\.\n" - " Function call: Binary\\(2, 1\\)\n" + "Uninteresting mock function call - returning default value.\n" + " Function call: Binary(2, 1)\n" " Returns: false\n" - "Stack trace:\n" - "[\\s\\S]*", - "MockA::Binary"); + "Stack trace:\n", + "Binary"); } }; @@ -1955,7 +1960,7 @@ TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) { TestUninterestingCall(true); } -#endif // 0 +#endif // GTEST_HAS_STREAM_REDIRECTION_ // A helper class that generates a failure when printed. We use it to // ensure that Google Mock doesn't print a value (even to an internal