From bf55085d456e3ee55eb234c98c435e54d0a2d5aa Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Tue, 9 Jun 2009 06:09:53 +0000 Subject: [PATCH] Implements .With() as a synonym of .WithArguments(); implements AllArgs(m) as a synonym of m; relies on gtest-port to #include tuple; fixes a compatibility with Symbian. --- include/gmock/gmock-matchers.h | 10 +++ include/gmock/gmock-spec-builders.h | 104 +++++++++++++++----------- include/gmock/gmock.h | 8 +- include/gmock/internal/gmock-port.h | 14 +--- src/gmock-internal-utils.cc | 17 +++-- test/gmock-generated-matchers_test.cc | 2 +- test/gmock-matchers_test.cc | 30 ++++++++ test/gmock-spec-builders_test.cc | 67 ++++++++++++----- test/gmock_link_test.h | 1 + test/gmock_output_test_.cc | 12 +-- test/gmock_output_test_golden.txt | 12 +-- 11 files changed, 176 insertions(+), 101 deletions(-) diff --git a/include/gmock/gmock-matchers.h b/include/gmock/gmock-matchers.h index f4d5b0a6..dc252e3e 100644 --- a/include/gmock/gmock-matchers.h +++ b/include/gmock/gmock-matchers.h @@ -2354,6 +2354,16 @@ inline bool Value(const T& value, M matcher) { return testing::Matches(matcher)(value); } +// AllArgs(m) is a synonym of m. This is useful in +// +// EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq())); +// +// which is easier to read than +// +// EXPECT_CALL(foo, Bar(_, _)).With(Eq()); +template +inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; } + // These macros allow using matchers to check values in Google Test // tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher) // succeed iff the value matches the matcher. If the assertion fails, diff --git a/include/gmock/gmock-spec-builders.h b/include/gmock/gmock-spec-builders.h index c002ae7f..b570c00c 100644 --- a/include/gmock/gmock-spec-builders.h +++ b/include/gmock/gmock-spec-builders.h @@ -37,16 +37,16 @@ // a mock method. The syntax is: // // ON_CALL(mock_object, Method(argument-matchers)) -// .WithArguments(multi-argument-matcher) +// .With(multi-argument-matcher) // .WillByDefault(action); // -// where the .WithArguments() clause is optional. +// where the .With() clause is optional. // // A user can use the EXPECT_CALL() macro to specify an expectation on // a mock method. The syntax is: // // EXPECT_CALL(mock_object, Method(argument-matchers)) -// .WithArguments(multi-argument-matchers) +// .With(multi-argument-matchers) // .Times(cardinality) // .InSequence(sequences) // .WillOnce(action) @@ -144,31 +144,39 @@ class DefaultActionSpec { // bug in Symbian's C++ compiler (cannot decide between two // overloaded constructors of Matcher). extra_matcher_(A()), - last_clause_(NONE) { + last_clause_(kNone) { } // Where in the source file was the default action spec defined? const char* file() const { return file_; } int line() const { return line_; } - // Implements the .WithArguments() clause. - DefaultActionSpec& WithArguments(const Matcher& m) { + // Implements the .With() clause. + DefaultActionSpec& With(const Matcher& m) { // Makes sure this is called at most once. - ExpectSpecProperty(last_clause_ < WITH_ARGUMENTS, - ".WithArguments() cannot appear " + ExpectSpecProperty(last_clause_ < kWith, + ".With() cannot appear " "more than once in an ON_CALL()."); - last_clause_ = WITH_ARGUMENTS; + last_clause_ = kWith; extra_matcher_ = m; return *this; } + // Implements the .WithArguments() clause as a synonym of .With() + // for backward compatibility. WithArguments() is deprecated and + // new code should always use With(), as .With(Args<1, 2>(m)) is + // clearer than .WithArguments(Args<1, 2>(m)). + DefaultActionSpec& WithArguments(const Matcher& m) { + return With(m); + } + // Implements the .WillByDefault() clause. DefaultActionSpec& WillByDefault(const Action& action) { - ExpectSpecProperty(last_clause_ < WILL_BY_DEFAULT, + ExpectSpecProperty(last_clause_ < kWillByDefault, ".WillByDefault() must appear " "exactly once in an ON_CALL()."); - last_clause_ = WILL_BY_DEFAULT; + last_clause_ = kWillByDefault; ExpectSpecProperty(!action.IsDoDefault(), "DoDefault() cannot be used in ON_CALL()."); @@ -183,7 +191,7 @@ class DefaultActionSpec { // Returns the action specified by the user. const Action& GetAction() const { - AssertSpecProperty(last_clause_ == WILL_BY_DEFAULT, + AssertSpecProperty(last_clause_ == kWillByDefault, ".WillByDefault() must appear exactly " "once in an ON_CALL()."); return action_; @@ -193,9 +201,9 @@ class DefaultActionSpec { enum Clause { // Do not change the order of the enum members! The run-time // syntax checking relies on it. - NONE, - WITH_ARGUMENTS, - WILL_BY_DEFAULT, + kNone, + kWith, + kWillByDefault, }; // Asserts that the ON_CALL() statement has a certain property. @@ -211,7 +219,7 @@ class DefaultActionSpec { // The information in statement // // ON_CALL(mock_object, Method(matchers)) - // .WithArguments(multi-argument-matcher) + // .With(multi-argument-matcher) // .WillByDefault(action); // // is recorded in the data members like this: @@ -228,7 +236,7 @@ class DefaultActionSpec { Action action_; // The last clause in the ON_CALL() statement as seen so far. - // Initially NONE and changes as the statement is parsed. + // Initially kNone and changes as the statement is parsed. Clause last_clause_; }; // class DefaultActionSpec @@ -437,13 +445,13 @@ class ExpectationBase { enum Clause { // Don't change the order of the enum members! - NONE, - WITH_ARGUMENTS, - TIMES, - IN_SEQUENCE, - WILL_ONCE, - WILL_REPEATEDLY, - RETIRES_ON_SATURATION, + kNone, + kWith, + kTimes, + kInSequence, + kWillOnce, + kWillRepeatedly, + kRetiresOnSaturation, }; // Asserts that the EXPECT_CALL() statement has the given property. @@ -581,7 +589,7 @@ class Expectation : public ExpectationBase { repeated_action_specified_(false), repeated_action_(DoDefault()), retires_on_saturation_(false), - last_clause_(NONE), + last_clause_(kNone), action_count_checked_(false) {} virtual ~Expectation() { @@ -590,36 +598,42 @@ class Expectation : public ExpectationBase { CheckActionCountIfNotDone(); } - // Implements the .WithArguments() clause. - Expectation& WithArguments(const Matcher& m) { - if (last_clause_ == WITH_ARGUMENTS) { + // Implements the .With() clause. + Expectation& With(const Matcher& m) { + if (last_clause_ == kWith) { ExpectSpecProperty(false, - ".WithArguments() cannot appear " + ".With() cannot appear " "more than once in an EXPECT_CALL()."); } else { - ExpectSpecProperty(last_clause_ < WITH_ARGUMENTS, - ".WithArguments() must be the first " + ExpectSpecProperty(last_clause_ < kWith, + ".With() must be the first " "clause in an EXPECT_CALL()."); } - last_clause_ = WITH_ARGUMENTS; + last_clause_ = kWith; extra_matcher_ = m; return *this; } + // Implements the .WithArguments() clause as a synonym of .With(). + // This is deprecated and new code should always use With(). + Expectation& WithArguments(const Matcher& m) { + return With(m); + } + // Implements the .Times() clause. Expectation& Times(const Cardinality& cardinality) { - if (last_clause_ ==TIMES) { + if (last_clause_ ==kTimes) { ExpectSpecProperty(false, ".Times() cannot appear " "more than once in an EXPECT_CALL()."); } else { - ExpectSpecProperty(last_clause_ < TIMES, + ExpectSpecProperty(last_clause_ < kTimes, ".Times() cannot appear after " ".InSequence(), .WillOnce(), .WillRepeatedly(), " "or .RetiresOnSaturation()."); } - last_clause_ = TIMES; + last_clause_ = kTimes; ExpectationBase::SpecifyCardinality(cardinality); return *this; @@ -632,11 +646,11 @@ class Expectation : public ExpectationBase { // Implements the .InSequence() clause. Expectation& InSequence(const Sequence& s) { - ExpectSpecProperty(last_clause_ <= IN_SEQUENCE, + ExpectSpecProperty(last_clause_ <= kInSequence, ".InSequence() cannot appear after .WillOnce()," " .WillRepeatedly(), or " ".RetiresOnSaturation()."); - last_clause_ = IN_SEQUENCE; + last_clause_ = kInSequence; s.AddExpectation(owner_->GetLinkedExpectationBase(this)); return *this; @@ -660,10 +674,10 @@ class Expectation : public ExpectationBase { // Implements the .WillOnce() clause. Expectation& WillOnce(const Action& action) { - ExpectSpecProperty(last_clause_ <= WILL_ONCE, + ExpectSpecProperty(last_clause_ <= kWillOnce, ".WillOnce() cannot appear after " ".WillRepeatedly() or .RetiresOnSaturation()."); - last_clause_ = WILL_ONCE; + last_clause_ = kWillOnce; actions_.push_back(action); if (!cardinality_specified()) { @@ -674,16 +688,16 @@ class Expectation : public ExpectationBase { // Implements the .WillRepeatedly() clause. Expectation& WillRepeatedly(const Action& action) { - if (last_clause_ == WILL_REPEATEDLY) { + if (last_clause_ == kWillRepeatedly) { ExpectSpecProperty(false, ".WillRepeatedly() cannot appear " "more than once in an EXPECT_CALL()."); } else { - ExpectSpecProperty(last_clause_ < WILL_REPEATEDLY, + ExpectSpecProperty(last_clause_ < kWillRepeatedly, ".WillRepeatedly() cannot appear " "after .RetiresOnSaturation()."); } - last_clause_ = WILL_REPEATEDLY; + last_clause_ = kWillRepeatedly; repeated_action_specified_ = true; repeated_action_ = action; @@ -699,10 +713,10 @@ class Expectation : public ExpectationBase { // Implements the .RetiresOnSaturation() clause. Expectation& RetiresOnSaturation() { - ExpectSpecProperty(last_clause_ < RETIRES_ON_SATURATION, + ExpectSpecProperty(last_clause_ < kRetiresOnSaturation, ".RetiresOnSaturation() cannot appear " "more than once."); - last_clause_ = RETIRES_ON_SATURATION; + last_clause_ = kRetiresOnSaturation; retires_on_saturation_ = true; // Now that no more action clauses can be specified, we check @@ -717,7 +731,7 @@ class Expectation : public ExpectationBase { return matchers_; } - // Returns the matcher specified by the .WithArguments() clause. + // Returns the matcher specified by the .With() clause. const Matcher& extra_matcher() const { return extra_matcher_; } diff --git a/include/gmock/gmock.h b/include/gmock/gmock.h index 22e70287..29d9727c 100644 --- a/include/gmock/gmock.h +++ b/include/gmock/gmock.h @@ -39,14 +39,14 @@ // This file implements the following syntax: // // ON_CALL(mock_object.Method(...)) -// .WithArguments(...) ? +// .With(...) ? // .WillByDefault(...); // -// where WithArguments() is optional and WillByDefault() must appear -// exactly once. +// where With() is optional and WillByDefault() must appear exactly +// once. // // EXPECT_CALL(mock_object.Method(...)) -// .WithArguments(...) ? +// .With(...) ? // .Times(...) ? // .InSequence(...) * // .WillOnce(...) * diff --git a/include/gmock/internal/gmock-port.h b/include/gmock/internal/gmock-port.h index 75be9edd..9ee8f728 100644 --- a/include/gmock/internal/gmock-port.h +++ b/include/gmock/internal/gmock-port.h @@ -47,18 +47,8 @@ // To avoid conditional compilation everywhere, we make it // gmock-port.h's responsibility to #include the header implementing -// tr1/tuple. -#if defined(__GNUC__) && GTEST_GCC_VER_ >= 40000 -// GTEST_GCC_VER_ is defined in gtest-port.h and 40000 corresponds to -// version 4.0.0. -// GCC 4.0+ implements tr1/tuple in the header. This does -// not conform to the TR1 spec, which requires the header to be . -#include -#else -// If the compiler is not GCC 4.0+, we assume the user is using a -// spec-conforming TR1 implementation. -#include -#endif // __GNUC__ +// tr1/tuple. gmock-port.h does this via gtest-port.h, which is +// guaranteed to pull in the tuple header. #if GTEST_OS_LINUX diff --git a/src/gmock-internal-utils.cc b/src/gmock-internal-utils.cc index ce17d715..0e693c70 100644 --- a/src/gmock-internal-utils.cc +++ b/src/gmock-internal-utils.cc @@ -131,16 +131,19 @@ void Log(LogSeverity severity, const string& message, // Ensures that logs from different threads don't interleave. MutexLock l(&g_log_mutex); - using ::std::cout; + + // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a + // macro. + if (severity == WARNING) { // Prints a GMOCK WARNING marker to make the warnings easily searchable. - cout << "\nGMOCK WARNING:"; + std::cout << "\nGMOCK WARNING:"; } // Pre-pends a new-line to message if it doesn't start with one. if (message.empty() || message[0] != '\n') { - cout << "\n"; + std::cout << "\n"; } - cout << message; + std::cout << message; if (stack_frames_to_skip >= 0) { #ifdef NDEBUG // In opt mode, we have to be conservative and skip no stack frame. @@ -153,13 +156,13 @@ void Log(LogSeverity severity, const string& message, // Appends a new-line to message if it doesn't end with one. if (!message.empty() && *message.rbegin() != '\n') { - cout << "\n"; + std::cout << "\n"; } - cout << "Stack trace:\n" + std::cout << "Stack trace:\n" << ::testing::internal::GetCurrentOsStackTraceExceptTop( ::testing::UnitTest::GetInstance(), actual_to_skip); } - cout << ::std::flush; + std::cout << ::std::flush; } } // namespace internal diff --git a/test/gmock-generated-matchers_test.cc b/test/gmock-generated-matchers_test.cc index 7e716981..19024d0d 100644 --- a/test/gmock-generated-matchers_test.cc +++ b/test/gmock-generated-matchers_test.cc @@ -457,7 +457,7 @@ TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) { NativeArrayPassedAsPointerAndSize helper; EXPECT_CALL(helper, Helper(_, _)) - .WithArguments(ElementsAre(0, 1)); + .With(ElementsAre(0, 1)); helper.Helper(array, 2); } diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc index 4ee6ea81..3541eef7 100644 --- a/test/gmock-matchers_test.cc +++ b/test/gmock-matchers_test.cc @@ -62,6 +62,7 @@ namespace gmock_matchers_test { using std::stringstream; using std::tr1::make_tuple; using testing::A; +using testing::AllArgs; using testing::AllOf; using testing::An; using testing::AnyOf; @@ -1689,6 +1690,35 @@ TEST(ValueTest, WorksWithMonomorphicMatcher) { EXPECT_FALSE(Value(1, ref_n)); } +TEST(AllArgsTest, WorksForTuple) { + EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt())); + EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt()))); +} + +TEST(AllArgsTest, WorksForNonTuple) { + EXPECT_THAT(42, AllArgs(Gt(0))); + EXPECT_THAT('a', Not(AllArgs(Eq('b')))); +} + +class AllArgsHelper { + public: + MOCK_METHOD2(Helper, int(char x, int y)); +}; + +TEST(AllArgsTest, WorksInWithClause) { + AllArgsHelper helper; + ON_CALL(helper, Helper(_, _)) + .With(AllArgs(Lt())) + .WillByDefault(Return(1)); + EXPECT_CALL(helper, Helper(_, _)); + EXPECT_CALL(helper, Helper(_, _)) + .With(AllArgs(Gt())) + .WillOnce(Return(2)); + + EXPECT_EQ(1, helper.Helper('\1', 2)); + EXPECT_EQ(2, helper.Helper('a', 1)); +} + // Tests that ASSERT_THAT() and EXPECT_THAT() work when the value // matches the matcher. TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) { diff --git a/test/gmock-spec-builders_test.cc b/test/gmock-spec-builders_test.cc index 4711899d..24621371 100644 --- a/test/gmock-spec-builders_test.cc +++ b/test/gmock-spec-builders_test.cc @@ -72,6 +72,7 @@ using testing::Const; using testing::DoAll; using testing::DoDefault; using testing::GMOCK_FLAG(verbose); +using testing::Gt; using testing::InSequence; using testing::Invoke; using testing::InvokeWithoutArgs; @@ -96,6 +97,7 @@ class MockA { MOCK_METHOD1(DoA, void(int n)); // NOLINT MOCK_METHOD1(ReturnResult, Result(int n)); // NOLINT MOCK_METHOD2(Binary, bool(int x, int y)); // NOLINT + MOCK_METHOD2(ReturnInt, int(int x, int y)); // NOLINT }; class MockB { @@ -171,25 +173,40 @@ TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) { // Tests that the syntax of ON_CALL() is enforced at run time. -TEST(OnCallSyntaxTest, WithArgumentsIsOptional) { +TEST(OnCallSyntaxTest, WithIsOptional) { MockA a; ON_CALL(a, DoA(5)) .WillByDefault(Return()); ON_CALL(a, DoA(_)) - .WithArguments(_) + .With(_) .WillByDefault(Return()); } -TEST(OnCallSyntaxTest, WithArgumentsCanAppearAtMostOnce) { +TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) { MockA a; EXPECT_NONFATAL_FAILURE({ // NOLINT ON_CALL(a, ReturnResult(_)) - .WithArguments(_) - .WithArguments(_) + .With(_) + .With(_) .WillByDefault(Return(Result())); - }, ".WithArguments() cannot appear more than once in an ON_CALL()"); + }, ".With() cannot appear more than once in an ON_CALL()"); +} + +TEST(OnCallSyntaxTest, WithArgumentsIsSynonymOfWith) { + MockA a; + ON_CALL(a, ReturnInt(_, _)) + .WithArguments(Lt()) + .WillByDefault(Return(1)); + ON_CALL(a, ReturnInt(_, _)) + .WithArguments(Gt()) + .WillByDefault(Return(2)); + EXPECT_CALL(a, ReturnInt(_, _)) + .Times(AnyNumber()); + + EXPECT_EQ(1, a.ReturnInt(1, 2)); + EXPECT_EQ(2, a.ReturnInt(2, 1)); } #if GTEST_HAS_DEATH_TEST @@ -237,51 +254,61 @@ TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) { // Tests that the syntax of EXPECT_CALL() is enforced at run time. -TEST(ExpectCallSyntaxTest, WithArgumentsIsOptional) { +TEST(ExpectCallSyntaxTest, WithIsOptional) { MockA a; EXPECT_CALL(a, DoA(5)) .Times(0); EXPECT_CALL(a, DoA(6)) - .WithArguments(_) + .With(_) .Times(0); } -TEST(ExpectCallSyntaxTest, WithArgumentsCanAppearAtMostOnce) { +TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) { MockA a; EXPECT_NONFATAL_FAILURE({ // NOLINT EXPECT_CALL(a, DoA(6)) - .WithArguments(_) - .WithArguments(_); - }, ".WithArguments() cannot appear more than once in " - "an EXPECT_CALL()"); + .With(_) + .With(_); + }, ".With() cannot appear more than once in an EXPECT_CALL()"); a.DoA(6); } -TEST(ExpectCallSyntaxTest, WithArgumentsMustBeFirstClause) { +TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) { MockA a; EXPECT_NONFATAL_FAILURE({ // NOLINT EXPECT_CALL(a, DoA(1)) .Times(1) - .WithArguments(_); - }, ".WithArguments() must be the first clause in an " - "EXPECT_CALL()"); + .With(_); + }, ".With() must be the first clause in an EXPECT_CALL()"); a.DoA(1); EXPECT_NONFATAL_FAILURE({ // NOLINT EXPECT_CALL(a, DoA(2)) .WillOnce(Return()) - .WithArguments(_); - }, ".WithArguments() must be the first clause in an " - "EXPECT_CALL()"); + .With(_); + }, ".With() must be the first clause in an EXPECT_CALL()"); a.DoA(2); } +TEST(ExpectCallSyntaxTest, WithArgumentsIsSynonymOfWith) { + MockA a; + EXPECT_CALL(a, ReturnInt(_, _)) + .WithArguments(Lt()) + .WillOnce(Return(1)); + EXPECT_CALL(a, ReturnInt(_, _)) + .WithArguments(Gt()) + .WillOnce(Return(2)); + + EXPECT_EQ(1, a.ReturnInt(1, 2)); + EXPECT_EQ(2, a.ReturnInt(2, 1)); +} + TEST(ExpectCallSyntaxTest, TimesCanBeInferred) { MockA a; diff --git a/test/gmock_link_test.h b/test/gmock_link_test.h index 4e0adb71..b903f3cb 100644 --- a/test/gmock_link_test.h +++ b/test/gmock_link_test.h @@ -120,6 +120,7 @@ #include #endif +#include #include #include #include diff --git a/test/gmock_output_test_.cc b/test/gmock_output_test_.cc index 97619af1..8244f10b 100644 --- a/test/gmock_output_test_.cc +++ b/test/gmock_output_test_.cc @@ -177,19 +177,19 @@ TEST_F(GMockOutputTest, MismatchArguments) { foo_.Bar(s, 0, 0); } -TEST_F(GMockOutputTest, MismatchWithArguments) { +TEST_F(GMockOutputTest, MismatchWith) { EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))) - .WithArguments(Ge()); + .With(Ge()); - foo_.Bar2(2, 3); // Mismatch WithArguments() + foo_.Bar2(2, 3); // Mismatch With() foo_.Bar2(2, 1); } -TEST_F(GMockOutputTest, MismatchArgumentsAndWithArguments) { +TEST_F(GMockOutputTest, MismatchArgumentsAndWith) { EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1))) - .WithArguments(Ge()); + .With(Ge()); - foo_.Bar2(1, 3); // Mismatch arguments and mismatch WithArguments() + foo_.Bar2(1, 3); // Mismatch arguments and mismatch With() foo_.Bar2(2, 1); } diff --git a/test/gmock_output_test_golden.txt b/test/gmock_output_test_golden.txt index b4d2ea06..aeec660f 100644 --- a/test/gmock_output_test_golden.txt +++ b/test/gmock_output_test_golden.txt @@ -174,7 +174,7 @@ FILE:#: Expected: to be called once Actual: never called - unsatisfied and active [ FAILED ] GMockOutputTest.MismatchArguments -[ RUN ] GMockOutputTest.MismatchWithArguments +[ RUN ] GMockOutputTest.MismatchWith unknown file: Failure Unexpected mock function call - returning default value. @@ -187,8 +187,8 @@ FILE:#: Actual: don't match Expected: to be called once Actual: never called - unsatisfied and active -[ FAILED ] GMockOutputTest.MismatchWithArguments -[ RUN ] GMockOutputTest.MismatchArgumentsAndWithArguments +[ FAILED ] GMockOutputTest.MismatchWith +[ RUN ] GMockOutputTest.MismatchArgumentsAndWith unknown file: Failure Unexpected mock function call - returning default value. @@ -203,7 +203,7 @@ FILE:#: Actual: don't match Expected: to be called once Actual: never called - unsatisfied and active -[ FAILED ] GMockOutputTest.MismatchArgumentsAndWithArguments +[ FAILED ] GMockOutputTest.MismatchArgumentsAndWith [ RUN ] GMockOutputTest.UnexpectedCallWithDefaultAction unknown file: Failure @@ -290,8 +290,8 @@ Stack trace: [ FAILED ] GMockOutputTest.UnsatisfiedPrerequisites [ FAILED ] GMockOutputTest.UnsatisfiedExpectation [ FAILED ] GMockOutputTest.MismatchArguments -[ FAILED ] GMockOutputTest.MismatchWithArguments -[ FAILED ] GMockOutputTest.MismatchArgumentsAndWithArguments +[ FAILED ] GMockOutputTest.MismatchWith +[ FAILED ] GMockOutputTest.MismatchArgumentsAndWith [ FAILED ] GMockOutputTest.UnexpectedCallWithDefaultAction [ FAILED ] GMockOutputTest.ExcessiveCallWithDefaultAction