summaryrefslogtreecommitdiff
path: root/ext/googlemock/test/gmock-spec-builders_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'ext/googlemock/test/gmock-spec-builders_test.cc')
-rw-r--r--ext/googlemock/test/gmock-spec-builders_test.cc2644
1 files changed, 2644 insertions, 0 deletions
diff --git a/ext/googlemock/test/gmock-spec-builders_test.cc b/ext/googlemock/test/gmock-spec-builders_test.cc
new file mode 100644
index 000000000..59ea87c89
--- /dev/null
+++ b/ext/googlemock/test/gmock-spec-builders_test.cc
@@ -0,0 +1,2644 @@
+// 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: wan@google.com (Zhanyong Wan)
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file tests the spec builder syntax.
+
+#include "gmock/gmock-spec-builders.h"
+
+#include <ostream> // NOLINT
+#include <sstream>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester {
+ public:
+ // Sets the call count of the given expectation to the given number.
+ void SetCallCount(int n, ExpectationBase* exp) {
+ exp->call_count_ = n;
+ }
+};
+
+} // namespace internal
+} // namespace testing
+
+namespace {
+
+using testing::_;
+using testing::AnyNumber;
+using testing::AtLeast;
+using testing::AtMost;
+using testing::Between;
+using testing::Cardinality;
+using testing::CardinalityInterface;
+using testing::ContainsRegex;
+using testing::Const;
+using testing::DoAll;
+using testing::DoDefault;
+using testing::Eq;
+using testing::Expectation;
+using testing::ExpectationSet;
+using testing::GMOCK_FLAG(verbose);
+using testing::Gt;
+using testing::InSequence;
+using testing::Invoke;
+using testing::InvokeWithoutArgs;
+using testing::IsNotSubstring;
+using testing::IsSubstring;
+using testing::Lt;
+using testing::Message;
+using testing::Mock;
+using testing::NaggyMock;
+using testing::Ne;
+using testing::Return;
+using testing::Sequence;
+using testing::SetArgPointee;
+using testing::internal::ExpectationTester;
+using testing::internal::FormatFileLocation;
+using testing::internal::kErrorVerbosity;
+using testing::internal::kInfoVerbosity;
+using testing::internal::kWarningVerbosity;
+using testing::internal::linked_ptr;
+using testing::internal::string;
+
+#if GTEST_HAS_STREAM_REDIRECTION
+using testing::HasSubstr;
+using testing::internal::CaptureStdout;
+using testing::internal::GetCapturedStdout;
+#endif
+
+class Incomplete;
+
+class MockIncomplete {
+ public:
+ // This line verifies that a mock method can take a by-reference
+ // argument of an incomplete type.
+ MOCK_METHOD1(ByRefFunc, void(const Incomplete& x));
+};
+
+// Tells Google Mock how to print a value of type Incomplete.
+void PrintTo(const Incomplete& x, ::std::ostream* os);
+
+TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
+ // Even though this mock class contains a mock method that takes
+ // by-reference an argument whose type is incomplete, we can still
+ // use the mock, as long as Google Mock knows how to print the
+ // argument.
+ MockIncomplete incomplete;
+ EXPECT_CALL(incomplete, ByRefFunc(_))
+ .Times(AnyNumber());
+}
+
+// The definition of the printer for the argument type doesn't have to
+// be visible where the mock is used.
+void PrintTo(const Incomplete& /* x */, ::std::ostream* os) {
+ *os << "incomplete";
+}
+
+class Result {};
+
+// A type that's not default constructible.
+class NonDefaultConstructible {
+ public:
+ explicit NonDefaultConstructible(int /* dummy */) {}
+};
+
+class MockA {
+ public:
+ MockA() {}
+
+ MOCK_METHOD1(DoA, void(int n));
+ MOCK_METHOD1(ReturnResult, Result(int n));
+ MOCK_METHOD0(ReturnNonDefaultConstructible, NonDefaultConstructible());
+ MOCK_METHOD2(Binary, bool(int x, int y));
+ MOCK_METHOD2(ReturnInt, int(int x, int y));
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
+};
+
+class MockB {
+ public:
+ MockB() {}
+
+ MOCK_CONST_METHOD0(DoB, int()); // NOLINT
+ MOCK_METHOD1(DoB, int(int n)); // NOLINT
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
+};
+
+class ReferenceHoldingMock {
+ public:
+ ReferenceHoldingMock() {}
+
+ MOCK_METHOD1(AcceptReference, void(linked_ptr<MockA>*));
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
+};
+
+// Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
+// redefining a mock method name. This could happen, for example, when
+// the tested code #includes Win32 API headers which define many APIs
+// as macros, e.g. #define TextOut TextOutW.
+
+#define Method MethodW
+
+class CC {
+ public:
+ virtual ~CC() {}
+ virtual int Method() = 0;
+};
+class MockCC : public CC {
+ public:
+ MockCC() {}
+
+ MOCK_METHOD0(Method, int());
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
+};
+
+// Tests that a method with expanded name compiles.
+TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
+ MockCC cc;
+ ON_CALL(cc, Method());
+}
+
+// Tests that the method with expanded name not only compiles but runs
+// and returns a correct value, too.
+TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
+ MockCC cc;
+ ON_CALL(cc, Method()).WillByDefault(Return(42));
+ EXPECT_EQ(42, cc.Method());
+}
+
+// Tests that a method with expanded name compiles.
+TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
+ MockCC cc;
+ EXPECT_CALL(cc, Method());
+ cc.Method();
+}
+
+// Tests that it works, too.
+TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
+ MockCC cc;
+ EXPECT_CALL(cc, Method()).WillOnce(Return(42));
+ EXPECT_EQ(42, cc.Method());
+}
+
+#undef Method // Done with macro redefinition tests.
+
+// Tests that ON_CALL evaluates its arguments exactly once as promised
+// by Google Mock.
+TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
+ MockA a;
+ MockA* pa = &a;
+
+ ON_CALL(*pa++, DoA(_));
+ EXPECT_EQ(&a + 1, pa);
+}
+
+TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
+ MockA a;
+ int n = 0;
+
+ ON_CALL(a, DoA(n++));
+ EXPECT_EQ(1, n);
+}
+
+// Tests that the syntax of ON_CALL() is enforced at run time.
+
+TEST(OnCallSyntaxTest, WithIsOptional) {
+ MockA a;
+
+ ON_CALL(a, DoA(5))
+ .WillByDefault(Return());
+ ON_CALL(a, DoA(_))
+ .With(_)
+ .WillByDefault(Return());
+}
+
+TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ ON_CALL(a, ReturnResult(_))
+ .With(_)
+ .With(_)
+ .WillByDefault(Return(Result()));
+ }, ".With() cannot appear more than once in an ON_CALL()");
+}
+
+TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
+ MockA a;
+
+ EXPECT_DEATH_IF_SUPPORTED({
+ ON_CALL(a, DoA(5));
+ a.DoA(5);
+ }, "");
+}
+
+TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ ON_CALL(a, DoA(5))
+ .WillByDefault(Return())
+ .WillByDefault(Return());
+ }, ".WillByDefault() must appear exactly once in an ON_CALL()");
+}
+
+// Tests that EXPECT_CALL evaluates its arguments exactly once as
+// promised by Google Mock.
+TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
+ MockA a;
+ MockA* pa = &a;
+
+ EXPECT_CALL(*pa++, DoA(_));
+ a.DoA(0);
+ EXPECT_EQ(&a + 1, pa);
+}
+
+TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
+ MockA a;
+ int n = 0;
+
+ EXPECT_CALL(a, DoA(n++));
+ a.DoA(0);
+ EXPECT_EQ(1, n);
+}
+
+// Tests that the syntax of EXPECT_CALL() is enforced at run time.
+
+TEST(ExpectCallSyntaxTest, WithIsOptional) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(5))
+ .Times(0);
+ EXPECT_CALL(a, DoA(6))
+ .With(_)
+ .Times(0);
+}
+
+TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(6))
+ .With(_)
+ .With(_);
+ }, ".With() cannot appear more than once in an EXPECT_CALL()");
+
+ a.DoA(6);
+}
+
+TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .Times(1)
+ .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())
+ .With(_);
+ }, ".With() must be the first clause in an EXPECT_CALL()");
+
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(1))
+ .WillOnce(Return());
+
+ EXPECT_CALL(a, DoA(2))
+ .WillOnce(Return())
+ .WillRepeatedly(Return());
+
+ a.DoA(1);
+ a.DoA(2);
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .Times(1)
+ .Times(2);
+ }, ".Times() cannot appear more than once in an EXPECT_CALL()");
+
+ a.DoA(1);
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
+ MockA a;
+ Sequence s;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .InSequence(s)
+ .Times(1);
+ }, ".Times() cannot appear after ");
+
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
+ MockA a;
+ Sequence s;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(2))
+ .InSequence(s);
+
+ a.DoA(1);
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
+ MockA a;
+ Sequence s1, s2;
+
+ EXPECT_CALL(a, DoA(1))
+ .InSequence(s1, s2)
+ .InSequence(s1);
+
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
+ MockA a;
+ Sequence s;
+
+ Expectation e = EXPECT_CALL(a, DoA(1))
+ .Times(AnyNumber());
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(2))
+ .After(e)
+ .InSequence(s);
+ }, ".InSequence() cannot appear after ");
+
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
+ MockA a;
+ Sequence s;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .WillOnce(Return())
+ .InSequence(s);
+ }, ".InSequence() cannot appear after ");
+
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
+ MockA a;
+
+ Expectation e = EXPECT_CALL(a, DoA(1));
+ EXPECT_NONFATAL_FAILURE({
+ EXPECT_CALL(a, DoA(2))
+ .WillOnce(Return())
+ .After(e);
+ }, ".After() cannot appear after ");
+
+ a.DoA(1);
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillIsOptional) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(2))
+ .WillOnce(Return());
+
+ a.DoA(1);
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(1))
+ .Times(AnyNumber())
+ .WillOnce(Return())
+ .WillOnce(Return())
+ .WillOnce(Return());
+}
+
+TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .WillRepeatedly(Return())
+ .WillOnce(Return());
+ }, ".WillOnce() cannot appear after ");
+
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(1))
+ .WillOnce(Return());
+ EXPECT_CALL(a, DoA(2))
+ .WillOnce(Return())
+ .WillRepeatedly(Return());
+
+ a.DoA(1);
+ a.DoA(2);
+ a.DoA(2);
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .WillRepeatedly(Return())
+ .WillRepeatedly(Return());
+ }, ".WillRepeatedly() cannot appear more than once in an "
+ "EXPECT_CALL()");
+}
+
+TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .RetiresOnSaturation()
+ .WillRepeatedly(Return());
+ }, ".WillRepeatedly() cannot appear after ");
+}
+
+TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
+ MockA a;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(1))
+ .RetiresOnSaturation();
+
+ a.DoA(1);
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
+ MockA a;
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ EXPECT_CALL(a, DoA(1))
+ .RetiresOnSaturation()
+ .RetiresOnSaturation();
+ }, ".RetiresOnSaturation() cannot appear more than once");
+
+ a.DoA(1);
+}
+
+TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
+ {
+ MockA a;
+ EXPECT_CALL(a, DoA(1));
+ a.DoA(1);
+ }
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ MockA a;
+ EXPECT_CALL(a, DoA(1));
+ }, "to be called once");
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ MockA a;
+ EXPECT_CALL(a, DoA(1));
+ a.DoA(1);
+ a.DoA(1);
+ }, "to be called once");
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that Google Mock doesn't print a warning when the number of
+// WillOnce() is adequate.
+TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
+ CaptureStdout();
+ {
+ MockB b;
+
+ // It's always fine to omit WillOnce() entirely.
+ EXPECT_CALL(b, DoB())
+ .Times(0);
+ EXPECT_CALL(b, DoB(1))
+ .Times(AtMost(1));
+ EXPECT_CALL(b, DoB(2))
+ .Times(1)
+ .WillRepeatedly(Return(1));
+
+ // It's fine for the number of WillOnce()s to equal the upper bound.
+ EXPECT_CALL(b, DoB(3))
+ .Times(Between(1, 2))
+ .WillOnce(Return(1))
+ .WillOnce(Return(2));
+
+ // It's fine for the number of WillOnce()s to be smaller than the
+ // upper bound when there is a WillRepeatedly().
+ EXPECT_CALL(b, DoB(4))
+ .Times(AtMost(3))
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2));
+
+ // Satisfies the above expectations.
+ b.DoB(2);
+ b.DoB(3);
+ }
+ 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) {
+ CaptureStdout();
+ {
+ MockB b;
+
+ // Warns when the number of WillOnce()s is larger than the upper bound.
+ EXPECT_CALL(b, DoB())
+ .Times(0)
+ .WillOnce(Return(1)); // #1
+ EXPECT_CALL(b, DoB())
+ .Times(AtMost(1))
+ .WillOnce(Return(1))
+ .WillOnce(Return(2)); // #2
+ EXPECT_CALL(b, DoB(1))
+ .Times(1)
+ .WillOnce(Return(1))
+ .WillOnce(Return(2))
+ .RetiresOnSaturation(); // #3
+
+ // Warns when the number of WillOnce()s equals the upper bound and
+ // there is a WillRepeatedly().
+ EXPECT_CALL(b, DoB())
+ .Times(0)
+ .WillRepeatedly(Return(1)); // #4
+ EXPECT_CALL(b, DoB(2))
+ .Times(1)
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2)); // #5
+
+ // Satisfies the above expectations.
+ b.DoB(1);
+ b.DoB(2);
+ }
+ const std::string output = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+ "Expected to be never called, but has 1 WillOnce().",
+ output); // #1
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+ "Expected to be called at most once, "
+ "but has 2 WillOnce()s.",
+ output); // #2
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
+ "Expected to be called once, but has 2 WillOnce()s.",
+ output); // #3
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
+ "Expected to be never called, but has 0 WillOnce()s "
+ "and a WillRepeatedly().",
+ output); // #4
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
+ "Expected to be called once, but has 1 WillOnce() "
+ "and a WillRepeatedly().",
+ output); // #5
+}
+
+// Tests that Google Mock warns on having too few actions in an
+// expectation compared to its cardinality.
+TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
+ MockB b;
+
+ EXPECT_CALL(b, DoB())
+ .Times(Between(2, 3))
+ .WillOnce(Return(1));
+
+ CaptureStdout();
+ b.DoB();
+ const std::string output = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
+ "Expected to be called between 2 and 3 times, "
+ "but has only 1 WillOnce().",
+ output);
+ b.DoB();
+}
+
+#endif // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests the semantics of ON_CALL().
+
+// Tests that the built-in default action is taken when no ON_CALL()
+// is specified.
+TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
+ MockB b;
+ EXPECT_CALL(b, DoB());
+
+ EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that the built-in default action is taken when no ON_CALL()
+// matches the invocation.
+TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
+ MockB b;
+ ON_CALL(b, DoB(1))
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b, DoB(_));
+
+ EXPECT_EQ(0, b.DoB(2));
+}
+
+// Tests that the last matching ON_CALL() action is taken.
+TEST(OnCallTest, PicksLastMatchingOnCall) {
+ MockB b;
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(3));
+ ON_CALL(b, DoB(2))
+ .WillByDefault(Return(2));
+ ON_CALL(b, DoB(1))
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b, DoB(_));
+
+ EXPECT_EQ(2, b.DoB(2));
+}
+
+// Tests the semantics of EXPECT_CALL().
+
+// Tests that any call is allowed when no EXPECT_CALL() is specified.
+TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
+ MockB b;
+ EXPECT_CALL(b, DoB());
+ // There is no expectation on DoB(int).
+
+ b.DoB();
+
+ // DoB(int) can be called any number of times.
+ b.DoB(1);
+ b.DoB(2);
+}
+
+// Tests that the last matching EXPECT_CALL() fires.
+TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
+ MockB b;
+ EXPECT_CALL(b, DoB(_))
+ .WillRepeatedly(Return(2));
+ EXPECT_CALL(b, DoB(1))
+ .WillRepeatedly(Return(1));
+
+ EXPECT_EQ(1, b.DoB(1));
+}
+
+// Tests lower-bound violation.
+TEST(ExpectCallTest, CatchesTooFewCalls) {
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ MockB b;
+ EXPECT_CALL(b, DoB(5))
+ .Times(AtLeast(2));
+
+ b.DoB(5);
+ }, "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
+ " Expected: to be called at least twice\n"
+ " Actual: called once - unsatisfied and active");
+}
+
+// Tests that the cardinality can be inferred when no Times(...) is
+// specified.
+TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
+ {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillOnce(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ }
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillOnce(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ }, "to be called twice");
+
+ { // NOLINT
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillOnce(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ EXPECT_NONFATAL_FAILURE(b.DoB(), "to be called twice");
+ }
+}
+
+TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
+ {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ }
+
+ { // NOLINT
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ }
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2));
+ }, "to be called at least once");
+}
+
+// Tests that the n-th action is taken for the n-th matching
+// invocation.
+TEST(ExpectCallTest, NthMatchTakesNthAction) {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillOnce(Return(2))
+ .WillOnce(Return(3));
+
+ EXPECT_EQ(1, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ EXPECT_EQ(3, b.DoB());
+}
+
+// Tests that the WillRepeatedly() action is taken when the WillOnce(...)
+// list is exhausted.
+TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1))
+ .WillRepeatedly(Return(2));
+
+ EXPECT_EQ(1, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+ EXPECT_EQ(2, b.DoB());
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that the default action is taken when the WillOnce(...) list is
+// exhausted and there is no WillRepeatedly().
+TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
+ MockB b;
+ EXPECT_CALL(b, DoB(_))
+ .Times(1);
+ EXPECT_CALL(b, DoB())
+ .Times(AnyNumber())
+ .WillOnce(Return(1))
+ .WillOnce(Return(2));
+
+ 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 std::string output1 = GetCapturedStdout();
+ EXPECT_STREQ("", output1.c_str());
+
+ CaptureStdout();
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB());
+ const std::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."));
+}
+
+TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
+ MockB b;
+ std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
+ EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
+
+ EXPECT_EQ(1, b.DoB());
+
+ CaptureStdout();
+ EXPECT_EQ(0, b.DoB());
+ const std::string output = GetCapturedStdout();
+ // The warning message should contain the call location.
+ EXPECT_PRED_FORMAT2(IsSubstring, expect_call_location, output);
+}
+
+TEST(FunctionMockerMessageTest,
+ ReportsDefaultActionLocationOfUninterestingCallsForNaggyMock) {
+ std::string on_call_location;
+ CaptureStdout();
+ {
+ NaggyMock<MockB> b;
+ on_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
+ ON_CALL(b, DoB(_)).WillByDefault(Return(0));
+ b.DoB(0);
+ }
+ EXPECT_PRED_FORMAT2(IsSubstring, on_call_location, GetCapturedStdout());
+}
+
+#endif // GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that an uninteresting call performs the default action.
+TEST(UninterestingCallTest, DoesDefaultAction) {
+ // When there is an ON_CALL() statement, the action specified by it
+ // should be taken.
+ MockA a;
+ ON_CALL(a, Binary(_, _))
+ .WillByDefault(Return(true));
+ EXPECT_TRUE(a.Binary(1, 2));
+
+ // When there is no ON_CALL(), the default value for the return type
+ // should be returned.
+ MockB b;
+ EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that an unexpected call performs the default action.
+TEST(UnexpectedCallTest, DoesDefaultAction) {
+ // When there is an ON_CALL() statement, the action specified by it
+ // should be taken.
+ MockA a;
+ ON_CALL(a, Binary(_, _))
+ .WillByDefault(Return(true));
+ EXPECT_CALL(a, Binary(0, 0));
+ a.Binary(0, 0);
+ bool result = false;
+ EXPECT_NONFATAL_FAILURE(result = a.Binary(1, 2),
+ "Unexpected mock function call");
+ EXPECT_TRUE(result);
+
+ // When there is no ON_CALL(), the default value for the return type
+ // should be returned.
+ MockB b;
+ EXPECT_CALL(b, DoB(0))
+ .Times(0);
+ int n = -1;
+ EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
+ "Unexpected mock function call");
+ EXPECT_EQ(0, n);
+}
+
+// Tests that when an unexpected void function generates the right
+// failure message.
+TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
+ // First, tests the message when there is only one EXPECT_CALL().
+ MockA a1;
+ EXPECT_CALL(a1, DoA(1));
+ a1.DoA(1);
+ // Ideally we should match the failure message against a regex, but
+ // EXPECT_NONFATAL_FAILURE doesn't support that, so we test for
+ // multiple sub-strings instead.
+ EXPECT_NONFATAL_FAILURE(
+ a1.DoA(9),
+ "Unexpected mock function call - returning directly.\n"
+ " Function call: DoA(9)\n"
+ "Google Mock tried the following 1 expectation, but it didn't match:");
+ EXPECT_NONFATAL_FAILURE(
+ a1.DoA(9),
+ " Expected arg #0: is equal to 1\n"
+ " Actual: 9\n"
+ " Expected: to be called once\n"
+ " Actual: called once - saturated and active");
+
+ // Next, tests the message when there are more than one EXPECT_CALL().
+ MockA a2;
+ EXPECT_CALL(a2, DoA(1));
+ EXPECT_CALL(a2, DoA(3));
+ a2.DoA(1);
+ EXPECT_NONFATAL_FAILURE(
+ a2.DoA(2),
+ "Unexpected mock function call - returning directly.\n"
+ " Function call: DoA(2)\n"
+ "Google Mock tried the following 2 expectations, but none matched:");
+ EXPECT_NONFATAL_FAILURE(
+ a2.DoA(2),
+ "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
+ " Expected arg #0: is equal to 1\n"
+ " Actual: 2\n"
+ " Expected: to be called once\n"
+ " Actual: called once - saturated and active");
+ EXPECT_NONFATAL_FAILURE(
+ a2.DoA(2),
+ "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
+ " Expected arg #0: is equal to 3\n"
+ " Actual: 2\n"
+ " Expected: to be called once\n"
+ " Actual: never called - unsatisfied and active");
+ a2.DoA(3);
+}
+
+// Tests that an unexpected non-void function generates the right
+// failure message.
+TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
+ MockB b1;
+ EXPECT_CALL(b1, DoB(1));
+ b1.DoB(1);
+ EXPECT_NONFATAL_FAILURE(
+ b1.DoB(2),
+ "Unexpected mock function call - returning default value.\n"
+ " Function call: DoB(2)\n"
+ " Returns: 0\n"
+ "Google Mock tried the following 1 expectation, but it didn't match:");
+ EXPECT_NONFATAL_FAILURE(
+ b1.DoB(2),
+ " Expected arg #0: is equal to 1\n"
+ " Actual: 2\n"
+ " Expected: to be called once\n"
+ " Actual: called once - saturated and active");
+}
+
+// Tests that Google Mock explains that an retired expectation doesn't
+// match the call.
+TEST(UnexpectedCallTest, RetiredExpectation) {
+ MockB b;
+ EXPECT_CALL(b, DoB(1))
+ .RetiresOnSaturation();
+
+ b.DoB(1);
+ EXPECT_NONFATAL_FAILURE(
+ b.DoB(1),
+ " Expected: the expectation is active\n"
+ " Actual: it is retired");
+}
+
+// Tests that Google Mock explains that an expectation that doesn't
+// match the arguments doesn't match the call.
+TEST(UnexpectedCallTest, UnmatchedArguments) {
+ MockB b;
+ EXPECT_CALL(b, DoB(1));
+
+ EXPECT_NONFATAL_FAILURE(
+ b.DoB(2),
+ " Expected arg #0: is equal to 1\n"
+ " Actual: 2\n");
+ b.DoB(1);
+}
+
+// Tests that Google Mock explains that an expectation with
+// unsatisfied pre-requisites doesn't match the call.
+TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
+ Sequence s1, s2;
+ MockB b;
+ EXPECT_CALL(b, DoB(1))
+ .InSequence(s1);
+ EXPECT_CALL(b, DoB(2))
+ .Times(AnyNumber())
+ .InSequence(s1);
+ EXPECT_CALL(b, DoB(3))
+ .InSequence(s2);
+ EXPECT_CALL(b, DoB(4))
+ .InSequence(s1, s2);
+
+ ::testing::TestPartResultArray failures;
+ {
+ ::testing::ScopedFakeTestPartResultReporter reporter(&failures);
+ b.DoB(4);
+ // Now 'failures' contains the Google Test failures generated by
+ // the above statement.
+ }
+
+ // There should be one non-fatal failure.
+ ASSERT_EQ(1, failures.size());
+ const ::testing::TestPartResult& r = failures.GetTestPartResult(0);
+ EXPECT_EQ(::testing::TestPartResult::kNonFatalFailure, r.type());
+
+ // Verifies that the failure message contains the two unsatisfied
+ // pre-requisites but not the satisfied one.
+#if GTEST_USES_PCRE
+ EXPECT_THAT(r.message(), ContainsRegex(
+ // PCRE has trouble using (.|\n) to match any character, but
+ // supports the (?s) prefix for using . to match any character.
+ "(?s)the following immediate pre-requisites are not satisfied:\n"
+ ".*: pre-requisite #0\n"
+ ".*: pre-requisite #1"));
+#elif GTEST_USES_POSIX_RE
+ EXPECT_THAT(r.message(), ContainsRegex(
+ // POSIX RE doesn't understand the (?s) prefix, but has no trouble
+ // with (.|\n).
+ "the following immediate pre-requisites are not satisfied:\n"
+ "(.|\n)*: pre-requisite #0\n"
+ "(.|\n)*: pre-requisite #1"));
+#else
+ // We can only use Google Test's own simple regex.
+ EXPECT_THAT(r.message(), ContainsRegex(
+ "the following immediate pre-requisites are not satisfied:"));
+ EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #0"));
+ EXPECT_THAT(r.message(), ContainsRegex(": pre-requisite #1"));
+#endif // GTEST_USES_PCRE
+
+ b.DoB(1);
+ b.DoB(3);
+ b.DoB(4);
+}
+
+TEST(UndefinedReturnValueTest,
+ ReturnValueIsMandatoryWhenNotDefaultConstructible) {
+ MockA a;
+ // TODO(wan@google.com): We should really verify the output message,
+ // but we cannot yet due to that EXPECT_DEATH only captures stderr
+ // while Google Mock logs to stdout.
+#if GTEST_HAS_EXCEPTIONS
+ EXPECT_ANY_THROW(a.ReturnNonDefaultConstructible());
+#else
+ EXPECT_DEATH_IF_SUPPORTED(a.ReturnNonDefaultConstructible(), "");
+#endif
+}
+
+// Tests that an excessive call (one whose arguments match the
+// matchers but is called too many times) performs the default action.
+TEST(ExcessiveCallTest, DoesDefaultAction) {
+ // When there is an ON_CALL() statement, the action specified by it
+ // should be taken.
+ MockA a;
+ ON_CALL(a, Binary(_, _))
+ .WillByDefault(Return(true));
+ EXPECT_CALL(a, Binary(0, 0));
+ a.Binary(0, 0);
+ bool result = false;
+ EXPECT_NONFATAL_FAILURE(result = a.Binary(0, 0),
+ "Mock function called more times than expected");
+ EXPECT_TRUE(result);
+
+ // When there is no ON_CALL(), the default value for the return type
+ // should be returned.
+ MockB b;
+ EXPECT_CALL(b, DoB(0))
+ .Times(0);
+ int n = -1;
+ EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
+ "Mock function called more times than expected");
+ EXPECT_EQ(0, n);
+}
+
+// Tests that when a void function is called too many times,
+// the failure message contains the argument values.
+TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
+ MockA a;
+ EXPECT_CALL(a, DoA(_))
+ .Times(0);
+ EXPECT_NONFATAL_FAILURE(
+ a.DoA(9),
+ "Mock function called more times than expected - returning directly.\n"
+ " Function call: DoA(9)\n"
+ " Expected: to be never called\n"
+ " Actual: called once - over-saturated and active");
+}
+
+// Tests that when a non-void function is called too many times, the
+// failure message contains the argument values and the return value.
+TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
+ MockB b;
+ EXPECT_CALL(b, DoB(_));
+ b.DoB(1);
+ EXPECT_NONFATAL_FAILURE(
+ b.DoB(2),
+ "Mock function called more times than expected - "
+ "returning default value.\n"
+ " Function call: DoB(2)\n"
+ " Returns: 0\n"
+ " Expected: to be called once\n"
+ " Actual: called twice - over-saturated and active");
+}
+
+// Tests using sequences.
+
+TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
+ MockA a;
+ {
+ InSequence dummy;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(2));
+ }
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ a.DoA(2);
+ }, "Unexpected mock function call");
+
+ a.DoA(1);
+ a.DoA(2);
+}
+
+TEST(InSequenceTest, NestedInSequence) {
+ MockA a;
+ {
+ InSequence dummy;
+
+ EXPECT_CALL(a, DoA(1));
+ {
+ InSequence dummy2;
+
+ EXPECT_CALL(a, DoA(2));
+ EXPECT_CALL(a, DoA(3));
+ }
+ }
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ a.DoA(1);
+ a.DoA(3);
+ }, "Unexpected mock function call");
+
+ a.DoA(2);
+ a.DoA(3);
+}
+
+TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
+ MockA a;
+ {
+ InSequence dummy;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(2));
+ }
+ EXPECT_CALL(a, DoA(3));
+
+ EXPECT_NONFATAL_FAILURE({ // NOLINT
+ a.DoA(2);
+ }, "Unexpected mock function call");
+
+ a.DoA(3);
+ a.DoA(1);
+ a.DoA(2);
+}
+
+// Tests that any order is allowed when no sequence is used.
+TEST(SequenceTest, AnyOrderIsOkByDefault) {
+ {
+ MockA a;
+ MockB b;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(b, DoB())
+ .Times(AnyNumber());
+
+ a.DoA(1);
+ b.DoB();
+ }
+
+ { // NOLINT
+ MockA a;
+ MockB b;
+
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(b, DoB())
+ .Times(AnyNumber());
+
+ b.DoB();
+ a.DoA(1);
+ }
+}
+
+// Tests that the calls must be in strict order when a complete order
+// is specified.
+TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
+ MockA a;
+ ON_CALL(a, ReturnResult(_))
+ .WillByDefault(Return(Result()));
+
+ Sequence s;
+ EXPECT_CALL(a, ReturnResult(1))
+ .InSequence(s);
+ EXPECT_CALL(a, ReturnResult(2))
+ .InSequence(s);
+ EXPECT_CALL(a, ReturnResult(3))
+ .InSequence(s);
+
+ a.ReturnResult(1);
+
+ // May only be called after a.ReturnResult(2).
+ EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+ a.ReturnResult(2);
+ a.ReturnResult(3);
+}
+
+// Tests that the calls must be in strict order when a complete order
+// is specified.
+TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
+ MockA a;
+ ON_CALL(a, ReturnResult(_))
+ .WillByDefault(Return(Result()));
+
+ Sequence s;
+ EXPECT_CALL(a, ReturnResult(1))
+ .InSequence(s);
+ EXPECT_CALL(a, ReturnResult(2))
+ .InSequence(s);
+
+ // May only be called after a.ReturnResult(1).
+ EXPECT_NONFATAL_FAILURE(a.ReturnResult(2), "Unexpected mock function call");
+
+ a.ReturnResult(1);
+ a.ReturnResult(2);
+}
+
+// Tests specifying a DAG using multiple sequences.
+class PartialOrderTest : public testing::Test {
+ protected:
+ PartialOrderTest() {
+ ON_CALL(a_, ReturnResult(_))
+ .WillByDefault(Return(Result()));
+
+ // Specifies this partial ordering:
+ //
+ // a.ReturnResult(1) ==>
+ // a.ReturnResult(2) * n ==> a.ReturnResult(3)
+ // b.DoB() * 2 ==>
+ Sequence x, y;
+ EXPECT_CALL(a_, ReturnResult(1))
+ .InSequence(x);
+ EXPECT_CALL(b_, DoB())
+ .Times(2)
+ .InSequence(y);
+ EXPECT_CALL(a_, ReturnResult(2))
+ .Times(AnyNumber())
+ .InSequence(x, y);
+ EXPECT_CALL(a_, ReturnResult(3))
+ .InSequence(x);
+ }
+
+ MockA a_;
+ MockB b_;
+};
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
+ a_.ReturnResult(1);
+ b_.DoB();
+
+ // May only be called after the second DoB().
+ EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+
+ b_.DoB();
+ a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
+ // May only be called after ReturnResult(1).
+ EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+
+ a_.ReturnResult(1);
+ b_.DoB();
+ b_.DoB();
+ a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
+ // May only be called last.
+ EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3), "Unexpected mock function call");
+
+ a_.ReturnResult(1);
+ b_.DoB();
+ b_.DoB();
+ a_.ReturnResult(3);
+}
+
+TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
+ a_.ReturnResult(1);
+ b_.DoB();
+ b_.DoB();
+ a_.ReturnResult(3);
+
+ // May only be called before ReturnResult(3).
+ EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
+}
+
+TEST(SequenceTest, Retirement) {
+ MockA a;
+ Sequence s;
+
+ EXPECT_CALL(a, DoA(1))
+ .InSequence(s);
+ EXPECT_CALL(a, DoA(_))
+ .InSequence(s)
+ .RetiresOnSaturation();
+ EXPECT_CALL(a, DoA(1))
+ .InSequence(s);
+
+ a.DoA(1);
+ a.DoA(2);
+ a.DoA(1);
+}
+
+// Tests Expectation.
+
+TEST(ExpectationTest, ConstrutorsWork) {
+ MockA a;
+ Expectation e1; // Default ctor.
+
+ // Ctor from various forms of EXPECT_CALL.
+ Expectation e2 = EXPECT_CALL(a, DoA(2));
+ Expectation e3 = EXPECT_CALL(a, DoA(3)).With(_);
+ {
+ Sequence s;
+ Expectation e4 = EXPECT_CALL(a, DoA(4)).Times(1);
+ Expectation e5 = EXPECT_CALL(a, DoA(5)).InSequence(s);
+ }
+ Expectation e6 = EXPECT_CALL(a, DoA(6)).After(e2);
+ Expectation e7 = EXPECT_CALL(a, DoA(7)).WillOnce(Return());
+ Expectation e8 = EXPECT_CALL(a, DoA(8)).WillRepeatedly(Return());
+ Expectation e9 = EXPECT_CALL(a, DoA(9)).RetiresOnSaturation();
+
+ Expectation e10 = e2; // Copy ctor.
+
+ EXPECT_THAT(e1, Ne(e2));
+ EXPECT_THAT(e2, Eq(e10));
+
+ a.DoA(2);
+ a.DoA(3);
+ a.DoA(4);
+ a.DoA(5);
+ a.DoA(6);
+ a.DoA(7);
+ a.DoA(8);
+ a.DoA(9);
+}
+
+TEST(ExpectationTest, AssignmentWorks) {
+ MockA a;
+ Expectation e1;
+ Expectation e2 = EXPECT_CALL(a, DoA(1));
+
+ EXPECT_THAT(e1, Ne(e2));
+
+ e1 = e2;
+ EXPECT_THAT(e1, Eq(e2));
+
+ a.DoA(1);
+}
+
+// Tests ExpectationSet.
+
+TEST(ExpectationSetTest, MemberTypesAreCorrect) {
+ ::testing::StaticAssertTypeEq<Expectation, ExpectationSet::value_type>();
+}
+
+TEST(ExpectationSetTest, ConstructorsWork) {
+ MockA a;
+
+ Expectation e1;
+ const Expectation e2;
+ ExpectationSet es1; // Default ctor.
+ ExpectationSet es2 = EXPECT_CALL(a, DoA(1)); // Ctor from EXPECT_CALL.
+ ExpectationSet es3 = e1; // Ctor from Expectation.
+ ExpectationSet es4(e1); // Ctor from Expectation; alternative syntax.
+ ExpectationSet es5 = e2; // Ctor from const Expectation.
+ ExpectationSet es6(e2); // Ctor from const Expectation; alternative syntax.
+ ExpectationSet es7 = es2; // Copy ctor.
+
+ EXPECT_EQ(0, es1.size());
+ EXPECT_EQ(1, es2.size());
+ EXPECT_EQ(1, es3.size());
+ EXPECT_EQ(1, es4.size());
+ EXPECT_EQ(1, es5.size());
+ EXPECT_EQ(1, es6.size());
+ EXPECT_EQ(1, es7.size());
+
+ EXPECT_THAT(es3, Ne(es2));
+ EXPECT_THAT(es4, Eq(es3));
+ EXPECT_THAT(es5, Eq(es4));
+ EXPECT_THAT(es6, Eq(es5));
+ EXPECT_THAT(es7, Eq(es2));
+ a.DoA(1);
+}
+
+TEST(ExpectationSetTest, AssignmentWorks) {
+ ExpectationSet es1;
+ ExpectationSet es2 = Expectation();
+
+ es1 = es2;
+ EXPECT_EQ(1, es1.size());
+ EXPECT_THAT(*(es1.begin()), Eq(Expectation()));
+ EXPECT_THAT(es1, Eq(es2));
+}
+
+TEST(ExpectationSetTest, InsertionWorks) {
+ ExpectationSet es1;
+ Expectation e1;
+ es1 += e1;
+ EXPECT_EQ(1, es1.size());
+ EXPECT_THAT(*(es1.begin()), Eq(e1));
+
+ MockA a;
+ Expectation e2 = EXPECT_CALL(a, DoA(1));
+ es1 += e2;
+ EXPECT_EQ(2, es1.size());
+
+ ExpectationSet::const_iterator it1 = es1.begin();
+ ExpectationSet::const_iterator it2 = it1;
+ ++it2;
+ EXPECT_TRUE(*it1 == e1 || *it2 == e1); // e1 must be in the set.
+ EXPECT_TRUE(*it1 == e2 || *it2 == e2); // e2 must be in the set too.
+ a.DoA(1);
+}
+
+TEST(ExpectationSetTest, SizeWorks) {
+ ExpectationSet es;
+ EXPECT_EQ(0, es.size());
+
+ es += Expectation();
+ EXPECT_EQ(1, es.size());
+
+ MockA a;
+ es += EXPECT_CALL(a, DoA(1));
+ EXPECT_EQ(2, es.size());
+
+ a.DoA(1);
+}
+
+TEST(ExpectationSetTest, IsEnumerable) {
+ ExpectationSet es;
+ EXPECT_TRUE(es.begin() == es.end());
+
+ es += Expectation();
+ ExpectationSet::const_iterator it = es.begin();
+ EXPECT_TRUE(it != es.end());
+ EXPECT_THAT(*it, Eq(Expectation()));
+ ++it;
+ EXPECT_TRUE(it== es.end());
+}
+
+// Tests the .After() clause.
+
+TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
+ MockA a;
+ ExpectationSet es;
+ es += EXPECT_CALL(a, DoA(1));
+ es += EXPECT_CALL(a, DoA(2));
+ EXPECT_CALL(a, DoA(3))
+ .After(es);
+
+ a.DoA(1);
+ a.DoA(2);
+ a.DoA(3);
+}
+
+TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
+ MockA a;
+ MockB b;
+ // The following also verifies that const Expectation objects work
+ // too. Do not remove the const modifiers.
+ const Expectation e1 = EXPECT_CALL(a, DoA(1));
+ const Expectation e2 = EXPECT_CALL(b, DoB())
+ .Times(2)
+ .After(e1);
+ EXPECT_CALL(a, DoA(2)).After(e2);
+
+ a.DoA(1);
+ b.DoB();
+ b.DoB();
+ a.DoA(2);
+}
+
+// Calls must be in strict order when specified so using .After().
+TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
+ MockA a;
+ MockB b;
+
+ // Define ordering:
+ // a.DoA(1) ==> b.DoB() ==> a.DoA(2)
+ Expectation e1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(b, DoB())
+ .After(e1);
+ EXPECT_CALL(a, DoA(2))
+ .After(e2);
+
+ a.DoA(1);
+
+ // May only be called after DoB().
+ EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
+
+ b.DoB();
+ a.DoA(2);
+}
+
+// Calls must be in strict order when specified so using .After().
+TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
+ MockA a;
+ MockB b;
+
+ // Define ordering:
+ // a.DoA(1) ==> b.DoB() * 2 ==> a.DoA(2)
+ Expectation e1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(b, DoB())
+ .Times(2)
+ .After(e1);
+ EXPECT_CALL(a, DoA(2))
+ .After(e2);
+
+ a.DoA(1);
+ b.DoB();
+
+ // May only be called after the second DoB().
+ EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
+
+ b.DoB();
+ a.DoA(2);
+}
+
+// Calls must satisfy the partial order when specified so.
+TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
+ MockA a;
+ ON_CALL(a, ReturnResult(_))
+ .WillByDefault(Return(Result()));
+
+ // Define ordering:
+ // a.DoA(1) ==>
+ // a.DoA(2) ==> a.ReturnResult(3)
+ Expectation e = EXPECT_CALL(a, DoA(1));
+ const ExpectationSet es = EXPECT_CALL(a, DoA(2));
+ EXPECT_CALL(a, ReturnResult(3))
+ .After(e, es);
+
+ // May only be called last.
+ EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+ a.DoA(2);
+ a.DoA(1);
+ a.ReturnResult(3);
+}
+
+// Calls must satisfy the partial order when specified so.
+TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
+ MockA a;
+
+ // Define ordering:
+ // a.DoA(1) ==>
+ // a.DoA(2) ==> a.DoA(3)
+ Expectation e = EXPECT_CALL(a, DoA(1));
+ const ExpectationSet es = EXPECT_CALL(a, DoA(2));
+ EXPECT_CALL(a, DoA(3))
+ .After(e, es);
+
+ a.DoA(2);
+
+ // May only be called last.
+ EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
+
+ a.DoA(1);
+ a.DoA(3);
+}
+
+// .After() can be combined with .InSequence().
+TEST(AfterTest, CanBeUsedWithInSequence) {
+ MockA a;
+ Sequence s;
+ Expectation e = EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(2)).InSequence(s);
+ EXPECT_CALL(a, DoA(3))
+ .InSequence(s)
+ .After(e);
+
+ a.DoA(1);
+
+ // May only be after DoA(2).
+ EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
+
+ a.DoA(2);
+ a.DoA(3);
+}
+
+// .After() can be called multiple times.
+TEST(AfterTest, CanBeCalledManyTimes) {
+ MockA a;
+ Expectation e1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(a, DoA(2));
+ Expectation e3 = EXPECT_CALL(a, DoA(3));
+ EXPECT_CALL(a, DoA(4))
+ .After(e1)
+ .After(e2)
+ .After(e3);
+
+ a.DoA(3);
+ a.DoA(1);
+ a.DoA(2);
+ a.DoA(4);
+}
+
+// .After() accepts up to 5 arguments.
+TEST(AfterTest, AcceptsUpToFiveArguments) {
+ MockA a;
+ Expectation e1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(a, DoA(2));
+ Expectation e3 = EXPECT_CALL(a, DoA(3));
+ ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
+ ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
+ EXPECT_CALL(a, DoA(6))
+ .After(e1, e2, e3, es1, es2);
+
+ a.DoA(5);
+ a.DoA(2);
+ a.DoA(4);
+ a.DoA(1);
+ a.DoA(3);
+ a.DoA(6);
+}
+
+// .After() allows input to contain duplicated Expectations.
+TEST(AfterTest, AcceptsDuplicatedInput) {
+ MockA a;
+ ON_CALL(a, ReturnResult(_))
+ .WillByDefault(Return(Result()));
+
+ // Define ordering:
+ // DoA(1) ==>
+ // DoA(2) ==> ReturnResult(3)
+ Expectation e1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(a, DoA(2));
+ ExpectationSet es;
+ es += e1;
+ es += e2;
+ EXPECT_CALL(a, ReturnResult(3))
+ .After(e1, e2, es, e1);
+
+ a.DoA(1);
+
+ // May only be after DoA(2).
+ EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
+
+ a.DoA(2);
+ a.ReturnResult(3);
+}
+
+// An Expectation added to an ExpectationSet after it has been used in
+// an .After() has no effect.
+TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
+ MockA a;
+ ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
+ Expectation e2 = EXPECT_CALL(a, DoA(2));
+ EXPECT_CALL(a, DoA(3))
+ .After(es1);
+ es1 += e2;
+
+ a.DoA(1);
+ a.DoA(3);
+ a.DoA(2);
+}
+
+// Tests that Google Mock correctly handles calls to mock functions
+// after a mock object owning one of their pre-requisites has died.
+
+// Tests that calls that satisfy the original spec are successful.
+TEST(DeletingMockEarlyTest, Success1) {
+ MockB* const b1 = new MockB;
+ MockA* const a = new MockA;
+ MockB* const b2 = new MockB;
+
+ {
+ InSequence dummy;
+ EXPECT_CALL(*b1, DoB(_))
+ .WillOnce(Return(1));
+ EXPECT_CALL(*a, Binary(_, _))
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*b2, DoB(_))
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(2));
+ }
+
+ EXPECT_EQ(1, b1->DoB(1));
+ delete b1;
+ // a's pre-requisite has died.
+ EXPECT_TRUE(a->Binary(0, 1));
+ delete b2;
+ // a's successor has died.
+ EXPECT_TRUE(a->Binary(1, 2));
+ delete a;
+}
+
+// Tests that calls that satisfy the original spec are successful.
+TEST(DeletingMockEarlyTest, Success2) {
+ MockB* const b1 = new MockB;
+ MockA* const a = new MockA;
+ MockB* const b2 = new MockB;
+
+ {
+ InSequence dummy;
+ EXPECT_CALL(*b1, DoB(_))
+ .WillOnce(Return(1));
+ EXPECT_CALL(*a, Binary(_, _))
+ .Times(AnyNumber());
+ EXPECT_CALL(*b2, DoB(_))
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(2));
+ }
+
+ delete a; // a is trivially satisfied.
+ EXPECT_EQ(1, b1->DoB(1));
+ EXPECT_EQ(2, b2->DoB(2));
+ delete b1;
+ delete b2;
+}
+
+// Tests that it's OK to delete a mock object itself in its action.
+
+// Suppresses warning on unreferenced formal parameter in MSVC with
+// -W4.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+ACTION_P(Delete, ptr) { delete ptr; }
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
+ MockA* const a = new MockA;
+ EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
+ a->DoA(42); // This will cause a to be deleted.
+}
+
+TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
+ MockA* const a = new MockA;
+ EXPECT_CALL(*a, ReturnResult(_))
+ .WillOnce(DoAll(Delete(a), Return(Result())));
+ a->ReturnResult(42); // This will cause a to be deleted.
+}
+
+// Tests that calls that violate the original spec yield failures.
+TEST(DeletingMockEarlyTest, Failure1) {
+ MockB* const b1 = new MockB;
+ MockA* const a = new MockA;
+ MockB* const b2 = new MockB;
+
+ {
+ InSequence dummy;
+ EXPECT_CALL(*b1, DoB(_))
+ .WillOnce(Return(1));
+ EXPECT_CALL(*a, Binary(_, _))
+ .Times(AnyNumber());
+ EXPECT_CALL(*b2, DoB(_))
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(2));
+ }
+
+ delete a; // a is trivially satisfied.
+ EXPECT_NONFATAL_FAILURE({
+ b2->DoB(2);
+ }, "Unexpected mock function call");
+ EXPECT_EQ(1, b1->DoB(1));
+ delete b1;
+ delete b2;
+}
+
+// Tests that calls that violate the original spec yield failures.
+TEST(DeletingMockEarlyTest, Failure2) {
+ MockB* const b1 = new MockB;
+ MockA* const a = new MockA;
+ MockB* const b2 = new MockB;
+
+ {
+ InSequence dummy;
+ EXPECT_CALL(*b1, DoB(_));
+ EXPECT_CALL(*a, Binary(_, _))
+ .Times(AnyNumber());
+ EXPECT_CALL(*b2, DoB(_))
+ .Times(AnyNumber());
+ }
+
+ EXPECT_NONFATAL_FAILURE(delete b1,
+ "Actual: never called");
+ EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
+ "Unexpected mock function call");
+ EXPECT_NONFATAL_FAILURE(b2->DoB(1),
+ "Unexpected mock function call");
+ delete a;
+ delete b2;
+}
+
+class EvenNumberCardinality : public CardinalityInterface {
+ public:
+ // Returns true iff call_count calls will satisfy this cardinality.
+ virtual bool IsSatisfiedByCallCount(int call_count) const {
+ return call_count % 2 == 0;
+ }
+
+ // Returns true iff call_count calls will saturate this cardinality.
+ virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+ return false;
+ }
+
+ // Describes self to an ostream.
+ virtual void DescribeTo(::std::ostream* os) const {
+ *os << "called even number of times";
+ }
+};
+
+Cardinality EvenNumber() {
+ return Cardinality(new EvenNumberCardinality);
+}
+
+TEST(ExpectationBaseTest,
+ AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
+ MockA* a = new MockA;
+ Sequence s;
+
+ EXPECT_CALL(*a, DoA(1))
+ .Times(EvenNumber())
+ .InSequence(s);
+ EXPECT_CALL(*a, DoA(2))
+ .Times(AnyNumber())
+ .InSequence(s);
+ EXPECT_CALL(*a, DoA(3))
+ .Times(AnyNumber());
+
+ a->DoA(3);
+ a->DoA(1);
+ EXPECT_NONFATAL_FAILURE(a->DoA(2), "Unexpected mock function call");
+ EXPECT_NONFATAL_FAILURE(delete a, "to be called even number of times");
+}
+
+// The following tests verify the message generated when a mock
+// function is called.
+
+struct Printable {
+};
+
+inline void operator<<(::std::ostream& os, const Printable&) {
+ os << "Printable";
+}
+
+struct Unprintable {
+ Unprintable() : value(0) {}
+ int value;
+};
+
+class MockC {
+ public:
+ MockC() {}
+
+ MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
+ const Printable& x, Unprintable y));
+ MOCK_METHOD0(NonVoidMethod, int()); // NOLINT
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
+};
+
+class VerboseFlagPreservingFixture : public testing::Test {
+ protected:
+ VerboseFlagPreservingFixture()
+ : saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
+
+ ~VerboseFlagPreservingFixture() { GMOCK_FLAG(verbose) = saved_verbose_flag_; }
+
+ private:
+ const string saved_verbose_flag_;
+
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
+};
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Tests that an uninteresting mock function call on a naggy mock
+// generates a warning without the stack trace when
+// --gmock_verbose=warning is specified.
+TEST(FunctionCallMessageTest,
+ UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
+ GMOCK_FLAG(verbose) = kWarningVerbosity;
+ NaggyMock<MockC> c;
+ CaptureStdout();
+ c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+ const std::string output = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
+ EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output);
+}
+
+// Tests that an uninteresting mock function call on a naggy mock
+// generates a warning containing the stack trace when
+// --gmock_verbose=info is specified.
+TEST(FunctionCallMessageTest,
+ UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
+ GMOCK_FLAG(verbose) = kInfoVerbosity;
+ NaggyMock<MockC> c;
+ CaptureStdout();
+ c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+ const std::string output = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
+ EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
+
+# ifndef NDEBUG
+
+ // We check the stack trace content in dbg-mode only, as opt-mode
+ // may inline the call we are interested in seeing.
+
+ // Verifies that a void mock function's name appears in the stack
+ // trace.
+ EXPECT_PRED_FORMAT2(IsSubstring, "VoidMethod(", output);
+
+ // Verifies that a non-void mock function's name appears in the
+ // stack trace.
+ CaptureStdout();
+ c.NonVoidMethod();
+ const std::string output2 = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(IsSubstring, "NonVoidMethod(", output2);
+
+# endif // NDEBUG
+}
+
+// Tests that an uninteresting mock function call on a naggy mock
+// causes the function arguments and return value to be printed.
+TEST(FunctionCallMessageTest,
+ UninterestingCallOnNaggyMockPrintsArgumentsAndReturnValue) {
+ // A non-void mock function.
+ NaggyMock<MockB> b;
+ CaptureStdout();
+ b.DoB();
+ const std::string output1 = GetCapturedStdout();
+ EXPECT_PRED_FORMAT2(
+ IsSubstring,
+ "Uninteresting mock function call - returning default value.\n"
+ " Function call: DoB()\n"
+ " Returns: 0\n", output1.c_str());
+ // Makes sure the return value is printed.
+
+ // A void mock function.
+ NaggyMock<MockC> c;
+ CaptureStdout();
+ c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable());
+ const std::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 <00-00 00-00>\\)"));
+ // A void function has no return value to print.
+}
+
+// Tests how the --gmock_verbose flag affects Google Mock's output.
+
+class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
+ public:
+ // Verifies that the given Google Mock output is correct. (When
+ // 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 std::string& output, bool should_print,
+ const string& expected_substring,
+ const string& function_name) {
+ if (should_print) {
+ 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_THAT(output.c_str(), HasSubstr(function_name));
+# else
+ // Suppresses 'unused function parameter' warnings.
+ static_cast<void>(function_name);
+# endif // NDEBUG
+ } else {
+ EXPECT_STREQ("", output.c_str());
+ }
+ }
+
+ // Tests how the flag affects expected calls.
+ void TestExpectedCall(bool should_print) {
+ MockA a;
+ EXPECT_CALL(a, DoA(5));
+ EXPECT_CALL(a, Binary(_, 1))
+ .WillOnce(Return(true));
+
+ // A void-returning function.
+ CaptureStdout();
+ a.DoA(5);
+ VerifyOutput(
+ GetCapturedStdout(),
+ should_print,
+ "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
+ " Function call: DoA(5)\n"
+ "Stack trace:\n",
+ "DoA");
+
+ // A non-void-returning function.
+ CaptureStdout();
+ a.Binary(2, 1);
+ VerifyOutput(
+ GetCapturedStdout(),
+ should_print,
+ "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
+ " Function call: Binary(2, 1)\n"
+ " Returns: true\n"
+ "Stack trace:\n",
+ "Binary");
+ }
+
+ // Tests how the flag affects uninteresting calls on a naggy mock.
+ void TestUninterestingCallOnNaggyMock(bool should_print) {
+ NaggyMock<MockA> a;
+ const string note =
+ "NOTE: You can safely ignore the above warning unless this "
+ "call should not happen. Do not suppress it by blindly adding "
+ "an EXPECT_CALL() if you don't mean to enforce the call. "
+ "See https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#"
+ "knowing-when-to-expect for details.";
+
+ // A void-returning function.
+ CaptureStdout();
+ a.DoA(5);
+ VerifyOutput(
+ GetCapturedStdout(),
+ should_print,
+ "\nGMOCK WARNING:\n"
+ "Uninteresting mock function call - returning directly.\n"
+ " Function call: DoA(5)\n" +
+ note,
+ "DoA");
+
+ // A non-void-returning function.
+ CaptureStdout();
+ a.Binary(2, 1);
+ VerifyOutput(
+ GetCapturedStdout(),
+ should_print,
+ "\nGMOCK WARNING:\n"
+ "Uninteresting mock function call - returning default value.\n"
+ " Function call: Binary(2, 1)\n"
+ " Returns: false\n" +
+ note,
+ "Binary");
+ }
+};
+
+// Tests that --gmock_verbose=info causes both expected and
+// uninteresting calls to be reported.
+TEST_F(GMockVerboseFlagTest, Info) {
+ GMOCK_FLAG(verbose) = kInfoVerbosity;
+ TestExpectedCall(true);
+ TestUninterestingCallOnNaggyMock(true);
+}
+
+// Tests that --gmock_verbose=warning causes uninteresting calls to be
+// reported.
+TEST_F(GMockVerboseFlagTest, Warning) {
+ GMOCK_FLAG(verbose) = kWarningVerbosity;
+ TestExpectedCall(false);
+ TestUninterestingCallOnNaggyMock(true);
+}
+
+// Tests that --gmock_verbose=warning causes neither expected nor
+// uninteresting calls to be reported.
+TEST_F(GMockVerboseFlagTest, Error) {
+ GMOCK_FLAG(verbose) = kErrorVerbosity;
+ TestExpectedCall(false);
+ TestUninterestingCallOnNaggyMock(false);
+}
+
+// Tests that --gmock_verbose=SOME_INVALID_VALUE has the same effect
+// as --gmock_verbose=warning.
+TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
+ GMOCK_FLAG(verbose) = "invalid"; // Treated as "warning".
+ TestExpectedCall(false);
+ TestUninterestingCallOnNaggyMock(true);
+}
+
+#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
+// buffer) when it is not supposed to do so.
+class PrintMeNot {};
+
+void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
+ ADD_FAILURE() << "Google Mock is printing a value that shouldn't be "
+ << "printed even to an internal buffer.";
+}
+
+class LogTestHelper {
+ public:
+ LogTestHelper() {}
+
+ MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
+
+ private:
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
+};
+
+class GMockLogTest : public VerboseFlagPreservingFixture {
+ protected:
+ LogTestHelper helper_;
+};
+
+TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
+ GMOCK_FLAG(verbose) = kWarningVerbosity;
+ EXPECT_CALL(helper_, Foo(_))
+ .WillOnce(Return(PrintMeNot()));
+ helper_.Foo(PrintMeNot()); // This is an expected call.
+}
+
+TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
+ GMOCK_FLAG(verbose) = kErrorVerbosity;
+ EXPECT_CALL(helper_, Foo(_))
+ .WillOnce(Return(PrintMeNot()));
+ helper_.Foo(PrintMeNot()); // This is an expected call.
+}
+
+TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
+ GMOCK_FLAG(verbose) = kErrorVerbosity;
+ ON_CALL(helper_, Foo(_))
+ .WillByDefault(Return(PrintMeNot()));
+ helper_.Foo(PrintMeNot()); // This should generate a warning.
+}
+
+// Tests Mock::AllowLeak().
+
+TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
+ MockA* a = new MockA;
+ Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
+ MockA* a = new MockA;
+ Mock::AllowLeak(a);
+ ON_CALL(*a, DoA(_)).WillByDefault(Return());
+ a->DoA(0);
+}
+
+TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
+ MockA* a = new MockA;
+ ON_CALL(*a, DoA(_)).WillByDefault(Return());
+ Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
+ MockA* a = new MockA;
+ Mock::AllowLeak(a);
+ EXPECT_CALL(*a, DoA(_));
+ a->DoA(0);
+}
+
+TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
+ MockA* a = new MockA;
+ EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
+ Mock::AllowLeak(a);
+}
+
+TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
+ MockA* a = new MockA;
+ ON_CALL(*a, DoA(_)).WillByDefault(Return());
+ EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
+ Mock::AllowLeak(a);
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when none of its methods has expectations.
+TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
+ MockB b;
+ ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when some, but not all, of its methods have expectations *and* the
+// verification succeeds.
+TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1));
+ b.DoB();
+ ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when some, but not all, of its methods have expectations *and* the
+// verification fails.
+TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1));
+ bool result = true;
+ EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
+ "Actual: never called");
+ ASSERT_FALSE(result);
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when all of its methods have expectations.
+TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
+ MockB b;
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(1));
+ EXPECT_CALL(b, DoB(_))
+ .WillOnce(Return(2));
+ b.DoB();
+ b.DoB(1);
+ ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can verify and clear a mock object's expectations
+// when a method has more than one expectation.
+TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
+ MockB b;
+ EXPECT_CALL(b, DoB(0))
+ .WillOnce(Return(1));
+ EXPECT_CALL(b, DoB(_))
+ .WillOnce(Return(2));
+ b.DoB(1);
+ bool result = true;
+ EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
+ "Actual: never called");
+ ASSERT_FALSE(result);
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can call VerifyAndClearExpectations() on the same
+// mock object multiple times.
+TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
+ MockB b;
+ EXPECT_CALL(b, DoB());
+ b.DoB();
+ Mock::VerifyAndClearExpectations(&b);
+
+ EXPECT_CALL(b, DoB(_))
+ .WillOnce(Return(1));
+ b.DoB(1);
+ Mock::VerifyAndClearExpectations(&b);
+ Mock::VerifyAndClearExpectations(&b);
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can clear a mock object's default actions when none
+// of its methods has default actions.
+TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
+ MockB b;
+ // If this crashes or generates a failure, the test will catch it.
+ Mock::VerifyAndClear(&b);
+ EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that we can clear a mock object's default actions when some,
+// but not all of its methods have default actions.
+TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
+ MockB b;
+ ON_CALL(b, DoB())
+ .WillByDefault(Return(1));
+
+ Mock::VerifyAndClear(&b);
+
+ // Verifies that the default action of int DoB() was removed.
+ EXPECT_EQ(0, b.DoB());
+}
+
+// Tests that we can clear a mock object's default actions when all of
+// its methods have default actions.
+TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
+ MockB b;
+ ON_CALL(b, DoB())
+ .WillByDefault(Return(1));
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(2));
+
+ Mock::VerifyAndClear(&b);
+
+ // Verifies that the default action of int DoB() was removed.
+ EXPECT_EQ(0, b.DoB());
+
+ // Verifies that the default action of int DoB(int) was removed.
+ EXPECT_EQ(0, b.DoB(0));
+}
+
+// Tests that we can clear a mock object's default actions when a
+// method has more than one ON_CALL() set on it.
+TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
+ MockB b;
+ ON_CALL(b, DoB(0))
+ .WillByDefault(Return(1));
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(2));
+
+ Mock::VerifyAndClear(&b);
+
+ // Verifies that the default actions (there are two) of int DoB(int)
+ // were removed.
+ EXPECT_EQ(0, b.DoB(0));
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can call VerifyAndClear() on a mock object multiple
+// times.
+TEST(VerifyAndClearTest, CanCallManyTimes) {
+ MockB b;
+ ON_CALL(b, DoB())
+ .WillByDefault(Return(1));
+ Mock::VerifyAndClear(&b);
+ Mock::VerifyAndClear(&b);
+
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(1));
+ Mock::VerifyAndClear(&b);
+
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the verification succeeds.
+TEST(VerifyAndClearTest, Success) {
+ MockB b;
+ ON_CALL(b, DoB())
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b, DoB(1))
+ .WillOnce(Return(2));
+
+ b.DoB();
+ b.DoB(1);
+ ASSERT_TRUE(Mock::VerifyAndClear(&b));
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the verification fails.
+TEST(VerifyAndClearTest, Failure) {
+ MockB b;
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(2));
+
+ b.DoB(1);
+ bool result = true;
+ EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
+ "Actual: never called");
+ ASSERT_FALSE(result);
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that VerifyAndClear() works when the default actions and
+// expectations are set on a const mock object.
+TEST(VerifyAndClearTest, Const) {
+ MockB b;
+ ON_CALL(Const(b), DoB())
+ .WillByDefault(Return(1));
+
+ EXPECT_CALL(Const(b), DoB())
+ .WillOnce(DoDefault())
+ .WillOnce(Return(2));
+
+ b.DoB();
+ b.DoB();
+ ASSERT_TRUE(Mock::VerifyAndClear(&b));
+
+ // There should be no expectations on the methods now, so we can
+ // freely call them.
+ EXPECT_EQ(0, b.DoB());
+ EXPECT_EQ(0, b.DoB(1));
+}
+
+// Tests that we can set default actions and expectations on a mock
+// object after VerifyAndClear() has been called on it.
+TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
+ MockB b;
+ ON_CALL(b, DoB())
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b, DoB(_))
+ .WillOnce(Return(2));
+ b.DoB(1);
+
+ Mock::VerifyAndClear(&b);
+
+ EXPECT_CALL(b, DoB())
+ .WillOnce(Return(3));
+ ON_CALL(b, DoB(_))
+ .WillByDefault(Return(4));
+
+ EXPECT_EQ(3, b.DoB());
+ EXPECT_EQ(4, b.DoB(1));
+}
+
+// Tests that calling VerifyAndClear() on one mock object does not
+// affect other mock objects (either of the same type or not).
+TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
+ MockA a;
+ MockB b1;
+ MockB b2;
+
+ ON_CALL(a, Binary(_, _))
+ .WillByDefault(Return(true));
+ EXPECT_CALL(a, Binary(_, _))
+ .WillOnce(DoDefault())
+ .WillOnce(Return(false));
+
+ ON_CALL(b1, DoB())
+ .WillByDefault(Return(1));
+ EXPECT_CALL(b1, DoB(_))
+ .WillOnce(Return(2));
+
+ ON_CALL(b2, DoB())
+ .WillByDefault(Return(3));
+ EXPECT_CALL(b2, DoB(_));
+
+ b2.DoB(0);
+ Mock::VerifyAndClear(&b2);
+
+ // Verifies that the default actions and expectations of a and b1
+ // are still in effect.
+ EXPECT_TRUE(a.Binary(0, 0));
+ EXPECT_FALSE(a.Binary(0, 0));
+
+ EXPECT_EQ(1, b1.DoB());
+ EXPECT_EQ(2, b1.DoB(0));
+}
+
+TEST(VerifyAndClearTest,
+ DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
+ linked_ptr<MockA> a(new MockA);
+ ReferenceHoldingMock test_mock;
+
+ // EXPECT_CALL stores a reference to a inside test_mock.
+ EXPECT_CALL(test_mock, AcceptReference(_))
+ .WillRepeatedly(SetArgPointee<0>(a));
+
+ // Throw away the reference to the mock that we have in a. After this, the
+ // only reference to it is stored by test_mock.
+ a.reset();
+
+ // When test_mock goes out of scope, it destroys the last remaining reference
+ // to the mock object originally pointed to by a. This will cause the MockA
+ // destructor to be called from inside the ReferenceHoldingMock destructor.
+ // The state of all mocks is protected by a single global lock, but there
+ // should be no deadlock.
+}
+
+TEST(VerifyAndClearTest,
+ DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
+ linked_ptr<MockA> a(new MockA);
+ ReferenceHoldingMock test_mock;
+
+ // ON_CALL stores a reference to a inside test_mock.
+ ON_CALL(test_mock, AcceptReference(_))
+ .WillByDefault(SetArgPointee<0>(a));
+
+ // Throw away the reference to the mock that we have in a. After this, the
+ // only reference to it is stored by test_mock.
+ a.reset();
+
+ // When test_mock goes out of scope, it destroys the last remaining reference
+ // to the mock object originally pointed to by a. This will cause the MockA
+ // destructor to be called from inside the ReferenceHoldingMock destructor.
+ // The state of all mocks is protected by a single global lock, but there
+ // should be no deadlock.
+}
+
+// Tests that a mock function's action can call a mock function
+// (either the same function or a different one) either as an explicit
+// action or as a default action without causing a dead lock. It
+// verifies that the action is not performed inside the critical
+// section.
+TEST(SynchronizationTest, CanCallMockMethodInAction) {
+ MockA a;
+ MockC c;
+ ON_CALL(a, DoA(_))
+ .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
+ &MockC::NonVoidMethod)));
+ EXPECT_CALL(a, DoA(1));
+ EXPECT_CALL(a, DoA(1))
+ .WillOnce(Invoke(&a, &MockA::DoA))
+ .RetiresOnSaturation();
+ EXPECT_CALL(c, NonVoidMethod());
+
+ a.DoA(1);
+ // This will match the second EXPECT_CALL() and trigger another a.DoA(1),
+ // which will in turn match the first EXPECT_CALL() and trigger a call to
+ // c.NonVoidMethod() that was specified by the ON_CALL() since the first
+ // EXPECT_CALL() did not specify an action.
+}
+
+} // namespace
+
+// Allows the user to define his own main and then invoke gmock_main
+// from it. This might be necessary on some platforms which require
+// specific setup and teardown.
+#if GMOCK_RENAME_MAIN
+int gmock_main(int argc, char **argv) {
+#else
+int main(int argc, char **argv) {
+#endif // GMOCK_RENAME_MAIN
+ testing::InitGoogleMock(&argc, argv);
+
+ // Ensures that the tests pass no matter what value of
+ // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
+ testing::GMOCK_FLAG(catch_leaked_mocks) = true;
+ testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
+
+ return RUN_ALL_TESTS();
+}