Diffusion sp4e-homework-lars-bertil (master) Browse

gmock-spec-builders_test.cc
a3c0dd0f4d58master

gmock-spec-builders_test.cc
View Options

			// 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.


			// 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::SaveArg;
			using testing::Sequence;
			using testing::SetArgPointee;
			using testing::internal::ExpectationTester;
			using testing::internal::FormatFileLocation;
			using testing::internal::kAllow;
			using testing::internal::kErrorVerbosity;
			using testing::internal::kFail;
			using testing::internal::kInfoVerbosity;
			using testing::internal::kWarn;
			using testing::internal::kWarningVerbosity;
			using testing::internal::linked_ptr;

			#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();
			}

			TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
			int original_behavior = testing::GMOCK_FLAG(default_mock_behavior);

			testing::GMOCK_FLAG(default_mock_behavior) = kAllow;
			CaptureStdout();
			{
			MockA a;
			a.DoA(0);
			}
			std::string output = GetCapturedStdout();
			EXPECT_TRUE(output.empty()) << output;

			testing::GMOCK_FLAG(default_mock_behavior) = kWarn;
			CaptureStdout();
			{
			MockA a;
			a.DoA(0);
			}
			std::string warning_output = GetCapturedStdout();
			EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
			EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
			warning_output);

			testing::GMOCK_FLAG(default_mock_behavior) = kFail;
			EXPECT_NONFATAL_FAILURE({
			MockA a;
			a.DoA(0);
			}, "Uninteresting mock function call");

			// Out of bounds values are converted to kWarn
			testing::GMOCK_FLAG(default_mock_behavior) = -1;
			CaptureStdout();
			{
			MockA a;
			a.DoA(0);
			}
			warning_output = GetCapturedStdout();
			EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
			EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
			warning_output);
			testing::GMOCK_FLAG(default_mock_behavior) = 3;
			CaptureStdout();
			{
			MockA a;
			a.DoA(0);
			}
			warning_output = GetCapturedStdout();
			EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
			EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
			warning_output);

			testing::GMOCK_FLAG(default_mock_behavior) = original_behavior;
			}

			#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, std::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 std::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 std::string& expected_substring,
			const std::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 std::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.
			}

			TEST(ParameterlessExpectationsTest, CanSetExpectationsWithoutMatchers) {
			MockA a;
			int do_a_arg0 = 0;
			ON_CALL(a, DoA).WillByDefault(SaveArg<0>(&do_a_arg0));
			int do_a_47_arg0 = 0;
			ON_CALL(a, DoA(47)).WillByDefault(SaveArg<0>(&do_a_47_arg0));

			a.DoA(17);
			EXPECT_THAT(do_a_arg0, 17);
			EXPECT_THAT(do_a_47_arg0, 0);
			a.DoA(47);
			EXPECT_THAT(do_a_arg0, 17);
			EXPECT_THAT(do_a_47_arg0, 47);

			ON_CALL(a, Binary).WillByDefault(Return(true));
			ON_CALL(a, Binary(_, 14)).WillByDefault(Return(false));
			EXPECT_THAT(a.Binary(14, 17), true);
			EXPECT_THAT(a.Binary(17, 14), false);
			}

			TEST(ParameterlessExpectationsTest, CanSetExpectationsForOverloadedMethods) {
			MockB b;
			ON_CALL(b, DoB()).WillByDefault(Return(9));
			ON_CALL(b, DoB(5)).WillByDefault(Return(11));

			EXPECT_THAT(b.DoB(), 9);
			EXPECT_THAT(b.DoB(1), 0); // default value
			EXPECT_THAT(b.DoB(5), 11);
			}

			struct MockWithConstMethods {
			public:
			MOCK_CONST_METHOD1(Foo, int(int));
			MOCK_CONST_METHOD2(Bar, int(int, const char*));
			};

			TEST(ParameterlessExpectationsTest, CanSetExpectationsForConstMethods) {
			MockWithConstMethods mock;
			ON_CALL(mock, Foo).WillByDefault(Return(7));
			ON_CALL(mock, Bar).WillByDefault(Return(33));

			EXPECT_THAT(mock.Foo(17), 7);
			EXPECT_THAT(mock.Bar(27, "purple"), 33);
			}

			class MockConstOverload {
			public:
			MOCK_METHOD1(Overloaded, int(int));
			MOCK_CONST_METHOD1(Overloaded, int(int));
			};

			TEST(ParameterlessExpectationsTest,
			CanSetExpectationsForConstOverloadedMethods) {
			MockConstOverload mock;
			ON_CALL(mock, Overloaded(_)).WillByDefault(Return(7));
			ON_CALL(mock, Overloaded(5)).WillByDefault(Return(9));
			ON_CALL(Const(mock), Overloaded(5)).WillByDefault(Return(11));
			ON_CALL(Const(mock), Overloaded(7)).WillByDefault(Return(13));

			EXPECT_THAT(mock.Overloaded(1), 7);
			EXPECT_THAT(mock.Overloaded(5), 9);
			EXPECT_THAT(mock.Overloaded(7), 7);

			const MockConstOverload& const_mock = mock;
			EXPECT_THAT(const_mock.Overloaded(1), 0);
			EXPECT_THAT(const_mock.Overloaded(5), 11);
			EXPECT_THAT(const_mock.Overloaded(7), 13);
			}

			} // namespace

			// Allows the user to define their 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();
			}

R9484/googlemock/test/gmock-spec-builders_test.cca3c0dd0f4d58master

gmock-spec-builders_test.ccView Options

R9484/googlemock/test/gmock-spec-builders_test.cc
a3c0dd0f4d58master

gmock-spec-builders_test.cc
View Options