rj_schema 0.2.3 → 0.2.4

data/ext/rj_schema/rapidjson/thirdparty/gtest/googlemock/test/gmock-spec-builders_test.cc

@@ -1,2644 +0,0 @@
-// 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();
-}