Index: projects/clang900-import/contrib/googletest/googlemock/test/gmock-spec-builders_test.cc
===================================================================
--- projects/clang900-import/contrib/googletest/googlemock/test/gmock-spec-builders_test.cc	(revision 352335)
+++ projects/clang900-import/contrib/googletest/googlemock/test/gmock-spec-builders_test.cc	(revision 352336)
@@ -1,2770 +1,2771 @@
 // 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 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;
   // FIXME: 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();
 }