// 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();