path: root/contrib/restricted/googletest/googlemock/include/gmock/gmock-spec-builders.h

// 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 implements the ON_CALL() and EXPECT_CALL() macros. 
// 
// A user can use the ON_CALL() macro to specify the default action of 
// a mock method.  The syntax is: 
// 
//   ON_CALL(mock_object, Method(argument-matchers)) 
//       .With(multi-argument-matcher) 
//       .WillByDefault(action); 
// 
//  where the .With() clause is optional. 
// 
// A user can use the EXPECT_CALL() macro to specify an expectation on 
// a mock method.  The syntax is: 
// 
//   EXPECT_CALL(mock_object, Method(argument-matchers)) 
//       .With(multi-argument-matchers) 
//       .Times(cardinality) 
//       .InSequence(sequences) 
//       .After(expectations) 
//       .WillOnce(action) 
//       .WillRepeatedly(action) 
//       .RetiresOnSaturation(); 
// 
// where all clauses are optional, and .InSequence()/.After()/ 
// .WillOnce() can appear any number of times. 
 
// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
 
#include <functional>
#include <map> 
#include <memory>
#include <set> 
#include <sstream> 
#include <string> 
#include <type_traits>
#include <utility>
#include <vector> 
#include "gmock/gmock-actions.h" 
#include "gmock/gmock-cardinalities.h" 
#include "gmock/gmock-matchers.h" 
#include "gmock/internal/gmock-internal-utils.h" 
#include "gmock/internal/gmock-port.h" 
#include "gtest/gtest.h" 
 
#if GTEST_HAS_EXCEPTIONS
# include <stdexcept>  // NOLINT
#endif

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

namespace testing { 
 
// An abstract handle of an expectation. 
class Expectation; 
 
// A set of expectation handles. 
class ExpectationSet; 
 
// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION 
// and MUST NOT BE USED IN USER CODE!!! 
namespace internal { 
 
// Implements a mock function. 
template <typename F> class FunctionMocker; 
 
// Base class for expectations. 
class ExpectationBase; 
 
// Implements an expectation. 
template <typename F> class TypedExpectation; 
 
// Helper class for testing the Expectation class template. 
class ExpectationTester; 
 
// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
template <typename MockClass>
class NiceMockImpl;
template <typename MockClass>
class StrictMockImpl;
template <typename MockClass>
class NaggyMockImpl;

// Protects the mock object registry (in class Mock), all function 
// mockers, and all expectations. 
// 
// The reason we don't use more fine-grained protection is: when a 
// mock function Foo() is called, it needs to consult its expectations 
// to see which one should be picked.  If another thread is allowed to 
// call a mock function (either Foo() or a different one) at the same 
// time, it could affect the "retired" attributes of Foo()'s 
// expectations when InSequence() is used, and thus affect which 
// expectation gets picked.  Therefore, we sequence all mock function 
// calls to ensure the integrity of the mock objects' states. 
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex); 
 
// Untyped base class for ActionResultHolder<R>. 
class UntypedActionResultHolderBase; 
 
// Abstract base class of FunctionMocker.  This is the
// type-agnostic part of the function mocker interface.  Its pure 
// virtual methods are implemented by FunctionMocker.
class GTEST_API_ UntypedFunctionMockerBase { 
 public: 
  UntypedFunctionMockerBase(); 
  virtual ~UntypedFunctionMockerBase(); 
 
  // Verifies that all expectations on this mock function have been 
  // satisfied.  Reports one or more Google Test non-fatal failures 
  // and returns false if not. 
  bool VerifyAndClearExpectationsLocked() 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); 
 
  // Clears the ON_CALL()s set on this mock function. 
  virtual void ClearDefaultActionsLocked() 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0; 
 
  // In all of the following Untyped* functions, it's the caller's 
  // responsibility to guarantee the correctness of the arguments' 
  // types. 
 
  // Performs the default action with the given arguments and returns 
  // the action's result.  The call description string will be used in 
  // the error message to describe the call in the case the default 
  // action fails. 
  // L = * 
  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction( 
      void* untyped_args, const std::string& call_description) const = 0;
 
  // Performs the given action with the given arguments and returns 
  // the action's result. 
  // L = * 
  virtual UntypedActionResultHolderBase* UntypedPerformAction( 
      const void* untyped_action, void* untyped_args) const = 0;
 
  // Writes a message that the call is uninteresting (i.e. neither 
  // explicitly expected nor explicitly unexpected) to the given 
  // ostream. 
  virtual void UntypedDescribeUninterestingCall( 
      const void* untyped_args, 
      ::std::ostream* os) const 
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; 
 
  // Returns the expectation that matches the given function arguments 
  // (or NULL is there's no match); when a match is found, 
  // untyped_action is set to point to the action that should be 
  // performed (or NULL if the action is "do default"), and 
  // is_excessive is modified to indicate whether the call exceeds the 
  // expected number. 
  virtual const ExpectationBase* UntypedFindMatchingExpectation( 
      const void* untyped_args, 
      const void** untyped_action, bool* is_excessive, 
      ::std::ostream* what, ::std::ostream* why) 
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0; 
 
  // Prints the given function arguments to the ostream. 
  virtual void UntypedPrintArgs(const void* untyped_args, 
                                ::std::ostream* os) const = 0; 
 
  // Sets the mock object this mock method belongs to, and registers 
  // this information in the global mock registry.  Will be called 
  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock 
  // method. 
  void RegisterOwner(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex); 
 
  // Sets the mock object this mock method belongs to, and sets the 
  // name of the mock function.  Will be called upon each invocation 
  // of this mock function. 
  void SetOwnerAndName(const void* mock_obj, const char* name) 
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex); 
 
  // Returns the mock object this mock method belongs to.  Must be 
  // called after RegisterOwner() or SetOwnerAndName() has been 
  // called. 
  const void* MockObject() const 
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex); 
 
  // Returns the name of this mock method.  Must be called after 
  // SetOwnerAndName() has been called. 
  const char* Name() const 
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex); 
 
  // Returns the result of invoking this mock function with the given 
  // arguments.  This function can be safely called from multiple 
  // threads concurrently.  The caller is responsible for deleting the 
  // result. 
  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 
 protected: 
  typedef std::vector<const void*> UntypedOnCallSpecs; 
 
  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
 
  // Returns an Expectation object that references and co-owns exp, 
  // which must be an expectation on this mock function. 
  Expectation GetHandleOf(ExpectationBase* exp); 
 
  // Address of the mock object this mock method belongs to.  Only 
  // valid after this mock method has been called or 
  // ON_CALL/EXPECT_CALL has been invoked on it. 
  const void* mock_obj_;  // Protected by g_gmock_mutex. 
 
  // Name of the function being mocked.  Only valid after this mock 
  // method has been called. 
  const char* name_;  // Protected by g_gmock_mutex. 
 
  // All default action specs for this function mocker. 
  UntypedOnCallSpecs untyped_on_call_specs_; 
 
  // All expectations for this function mocker. 
  //
  // It's undefined behavior to interleave expectations (EXPECT_CALLs
  // or ON_CALLs) and mock function calls.  Also, the order of
  // expectations is important.  Therefore it's a logic race condition
  // to read/write untyped_expectations_ concurrently.  In order for
  // tools like tsan to catch concurrent read/write accesses to
  // untyped_expectations, we deliberately leave accesses to it
  // unprotected.
  UntypedExpectations untyped_expectations_; 
};  // class UntypedFunctionMockerBase 
 
// Untyped base class for OnCallSpec<F>. 
class UntypedOnCallSpecBase { 
 public: 
  // The arguments are the location of the ON_CALL() statement. 
  UntypedOnCallSpecBase(const char* a_file, int a_line) 
      : file_(a_file), line_(a_line), last_clause_(kNone) {} 
 
  // Where in the source file was the default action spec defined? 
  const char* file() const { return file_; } 
  int line() const { return line_; } 
 
 protected: 
  // Gives each clause in the ON_CALL() statement a name. 
  enum Clause { 
    // Do not change the order of the enum members!  The run-time 
    // syntax checking relies on it. 
    kNone, 
    kWith, 
    kWillByDefault 
  }; 
 
  // Asserts that the ON_CALL() statement has a certain property. 
  void AssertSpecProperty(bool property,
                          const std::string& failure_message) const {
    Assert(property, file_, line_, failure_message); 
  } 
 
  // Expects that the ON_CALL() statement has a certain property. 
  void ExpectSpecProperty(bool property,
                          const std::string& failure_message) const {
    Expect(property, file_, line_, failure_message); 
  } 
 
  const char* file_; 
  int line_; 
 
  // The last clause in the ON_CALL() statement as seen so far. 
  // Initially kNone and changes as the statement is parsed. 
  Clause last_clause_; 
};  // class UntypedOnCallSpecBase 
 
// This template class implements an ON_CALL spec. 
template <typename F> 
class OnCallSpec : public UntypedOnCallSpecBase { 
 public: 
  typedef typename Function<F>::ArgumentTuple ArgumentTuple; 
  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; 
 
  // Constructs an OnCallSpec object from the information inside 
  // the parenthesis of an ON_CALL() statement. 
  OnCallSpec(const char* a_file, int a_line, 
             const ArgumentMatcherTuple& matchers) 
      : UntypedOnCallSpecBase(a_file, a_line), 
        matchers_(matchers), 
        // By default, extra_matcher_ should match anything.  However, 
        // we cannot initialize it with _ as that causes ambiguity between
        // Matcher's copy and move constructor for some argument types.
        extra_matcher_(A<const ArgumentTuple&>()) {}
 
  // Implements the .With() clause. 
  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) { 
    // Makes sure this is called at most once. 
    ExpectSpecProperty(last_clause_ < kWith, 
                       ".With() cannot appear " 
                       "more than once in an ON_CALL()."); 
    last_clause_ = kWith; 
 
    extra_matcher_ = m; 
    return *this; 
  } 
 
  // Implements the .WillByDefault() clause. 
  OnCallSpec& WillByDefault(const Action<F>& action) { 
    ExpectSpecProperty(last_clause_ < kWillByDefault, 
                       ".WillByDefault() must appear " 
                       "exactly once in an ON_CALL()."); 
    last_clause_ = kWillByDefault; 
 
    ExpectSpecProperty(!action.IsDoDefault(), 
                       "DoDefault() cannot be used in ON_CALL()."); 
    action_ = action; 
    return *this; 
  } 
 
  // Returns true if and only if the given arguments match the matchers.
  bool Matches(const ArgumentTuple& args) const { 
    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); 
  } 
 
  // Returns the action specified by the user. 
  const Action<F>& GetAction() const { 
    AssertSpecProperty(last_clause_ == kWillByDefault, 
                       ".WillByDefault() must appear exactly " 
                       "once in an ON_CALL()."); 
    return action_; 
  } 
 
 private: 
  // The information in statement 
  // 
  //   ON_CALL(mock_object, Method(matchers)) 
  //       .With(multi-argument-matcher) 
  //       .WillByDefault(action); 
  // 
  // is recorded in the data members like this: 
  // 
  //   source file that contains the statement => file_ 
  //   line number of the statement            => line_ 
  //   matchers                                => matchers_ 
  //   multi-argument-matcher                  => extra_matcher_ 
  //   action                                  => action_ 
  ArgumentMatcherTuple matchers_; 
  Matcher<const ArgumentTuple&> extra_matcher_; 
  Action<F> action_; 
};  // class OnCallSpec 
 
// Possible reactions on uninteresting calls. 
enum CallReaction { 
  kAllow, 
  kWarn, 
  kFail, 
}; 
 
}  // namespace internal 
 
// Utilities for manipulating mock objects. 
class GTEST_API_ Mock { 
 public: 
  // The following public methods can be called concurrently. 
 
  // Tells Google Mock to ignore mock_obj when checking for leaked 
  // mock objects. 
  static void AllowLeak(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Verifies and clears all expectations on the given mock object. 
  // If the expectations aren't satisfied, generates one or more 
  // Google Test non-fatal failures and returns false. 
  static bool VerifyAndClearExpectations(void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Verifies all expectations on the given mock object and clears its 
  // default actions and expectations.  Returns true if and only if the
  // verification was successful. 
  static bool VerifyAndClear(void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Returns whether the mock was created as a naggy mock (default)
  static bool IsNaggy(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
  // Returns whether the mock was created as a nice mock
  static bool IsNice(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
  // Returns whether the mock was created as a strict mock
  static bool IsStrict(void* mock_obj)
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

 private: 
  friend class internal::UntypedFunctionMockerBase; 
 
  // Needed for a function mocker to register itself (so that we know 
  // how to clear a mock object). 
  template <typename F> 
  friend class internal::FunctionMocker;
 
  template <typename MockClass>
  friend class internal::NiceMockImpl;
  template <typename MockClass>
  friend class internal::NaggyMockImpl;
  template <typename MockClass>
  friend class internal::StrictMockImpl;
 
  // Tells Google Mock to allow uninteresting calls on the given mock 
  // object. 
  static void AllowUninterestingCalls(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Tells Google Mock to warn the user about uninteresting calls on 
  // the given mock object. 
  static void WarnUninterestingCalls(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Tells Google Mock to fail uninteresting calls on the given mock 
  // object. 
  static void FailUninterestingCalls(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Tells Google Mock the given mock object is being destroyed and 
  // its entry in the call-reaction table should be removed. 
  static void UnregisterCallReaction(const void* mock_obj) 
      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Returns the reaction Google Mock will have on uninteresting calls 
  // made on the given mock object. 
  static internal::CallReaction GetReactionOnUninterestingCalls( 
      const void* mock_obj) 
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Verifies that all expectations on the given mock object have been 
  // satisfied.  Reports one or more Google Test non-fatal failures 
  // and returns false if not. 
  static bool VerifyAndClearExpectationsLocked(void* mock_obj) 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); 
 
  // Clears all ON_CALL()s set on the given mock object. 
  static void ClearDefaultActionsLocked(void* mock_obj) 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); 
 
  // Registers a mock object and a mock method it owns. 
  static void Register( 
      const void* mock_obj, 
      internal::UntypedFunctionMockerBase* mocker) 
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Tells Google Mock where in the source code mock_obj is used in an 
  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this 
  // information helps the user identify which object it is. 
  static void RegisterUseByOnCallOrExpectCall( 
      const void* mock_obj, const char* file, int line) 
          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
 
  // Unregisters a mock method; removes the owning mock object from 
  // the registry when the last mock method associated with it has 
  // been unregistered.  This is called only in the destructor of 
  // FunctionMocker.
  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex); 
};  // class Mock 
 
// An abstract handle of an expectation.  Useful in the .After() 
// clause of EXPECT_CALL() for setting the (partial) order of 
// expectations.  The syntax: 
// 
//   Expectation e1 = EXPECT_CALL(...)...; 
//   EXPECT_CALL(...).After(e1)...; 
// 
// sets two expectations where the latter can only be matched after 
// the former has been satisfied. 
// 
// Notes: 
//   - This class is copyable and has value semantics. 
//   - Constness is shallow: a const Expectation object itself cannot 
//     be modified, but the mutable methods of the ExpectationBase 
//     object it references can be called via expectation_base(). 

class GTEST_API_ Expectation { 
 public: 
  // Constructs a null object that doesn't reference any expectation. 
  Expectation(); 
  Expectation(Expectation&&) = default;
  Expectation(const Expectation&) = default;
  Expectation& operator=(Expectation&&) = default;
  Expectation& operator=(const Expectation&) = default;
  ~Expectation(); 
 
  // This single-argument ctor must not be explicit, in order to support the 
  //   Expectation e = EXPECT_CALL(...); 
  // syntax. 
  // 
  // A TypedExpectation object stores its pre-requisites as 
  // Expectation objects, and needs to call the non-const Retire() 
  // method on the ExpectationBase objects they reference.  Therefore 
  // Expectation must receive a *non-const* reference to the 
  // ExpectationBase object. 
  Expectation(internal::ExpectationBase& exp);  // NOLINT 
 
  // The compiler-generated copy ctor and operator= work exactly as 
  // intended, so we don't need to define our own. 
 
  // Returns true if and only if rhs references the same expectation as this
  // object does.
  bool operator==(const Expectation& rhs) const { 
    return expectation_base_ == rhs.expectation_base_; 
  } 
 
  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); } 
 
 private: 
  friend class ExpectationSet; 
  friend class Sequence; 
  friend class ::testing::internal::ExpectationBase; 
  friend class ::testing::internal::UntypedFunctionMockerBase; 
 
  template <typename F> 
  friend class ::testing::internal::FunctionMocker;
 
  template <typename F> 
  friend class ::testing::internal::TypedExpectation; 
 
  // This comparator is needed for putting Expectation objects into a set. 
  class Less { 
   public: 
    bool operator()(const Expectation& lhs, const Expectation& rhs) const { 
      return lhs.expectation_base_.get() < rhs.expectation_base_.get(); 
    } 
  }; 
 
  typedef ::std::set<Expectation, Less> Set; 
 
  Expectation( 
      const std::shared_ptr<internal::ExpectationBase>& expectation_base);
 
  // Returns the expectation this object references. 
  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
    return expectation_base_; 
  } 
 
  // A shared_ptr that co-owns the expectation this handle references.
  std::shared_ptr<internal::ExpectationBase> expectation_base_;
}; 
 
// A set of expectation handles.  Useful in the .After() clause of 
// EXPECT_CALL() for setting the (partial) order of expectations.  The 
// syntax: 
// 
//   ExpectationSet es; 
//   es += EXPECT_CALL(...)...; 
//   es += EXPECT_CALL(...)...; 
//   EXPECT_CALL(...).After(es)...; 
// 
// sets three expectations where the last one can only be matched 
// after the first two have both been satisfied. 
// 
// This class is copyable and has value semantics. 
class ExpectationSet { 
 public: 
  // A bidirectional iterator that can read a const element in the set. 
  typedef Expectation::Set::const_iterator const_iterator; 
 
  // An object stored in the set.  This is an alias of Expectation. 
  typedef Expectation::Set::value_type value_type; 
 
  // Constructs an empty set. 
  ExpectationSet() {} 
 
  // This single-argument ctor must not be explicit, in order to support the 
  //   ExpectationSet es = EXPECT_CALL(...); 
  // syntax. 
  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT 
    *this += Expectation(exp); 
  } 
 
  // This single-argument ctor implements implicit conversion from 
  // Expectation and thus must not be explicit.  This allows either an 
  // Expectation or an ExpectationSet to be used in .After(). 
  ExpectationSet(const Expectation& e) {  // NOLINT 
    *this += e; 
  } 
 
  // The compiler-generator ctor and operator= works exactly as 
  // intended, so we don't need to define our own. 
 
  // Returns true if and only if rhs contains the same set of Expectation
  // objects as this does.
  bool operator==(const ExpectationSet& rhs) const { 
    return expectations_ == rhs.expectations_; 
  } 
 
  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); } 
 
  // Implements the syntax 
  //   expectation_set += EXPECT_CALL(...); 
  ExpectationSet& operator+=(const Expectation& e) { 
    expectations_.insert(e); 
    return *this; 
  } 
 
  int size() const { return static_cast<int>(expectations_.size()); } 
 
  const_iterator begin() const { return expectations_.begin(); } 
  const_iterator end() const { return expectations_.end(); } 
 
 private: 
  Expectation::Set expectations_; 
}; 
 
 
// Sequence objects are used by a user to specify the relative order 
// in which the expectations should match.  They are copyable (we rely 
// on the compiler-defined copy constructor and assignment operator). 
class GTEST_API_ Sequence { 
 public: 
  // Constructs an empty sequence. 
  Sequence() : last_expectation_(new Expectation) {} 
 
  // Adds an expectation to this sequence.  The caller must ensure 
  // that no other thread is accessing this Sequence object. 
  void AddExpectation(const Expectation& expectation) const; 
 
 private: 
  // The last expectation in this sequence.
  std::shared_ptr<Expectation> last_expectation_;
};  // class Sequence 
 
// An object of this type causes all EXPECT_CALL() statements 
// encountered in its scope to be put in an anonymous sequence.  The 
// work is done in the constructor and destructor.  You should only 
// create an InSequence object on the stack. 
// 
// The sole purpose for this class is to support easy definition of 
// sequential expectations, e.g. 
// 
//   { 
//     InSequence dummy;  // The name of the object doesn't matter. 
// 
//     // The following expectations must match in the order they appear. 
//     EXPECT_CALL(a, Bar())...; 
//     EXPECT_CALL(a, Baz())...; 
//     ... 
//     EXPECT_CALL(b, Xyz())...; 
//   } 
// 
// You can create InSequence objects in multiple threads, as long as 
// they are used to affect different mock objects.  The idea is that 
// each thread can create and set up its own mocks as if it's the only 
// thread.  However, for clarity of your tests we recommend you to set 
// up mocks in the main thread unless you have a good reason not to do 
// so. 
class GTEST_API_ InSequence { 
 public: 
  InSequence(); 
  ~InSequence(); 
 private: 
  bool sequence_created_; 
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT 
} GTEST_ATTRIBUTE_UNUSED_; 
 
namespace internal { 
 
// Points to the implicit sequence introduced by a living InSequence 
// object (if any) in the current thread or NULL. 
GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence; 
 
// Base class for implementing expectations. 
// 
// There are two reasons for having a type-agnostic base class for 
// Expectation: 
// 
//   1. We need to store collections of expectations of different 
//   types (e.g. all pre-requisites of a particular expectation, all 
//   expectations in a sequence).  Therefore these expectation objects 
//   must share a common base class. 
// 
//   2. We can avoid binary code bloat by moving methods not depending 
//   on the template argument of Expectation to the base class. 
// 
// This class is internal and mustn't be used by user code directly. 
class GTEST_API_ ExpectationBase { 
 public: 
  // source_text is the EXPECT_CALL(...) source that created this Expectation. 
  ExpectationBase(const char* file, int line, const std::string& source_text);
 
  virtual ~ExpectationBase(); 
 
  // Where in the source file was the expectation spec defined? 
  const char* file() const { return file_; } 
  int line() const { return line_; } 
  const char* source_text() const { return source_text_.c_str(); } 
  // Returns the cardinality specified in the expectation spec. 
  const Cardinality& cardinality() const { return cardinality_; } 
 
  // Describes the source file location of this expectation. 
  void DescribeLocationTo(::std::ostream* os) const { 
    *os << FormatFileLocation(file(), line()) << " "; 
  } 
 
  // Describes how many times a function call matching this 
  // expectation has occurred. 
  void DescribeCallCountTo(::std::ostream* os) const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); 
 
  // If this mock method has an extra matcher (i.e. .With(matcher)), 
  // describes it to the ostream. 
  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0; 
 
 protected: 
  friend class ::testing::Expectation; 
  friend class UntypedFunctionMockerBase; 
 
  enum Clause { 
    // Don't change the order of the enum members! 
    kNone, 
    kWith, 
    kTimes, 
    kInSequence, 
    kAfter, 
    kWillOnce, 
    kWillRepeatedly, 
    kRetiresOnSaturation 
  }; 
 
  typedef std::vector<const void*> UntypedActions; 
 
  // Returns an Expectation object that references and co-owns this 
  // expectation. 
  virtual Expectation GetHandle() = 0; 
 
  // Asserts that the EXPECT_CALL() statement has the given property. 
  void AssertSpecProperty(bool property,
                          const std::string& failure_message) const {
    Assert(property, file_, line_, failure_message); 
  } 
 
  // Expects that the EXPECT_CALL() statement has the given property. 
  void ExpectSpecProperty(bool property,
                          const std::string& failure_message) const {
    Expect(property, file_, line_, failure_message); 
  } 
 
  // Explicitly specifies the cardinality of this expectation.  Used 
  // by the subclasses to implement the .Times() clause. 
  void SpecifyCardinality(const Cardinality& cardinality); 
 
  // Returns true if and only if the user specified the cardinality
  // explicitly using a .Times().
  bool cardinality_specified() const { return cardinality_specified_; } 
 
  // Sets the cardinality of this expectation spec. 
  void set_cardinality(const Cardinality& a_cardinality) { 
    cardinality_ = a_cardinality; 
  } 
 
  // The following group of methods should only be called after the 
  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by 
  // the current thread. 
 
  // Retires all pre-requisites of this expectation. 
  void RetireAllPreRequisites() 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); 
 
  // Returns true if and only if this expectation is retired.
  bool is_retired() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return retired_; 
  } 
 
  // Retires this expectation. 
  void Retire() 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    retired_ = true; 
  } 
 
  // Returns true if and only if this expectation is satisfied.
  bool IsSatisfied() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return cardinality().IsSatisfiedByCallCount(call_count_); 
  } 
 
  // Returns true if and only if this expectation is saturated.
  bool IsSaturated() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return cardinality().IsSaturatedByCallCount(call_count_); 
  } 
 
  // Returns true if and only if this expectation is over-saturated.
  bool IsOverSaturated() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return cardinality().IsOverSaturatedByCallCount(call_count_); 
  } 
 
  // Returns true if and only if all pre-requisites of this expectation are
  // satisfied.
  bool AllPrerequisitesAreSatisfied() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); 
 
  // Adds unsatisfied pre-requisites of this expectation to 'result'. 
  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex); 
 
  // Returns the number this expectation has been invoked. 
  int call_count() const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return call_count_; 
  } 
 
  // Increments the number this expectation has been invoked. 
  void IncrementCallCount() 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    call_count_++; 
  } 
 
  // Checks the action count (i.e. the number of WillOnce() and 
  // WillRepeatedly() clauses) against the cardinality if this hasn't 
  // been done before.  Prints a warning if there are too many or too 
  // few actions. 
  void CheckActionCountIfNotDone() const 
      GTEST_LOCK_EXCLUDED_(mutex_); 
 
  friend class ::testing::Sequence; 
  friend class ::testing::internal::ExpectationTester; 
 
  template <typename Function> 
  friend class TypedExpectation; 
 
  // Implements the .Times() clause. 
  void UntypedTimes(const Cardinality& a_cardinality); 
 
  // This group of fields are part of the spec and won't change after 
  // an EXPECT_CALL() statement finishes. 
  const char* file_;          // The file that contains the expectation. 
  int line_;                  // The line number of the expectation. 
  const std::string source_text_;  // The EXPECT_CALL(...) source text.
  // True if and only if the cardinality is specified explicitly.
  bool cardinality_specified_; 
  Cardinality cardinality_;            // The cardinality of the expectation. 
  // The immediate pre-requisites (i.e. expectations that must be 
  // satisfied before this expectation can be matched) of this 
  // expectation.  We use std::shared_ptr in the set because we want an
  // Expectation object to be co-owned by its FunctionMocker and its 
  // successors.  This allows multiple mock objects to be deleted at 
  // different times. 
  ExpectationSet immediate_prerequisites_; 
 
  // This group of fields are the current state of the expectation, 
  // and can change as the mock function is called. 
  int call_count_;  // How many times this expectation has been invoked. 
  bool retired_;    // True if and only if this expectation has retired.
  UntypedActions untyped_actions_; 
  bool extra_matcher_specified_; 
  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified. 
  bool retires_on_saturation_; 
  Clause last_clause_; 
  mutable bool action_count_checked_;  // Under mutex_. 
  mutable Mutex mutex_;  // Protects action_count_checked_. 
};  // class ExpectationBase 
 
// Impements an expectation for the given function type. 
template <typename F> 
class TypedExpectation : public ExpectationBase { 
 public: 
  typedef typename Function<F>::ArgumentTuple ArgumentTuple; 
  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple; 
  typedef typename Function<F>::Result Result; 
 
  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
                   const std::string& a_source_text,
                   const ArgumentMatcherTuple& m) 
      : ExpectationBase(a_file, a_line, a_source_text), 
        owner_(owner), 
        matchers_(m), 
        // By default, extra_matcher_ should match anything.  However, 
        // we cannot initialize it with _ as that causes ambiguity between
        // Matcher's copy and move constructor for some argument types.
        extra_matcher_(A<const ArgumentTuple&>()), 
        repeated_action_(DoDefault()) {} 
 
  ~TypedExpectation() override {
    // Check the validity of the action count if it hasn't been done 
    // yet (for example, if the expectation was never used). 
    CheckActionCountIfNotDone(); 
    for (UntypedActions::const_iterator it = untyped_actions_.begin(); 
         it != untyped_actions_.end(); ++it) { 
      delete static_cast<const Action<F>*>(*it); 
    } 
  } 
 
  // Implements the .With() clause. 
  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) { 
    if (last_clause_ == kWith) { 
      ExpectSpecProperty(false, 
                         ".With() cannot appear " 
                         "more than once in an EXPECT_CALL()."); 
    } else { 
      ExpectSpecProperty(last_clause_ < kWith, 
                         ".With() must be the first " 
                         "clause in an EXPECT_CALL()."); 
    } 
    last_clause_ = kWith; 
 
    extra_matcher_ = m; 
    extra_matcher_specified_ = true; 
    return *this; 
  } 
 
  // Implements the .Times() clause. 
  TypedExpectation& Times(const Cardinality& a_cardinality) { 
    ExpectationBase::UntypedTimes(a_cardinality); 
    return *this; 
  } 
 
  // Implements the .Times() clause. 
  TypedExpectation& Times(int n) { 
    return Times(Exactly(n)); 
  } 
 
  // Implements the .InSequence() clause. 
  TypedExpectation& InSequence(const Sequence& s) { 
    ExpectSpecProperty(last_clause_ <= kInSequence, 
                       ".InSequence() cannot appear after .After()," 
                       " .WillOnce(), .WillRepeatedly(), or " 
                       ".RetiresOnSaturation()."); 
    last_clause_ = kInSequence; 
 
    s.AddExpectation(GetHandle()); 
    return *this; 
  } 
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) { 
    return InSequence(s1).InSequence(s2); 
  } 
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, 
                               const Sequence& s3) { 
    return InSequence(s1, s2).InSequence(s3); 
  } 
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, 
                               const Sequence& s3, const Sequence& s4) { 
    return InSequence(s1, s2, s3).InSequence(s4); 
  } 
  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, 
                               const Sequence& s3, const Sequence& s4, 
                               const Sequence& s5) { 
    return InSequence(s1, s2, s3, s4).InSequence(s5); 
  } 
 
  // Implements that .After() clause. 
  TypedExpectation& After(const ExpectationSet& s) { 
    ExpectSpecProperty(last_clause_ <= kAfter, 
                       ".After() cannot appear after .WillOnce()," 
                       " .WillRepeatedly(), or " 
                       ".RetiresOnSaturation()."); 
    last_clause_ = kAfter; 
 
    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) { 
      immediate_prerequisites_ += *it; 
    } 
    return *this; 
  } 
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) { 
    return After(s1).After(s2); 
  } 
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, 
                          const ExpectationSet& s3) { 
    return After(s1, s2).After(s3); 
  } 
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, 
                          const ExpectationSet& s3, const ExpectationSet& s4) { 
    return After(s1, s2, s3).After(s4); 
  } 
  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, 
                          const ExpectationSet& s3, const ExpectationSet& s4, 
                          const ExpectationSet& s5) { 
    return After(s1, s2, s3, s4).After(s5); 
  } 
 
  // Implements the .WillOnce() clause. 
  TypedExpectation& WillOnce(const Action<F>& action) { 
    ExpectSpecProperty(last_clause_ <= kWillOnce, 
                       ".WillOnce() cannot appear after " 
                       ".WillRepeatedly() or .RetiresOnSaturation()."); 
    last_clause_ = kWillOnce; 
 
    untyped_actions_.push_back(new Action<F>(action)); 
    if (!cardinality_specified()) { 
      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size()))); 
    } 
    return *this; 
  } 
 
  // Implements the .WillRepeatedly() clause. 
  TypedExpectation& WillRepeatedly(const Action<F>& action) { 
    if (last_clause_ == kWillRepeatedly) { 
      ExpectSpecProperty(false, 
                         ".WillRepeatedly() cannot appear " 
                         "more than once in an EXPECT_CALL()."); 
    } else { 
      ExpectSpecProperty(last_clause_ < kWillRepeatedly, 
                         ".WillRepeatedly() cannot appear " 
                         "after .RetiresOnSaturation()."); 
    } 
    last_clause_ = kWillRepeatedly; 
    repeated_action_specified_ = true; 
 
    repeated_action_ = action; 
    if (!cardinality_specified()) { 
      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size()))); 
    } 
 
    // Now that no more action clauses can be specified, we check 
    // whether their count makes sense. 
    CheckActionCountIfNotDone(); 
    return *this; 
  } 
 
  // Implements the .RetiresOnSaturation() clause. 
  TypedExpectation& RetiresOnSaturation() { 
    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation, 
                       ".RetiresOnSaturation() cannot appear " 
                       "more than once."); 
    last_clause_ = kRetiresOnSaturation; 
    retires_on_saturation_ = true; 
 
    // Now that no more action clauses can be specified, we check 
    // whether their count makes sense. 
    CheckActionCountIfNotDone(); 
    return *this; 
  } 
 
  // Returns the matchers for the arguments as specified inside the 
  // EXPECT_CALL() macro. 
  const ArgumentMatcherTuple& matchers() const { 
    return matchers_; 
  } 
 
  // Returns the matcher specified by the .With() clause. 
  const Matcher<const ArgumentTuple&>& extra_matcher() const { 
    return extra_matcher_; 
  } 
 
  // Returns the action specified by the .WillRepeatedly() clause. 
  const Action<F>& repeated_action() const { return repeated_action_; } 
 
  // If this mock method has an extra matcher (i.e. .With(matcher)), 
  // describes it to the ostream. 
  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
    if (extra_matcher_specified_) { 
      *os << "    Expected args: "; 
      extra_matcher_.DescribeTo(os); 
      *os << "\n"; 
    } 
  } 
 
 private: 
  template <typename Function> 
  friend class FunctionMocker;
 
  // Returns an Expectation object that references and co-owns this 
  // expectation. 
  Expectation GetHandle() override { return owner_->GetHandleOf(this); }
 
  // The following methods will be called only after the EXPECT_CALL() 
  // statement finishes and when the current thread holds 
  // g_gmock_mutex. 
 
  // Returns true if and only if this expectation matches the given arguments.
  bool Matches(const ArgumentTuple& args) const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args); 
  } 
 
  // Returns true if and only if this expectation should handle the given
  // arguments.
  bool ShouldHandleArguments(const ArgumentTuple& args) const 
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
 
    // In case the action count wasn't checked when the expectation 
    // was defined (e.g. if this expectation has no WillRepeatedly() 
    // or RetiresOnSaturation() clause), we check it when the 
    // expectation is used for the first time. 
    CheckActionCountIfNotDone(); 
    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args); 
  } 
 
  // Describes the result of matching the arguments against this 
  // expectation to the given ostream. 
  void ExplainMatchResultTo( 
      const ArgumentTuple& args, 
      ::std::ostream* os) const 
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
 
    if (is_retired()) { 
      *os << "         Expected: the expectation is active\n" 
          << "           Actual: it is retired\n"; 
    } else if (!Matches(args)) { 
      if (!TupleMatches(matchers_, args)) { 
        ExplainMatchFailureTupleTo(matchers_, args, os); 
      } 
      StringMatchResultListener listener; 
      if (!extra_matcher_.MatchAndExplain(args, &listener)) { 
        *os << "    Expected args: "; 
        extra_matcher_.DescribeTo(os); 
        *os << "\n           Actual: don't match"; 
 
        internal::PrintIfNotEmpty(listener.str(), os); 
        *os << "\n"; 
      } 
    } else if (!AllPrerequisitesAreSatisfied()) { 
      *os << "         Expected: all pre-requisites are satisfied\n" 
          << "           Actual: the following immediate pre-requisites " 
          << "are not satisfied:\n"; 
      ExpectationSet unsatisfied_prereqs; 
      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs); 
      int i = 0; 
      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin(); 
           it != unsatisfied_prereqs.end(); ++it) { 
        it->expectation_base()->DescribeLocationTo(os); 
        *os << "pre-requisite #" << i++ << "\n"; 
      } 
      *os << "                   (end of pre-requisites)\n"; 
    } else { 
      // This line is here just for completeness' sake.  It will never 
      // be executed as currently the ExplainMatchResultTo() function 
      // is called only when the mock function call does NOT match the 
      // expectation. 
      *os << "The call matches the expectation.\n"; 
    } 
  } 
 
  // Returns the action that should be taken for the current invocation. 
  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
                                    const ArgumentTuple& args) const
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld(); 
    const int count = call_count(); 
    Assert(count >= 1, __FILE__, __LINE__, 
           "call_count() is <= 0 when GetCurrentAction() is " 
           "called - this should never happen."); 
 
    const int action_count = static_cast<int>(untyped_actions_.size()); 
    if (action_count > 0 && !repeated_action_specified_ && 
        count > action_count) { 
      // If there is at least one WillOnce() and no WillRepeatedly(), 
      // we warn the user when the WillOnce() clauses ran out. 
      ::std::stringstream ss; 
      DescribeLocationTo(&ss); 
      ss << "Actions ran out in " << source_text() << "...\n" 
         << "Called " << count << " times, but only " 
         << action_count << " WillOnce()" 
         << (action_count == 1 ? " is" : "s are") << " specified - "; 
      mocker->DescribeDefaultActionTo(args, &ss); 
      Log(kWarning, ss.str(), 1); 
    } 
 
    return count <= action_count
               ? *static_cast<const Action<F>*>(
                     untyped_actions_[static_cast<size_t>(count - 1)])
               : repeated_action();
  } 
 
  // Given the arguments of a mock function call, if the call will 
  // over-saturate this expectation, returns the default action; 
  // otherwise, returns the next action in this expectation.  Also 
  // describes *what* happened to 'what', and explains *why* Google 
  // Mock does it to 'why'.  This method is not const as it calls 
  // IncrementCallCount().  A return value of NULL means the default 
  // action. 
  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
                                         const ArgumentTuple& args,
                                         ::std::ostream* what,
                                         ::std::ostream* why)
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
    g_gmock_mutex.AssertHeld(); 
    if (IsSaturated()) { 
      // We have an excessive call. 
      IncrementCallCount(); 
      *what << "Mock function called more times than expected - "; 
      mocker->DescribeDefaultActionTo(args, what); 
      DescribeCallCountTo(why); 
 
      return nullptr;
    } 
 
    IncrementCallCount(); 
    RetireAllPreRequisites(); 
 
    if (retires_on_saturation_ && IsSaturated()) { 
      Retire(); 
    } 
 
    // Must be done after IncrementCount()! 
    *what << "Mock function call matches " << source_text() <<"...\n"; 
    return &(GetCurrentAction(mocker, args)); 
  } 
 
  // All the fields below won't change once the EXPECT_CALL() 
  // statement finishes. 
  FunctionMocker<F>* const owner_;
  ArgumentMatcherTuple matchers_; 
  Matcher<const ArgumentTuple&> extra_matcher_; 
  Action<F> repeated_action_; 
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation); 
};  // class TypedExpectation 
 
// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for 
// specifying the default behavior of, or expectation on, a mock 
// function. 
 
// Note: class MockSpec really belongs to the ::testing namespace. 
// However if we define it in ::testing, MSVC will complain when 
// classes in ::testing::internal declare it as a friend class 
// template.  To workaround this compiler bug, we define MockSpec in 
// ::testing::internal and import it into ::testing. 
 
// Logs a message including file and line number information. 
GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, 
                                const char* file, int line, 
                                const std::string& message);
 
template <typename F> 
class MockSpec { 
 public: 
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 
  typedef typename internal::Function<F>::ArgumentMatcherTuple 
      ArgumentMatcherTuple; 
 
  // Constructs a MockSpec object, given the function mocker object 
  // that the spec is associated with. 
  MockSpec(internal::FunctionMocker<F>* function_mocker,
           const ArgumentMatcherTuple& matchers)
      : function_mocker_(function_mocker), matchers_(matchers) {}
 
  // Adds a new default action spec to the function mocker and returns 
  // the newly created spec. 
  internal::OnCallSpec<F>& InternalDefaultActionSetAt( 
      const char* file, int line, const char* obj, const char* call) { 
    LogWithLocation(internal::kInfo, file, line, 
                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
    return function_mocker_->AddNewOnCallSpec(file, line, matchers_); 
  } 
 
  // Adds a new expectation spec to the function mocker and returns 
  // the newly created spec. 
  internal::TypedExpectation<F>& InternalExpectedAt( 
      const char* file, int line, const char* obj, const char* call) { 
    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
                                  call + ")");
    LogWithLocation(internal::kInfo, file, line, source_text + " invoked"); 
    return function_mocker_->AddNewExpectation( 
        file, line, source_text, matchers_); 
  } 
 
  // This operator overload is used to swallow the superfluous parameter list
  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
  // explanation.
  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
    return *this;
  }

 private: 
  template <typename Function> 
  friend class internal::FunctionMocker; 
 
  // The function mocker that owns this spec. 
  internal::FunctionMocker<F>* const function_mocker_;
  // The argument matchers specified in the spec. 
  ArgumentMatcherTuple matchers_; 
};  // class MockSpec 
 
// Wrapper type for generically holding an ordinary value or lvalue reference. 
// If T is not a reference type, it must be copyable or movable. 
// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless 
// T is a move-only value type (which means that it will always be copyable 
// if the current platform does not support move semantics). 
// 
// The primary template defines handling for values, but function header 
// comments describe the contract for the whole template (including 
// specializations). 
template <typename T> 
class ReferenceOrValueWrapper { 
 public: 
  // Constructs a wrapper from the given value/reference. 
  explicit ReferenceOrValueWrapper(T value) 
      : value_(std::move(value)) {
  } 
 
  // Unwraps and returns the underlying value/reference, exactly as 
  // originally passed. The behavior of calling this more than once on 
  // the same object is unspecified. 
  T Unwrap() { return std::move(value_); }
 
  // Provides nondestructive access to the underlying value/reference. 
  // Always returns a const reference (more precisely, 
  // const std::add_lvalue_reference<T>::type). The behavior of calling this
  // after calling Unwrap on the same object is unspecified.
  const T& Peek() const { 
    return value_; 
  } 
 
 private: 
  T value_; 
}; 
 
// Specialization for lvalue reference types. See primary template 
// for documentation. 
template <typename T> 
class ReferenceOrValueWrapper<T&> { 
 public: 
  // Workaround for debatable pass-by-reference lint warning (c-library-team 
  // policy precludes NOLINT in this context) 
  typedef T& reference; 
  explicit ReferenceOrValueWrapper(reference ref) 
      : value_ptr_(&ref) {} 
  T& Unwrap() { return *value_ptr_; } 
  const T& Peek() const { return *value_ptr_; } 
 
 private: 
  T* value_ptr_; 
}; 
 
// C++ treats the void type specially.  For example, you cannot define 
// a void-typed variable or pass a void value to a function. 
// ActionResultHolder<T> holds a value of type T, where T must be a 
// copyable type or void (T doesn't need to be default-constructable). 
// It hides the syntactic difference between void and other types, and 
// is used to unify the code for invoking both void-returning and 
// non-void-returning mock functions. 
 
// Untyped base class for ActionResultHolder<T>. 
class UntypedActionResultHolderBase { 
 public: 
  virtual ~UntypedActionResultHolderBase() {} 
 
  // Prints the held value as an action's result to os. 
  virtual void PrintAsActionResult(::std::ostream* os) const = 0; 
}; 
 
// This generic definition is used when T is not void. 
template <typename T> 
class ActionResultHolder : public UntypedActionResultHolderBase { 
 public: 
  // Returns the held value. Must not be called more than once. 
  T Unwrap() { 
    return result_.Unwrap(); 
  } 
 
  // Prints the held value as an action's result to os. 
  void PrintAsActionResult(::std::ostream* os) const override {
    *os << "\n          Returns: "; 
    // T may be a reference type, so we don't use UniversalPrint(). 
    UniversalPrinter<T>::Print(result_.Peek(), os); 
  } 
 
  // Performs the given mock function's default action and returns the 
  // result in a new-ed ActionResultHolder. 
  template <typename F> 
  static ActionResultHolder* PerformDefaultAction( 
      const FunctionMocker<F>* func_mocker,
      typename Function<F>::ArgumentTuple&& args,
      const std::string& call_description) {
    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
        std::move(args), call_description)));
  } 
 
  // Performs the given action and returns the result in a new-ed 
  // ActionResultHolder. 
  template <typename F> 
  static ActionResultHolder* PerformAction(
      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
    return new ActionResultHolder(
        Wrapper(action.Perform(std::move(args))));
  } 
 
 private: 
  typedef ReferenceOrValueWrapper<T> Wrapper; 
 
  explicit ActionResultHolder(Wrapper result) 
      : result_(std::move(result)) {
  } 
 
  Wrapper result_; 
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder); 
}; 
 
// Specialization for T = void. 
template <> 
class ActionResultHolder<void> : public UntypedActionResultHolderBase { 
 public: 
  void Unwrap() { } 
 
  void PrintAsActionResult(::std::ostream* /* os */) const override {}
 
  // Performs the given mock function's default action and returns ownership 
  // of an empty ActionResultHolder*. 
  template <typename F> 
  static ActionResultHolder* PerformDefaultAction( 
      const FunctionMocker<F>* func_mocker,
      typename Function<F>::ArgumentTuple&& args,
      const std::string& call_description) {
    func_mocker->PerformDefaultAction(std::move(args), call_description);
    return new ActionResultHolder; 
  } 
 
  // Performs the given action and returns ownership of an empty 
  // ActionResultHolder*. 
  template <typename F> 
  static ActionResultHolder* PerformAction( 
      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
    action.Perform(std::move(args));
    return new ActionResultHolder; 
  } 
 
 private: 
  ActionResultHolder() {} 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder); 
}; 
 
template <typename F> 
class FunctionMocker;

template <typename R, typename... Args>
class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
  using F = R(Args...);

 public: 
  using Result = R;
  using ArgumentTuple = std::tuple<Args...>;
  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
 
  FunctionMocker() {}
 
  // There is no generally useful and implementable semantics of
  // copying a mock object, so copying a mock is usually a user error.
  // Thus we disallow copying function mockers.  If the user really
  // wants to copy a mock object, they should implement their own copy
  // operation, for example:
  //
  //   class MockFoo : public Foo {
  //    public:
  //     // Defines a copy constructor explicitly.
  //     MockFoo(const MockFoo& src) {}
  //     ...
  //   };
  FunctionMocker(const FunctionMocker&) = delete;
  FunctionMocker& operator=(const FunctionMocker&) = delete;

  // The destructor verifies that all expectations on this mock 
  // function have been satisfied.  If not, it will report Google Test 
  // non-fatal failures for the violations. 
  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    MutexLock l(&g_gmock_mutex); 
    VerifyAndClearExpectationsLocked(); 
    Mock::UnregisterLocked(this); 
    ClearDefaultActionsLocked(); 
  } 
 
  // Returns the ON_CALL spec that matches this mock function with the 
  // given arguments; returns NULL if no matching ON_CALL is found. 
  // L = * 
  const OnCallSpec<F>* FindOnCallSpec( 
      const ArgumentTuple& args) const { 
    for (UntypedOnCallSpecs::const_reverse_iterator it 
             = untyped_on_call_specs_.rbegin(); 
         it != untyped_on_call_specs_.rend(); ++it) { 
      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it); 
      if (spec->Matches(args)) 
        return spec; 
    } 
 
    return nullptr;
  } 
 
  // Performs the default action of this mock function on the given 
  // arguments and returns the result. Asserts (or throws if 
  // exceptions are enabled) with a helpful call descrption if there 
  // is no valid return value. This method doesn't depend on the 
  // mutable state of this object, and thus can be called concurrently 
  // without locking. 
  // L = * 
  Result PerformDefaultAction(ArgumentTuple&& args,
                              const std::string& call_description) const {
    const OnCallSpec<F>* const spec = 
        this->FindOnCallSpec(args); 
    if (spec != nullptr) {
      return spec->GetAction().Perform(std::move(args));
    } 
    const std::string message =
        call_description +
        "\n    The mock function has no default action " 
        "set, and its return type has no default value set."; 
#if GTEST_HAS_EXCEPTIONS 
    if (!DefaultValue<Result>::Exists()) { 
      throw std::runtime_error(message); 
    } 
#else 
    Assert(DefaultValue<Result>::Exists(), "", -1, message); 
#endif 
    return DefaultValue<Result>::Get(); 
  } 
 
  // Performs the default action with the given arguments and returns 
  // the action's result.  The call description string will be used in 
  // the error message to describe the call in the case the default 
  // action fails.  The caller is responsible for deleting the result. 
  // L = * 
  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
      void* untyped_args,  // must point to an ArgumentTuple
      const std::string& call_description) const override {
    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
    return ResultHolder::PerformDefaultAction(this, std::move(*args),
                                              call_description);
  } 
 
  // Performs the given action with the given arguments and returns 
  // the action's result.  The caller is responsible for deleting the 
  // result. 
  // L = * 
  UntypedActionResultHolderBase* UntypedPerformAction(
      const void* untyped_action, void* untyped_args) const override {
    // Make a copy of the action before performing it, in case the 
    // action deletes the mock object (and thus deletes itself). 
    const Action<F> action = *static_cast<const Action<F>*>(untyped_action); 
    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
    return ResultHolder::PerformAction(action, std::move(*args));
  } 
 
  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked(): 
  // clears the ON_CALL()s set on this mock function. 
  void ClearDefaultActionsLocked() override
      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
 
    // Deleting our default actions may trigger other mock objects to be 
    // deleted, for example if an action contains a reference counted smart 
    // pointer to that mock object, and that is the last reference. So if we 
    // delete our actions within the context of the global mutex we may deadlock 
    // when this method is called again. Instead, make a copy of the set of 
    // actions to delete, clear our set within the mutex, and then delete the 
    // actions outside of the mutex. 
    UntypedOnCallSpecs specs_to_delete; 
    untyped_on_call_specs_.swap(specs_to_delete); 
 
    g_gmock_mutex.Unlock(); 
    for (UntypedOnCallSpecs::const_iterator it = 
             specs_to_delete.begin(); 
         it != specs_to_delete.end(); ++it) { 
      delete static_cast<const OnCallSpec<F>*>(*it); 
    } 
 
    // Lock the mutex again, since the caller expects it to be locked when we 
    // return. 
    g_gmock_mutex.Lock(); 
  } 
 
  // Returns the result of invoking this mock function with the given
  // arguments.  This function can be safely called from multiple
  // threads concurrently.
  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    ArgumentTuple tuple(std::forward<Args>(args)...);
    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
    return holder->Unwrap();
  }

  MockSpec<F> With(Matcher<Args>... m) {
    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
  }

 protected: 
  template <typename Function> 
  friend class MockSpec; 
 
  typedef ActionResultHolder<Result> ResultHolder; 
 
  // Adds and returns a default action spec for this mock function. 
  OnCallSpec<F>& AddNewOnCallSpec( 
      const char* file, int line, 
      const ArgumentMatcherTuple& m) 
          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); 
    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m); 
    untyped_on_call_specs_.push_back(on_call_spec); 
    return *on_call_spec; 
  } 
 
  // Adds and returns an expectation spec for this mock function. 
  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
                                         const std::string& source_text,
                                         const ArgumentMatcherTuple& m)
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line); 
    TypedExpectation<F>* const expectation = 
        new TypedExpectation<F>(this, file, line, source_text, m); 
    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
    // See the definition of untyped_expectations_ for why access to
    // it is unprotected here.
    untyped_expectations_.push_back(untyped_expectation); 
 
    // Adds this expectation into the implicit sequence if there is one. 
    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get(); 
    if (implicit_sequence != nullptr) {
      implicit_sequence->AddExpectation(Expectation(untyped_expectation)); 
    } 
 
    return *expectation; 
  } 
 
 private: 
  template <typename Func> friend class TypedExpectation; 
 
  // Some utilities needed for implementing UntypedInvokeWith(). 
 
  // Describes what default action will be performed for the given 
  // arguments. 
  // L = * 
  void DescribeDefaultActionTo(const ArgumentTuple& args, 
                               ::std::ostream* os) const { 
    const OnCallSpec<F>* const spec = FindOnCallSpec(args); 
 
    if (spec == nullptr) {
      *os << (std::is_void<Result>::value ? "returning directly.\n"
                                          : "returning default value.\n");
    } else { 
      *os << "taking default action specified at:\n" 
          << FormatFileLocation(spec->file(), spec->line()) << "\n"; 
    } 
  } 
 
  // Writes a message that the call is uninteresting (i.e. neither 
  // explicitly expected nor explicitly unexpected) to the given 
  // ostream. 
  void UntypedDescribeUninterestingCall(const void* untyped_args,
                                        ::std::ostream* os) const override
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    const ArgumentTuple& args = 
        *static_cast<const ArgumentTuple*>(untyped_args); 
    *os << "Uninteresting mock function call - "; 
    DescribeDefaultActionTo(args, os); 
    *os << "    Function call: " << Name(); 
    UniversalPrint(args, os); 
  } 
 
  // Returns the expectation that matches the given function arguments 
  // (or NULL is there's no match); when a match is found, 
  // untyped_action is set to point to the action that should be 
  // performed (or NULL if the action is "do default"), and 
  // is_excessive is modified to indicate whether the call exceeds the 
  // expected number. 
  // 
  // Critical section: We must find the matching expectation and the 
  // corresponding action that needs to be taken in an ATOMIC 
  // transaction.  Otherwise another thread may call this mock 
  // method in the middle and mess up the state. 
  // 
  // However, performing the action has to be left out of the critical 
  // section.  The reason is that we have no control on what the 
  // action does (it can invoke an arbitrary user function or even a 
  // mock function) and excessive locking could cause a dead lock. 
  const ExpectationBase* UntypedFindMatchingExpectation(
      const void* untyped_args, const void** untyped_action, bool* is_excessive,
      ::std::ostream* what, ::std::ostream* why) override
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    const ArgumentTuple& args = 
        *static_cast<const ArgumentTuple*>(untyped_args); 
    MutexLock l(&g_gmock_mutex); 
    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args); 
    if (exp == nullptr) {  // A match wasn't found.
      this->FormatUnexpectedCallMessageLocked(args, what, why); 
      return nullptr;
    } 
 
    // This line must be done before calling GetActionForArguments(), 
    // which will increment the call count for *exp and thus affect 
    // its saturation status. 
    *is_excessive = exp->IsSaturated(); 
    const Action<F>* action = exp->GetActionForArguments(this, args, what, why); 
    if (action != nullptr && action->IsDoDefault())
      action = nullptr;  // Normalize "do default" to NULL.
    *untyped_action = action; 
    return exp; 
  } 
 
  // Prints the given function arguments to the ostream. 
  void UntypedPrintArgs(const void* untyped_args,
                        ::std::ostream* os) const override {
    const ArgumentTuple& args = 
        *static_cast<const ArgumentTuple*>(untyped_args); 
    UniversalPrint(args, os); 
  } 
 
  // Returns the expectation that matches the arguments, or NULL if no 
  // expectation matches them. 
  TypedExpectation<F>* FindMatchingExpectationLocked( 
      const ArgumentTuple& args) const 
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    // See the definition of untyped_expectations_ for why access to
    // it is unprotected here.
    for (typename UntypedExpectations::const_reverse_iterator it = 
             untyped_expectations_.rbegin(); 
         it != untyped_expectations_.rend(); ++it) { 
      TypedExpectation<F>* const exp = 
          static_cast<TypedExpectation<F>*>(it->get()); 
      if (exp->ShouldHandleArguments(args)) { 
        return exp; 
      } 
    } 
    return nullptr;
  } 
 
  // Returns a message that the arguments don't match any expectation. 
  void FormatUnexpectedCallMessageLocked( 
      const ArgumentTuple& args, 
      ::std::ostream* os, 
      ::std::ostream* why) const 
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    *os << "\nUnexpected mock function call - "; 
    DescribeDefaultActionTo(args, os); 
    PrintTriedExpectationsLocked(args, why); 
  } 
 
  // Prints a list of expectations that have been tried against the 
  // current mock function call. 
  void PrintTriedExpectationsLocked( 
      const ArgumentTuple& args, 
      ::std::ostream* why) const 
          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
    g_gmock_mutex.AssertHeld(); 
    const size_t count = untyped_expectations_.size();
    *why << "Google Mock tried the following " << count << " " 
         << (count == 1 ? "expectation, but it didn't match" : 
             "expectations, but none matched") 
         << ":\n"; 
    for (size_t i = 0; i < count; i++) {
      TypedExpectation<F>* const expectation = 
          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get()); 
      *why << "\n"; 
      expectation->DescribeLocationTo(why); 
      if (count > 1) { 
        *why << "tried expectation #" << i << ": "; 
      } 
      *why << expectation->source_text() << "...\n"; 
      expectation->ExplainMatchResultTo(args, why); 
      expectation->DescribeCallCountTo(why); 
    } 
  } 
};  // class FunctionMocker
 
// Reports an uninteresting call (whose description is in msg) in the
// manner specified by 'reaction'.
void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
 
}  // namespace internal
 
namespace internal {

template <typename F>
class MockFunction;

template <typename R, typename... Args>
class MockFunction<R(Args...)> {
 public:
  MockFunction(const MockFunction&) = delete;
  MockFunction& operator=(const MockFunction&) = delete;

  std::function<R(Args...)> AsStdFunction() {
    return [this](Args... args) -> R {
      return this->Call(std::forward<Args>(args)...);
    };
  }

  // Implementation detail: the expansion of the MOCK_METHOD macro.
  R Call(Args... args) {
    mock_.SetOwnerAndName(this, "Call");
    return mock_.Invoke(std::forward<Args>(args)...);
  }

  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
    mock_.RegisterOwner(this);
    return mock_.With(std::move(m)...);
  }

  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
    return this->gmock_Call(::testing::A<Args>()...);
  }

 protected:
  MockFunction() = default;
  ~MockFunction() = default;

 private:
  FunctionMocker<R(Args...)> mock_;
};

/*
The SignatureOf<F> struct is a meta-function returning function signature
corresponding to the provided F argument.

It makes use of MockFunction easier by allowing it to accept more F arguments
than just function signatures.

Specializations provided here cover a signature type itself and any template
that can be parameterized with a signature, including std::function and
boost::function.
*/

template <typename F, typename = void>
struct SignatureOf;

template <typename R, typename... Args>
struct SignatureOf<R(Args...)> {
  using type = R(Args...);
};

template <template <typename> class C, typename F>
struct SignatureOf<C<F>,
                   typename std::enable_if<std::is_function<F>::value>::type>
    : SignatureOf<F> {};

template <typename F>
using SignatureOfT = typename SignatureOf<F>::type;

}  // namespace internal

// A MockFunction<F> type has one mock method whose type is
// internal::SignatureOfT<F>.  It is useful when you just want your
// test code to emit some messages and have Google Mock verify the
// right messages are sent (and perhaps at the right times).  For
// example, if you are exercising code:
//
//   Foo(1);
//   Foo(2);
//   Foo(3);
//
// and want to verify that Foo(1) and Foo(3) both invoke
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
//
// TEST(FooTest, InvokesBarCorrectly) {
//   MyMock mock;
//   MockFunction<void(string check_point_name)> check;
//   {
//     InSequence s;
//
//     EXPECT_CALL(mock, Bar("a"));
//     EXPECT_CALL(check, Call("1"));
//     EXPECT_CALL(check, Call("2"));
//     EXPECT_CALL(mock, Bar("a"));
//   }
//   Foo(1);
//   check.Call("1");
//   Foo(2);
//   check.Call("2");
//   Foo(3);
// }
//
// The expectation spec says that the first Bar("a") must happen
// before check point "1", the second Bar("a") must happen after check
// point "2", and nothing should happen between the two check
// points. The explicit check points make it easy to tell which
// Bar("a") is called by which call to Foo().
//
// MockFunction<F> can also be used to exercise code that accepts
// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
// AsStdFunction() method to create std::function proxy forwarding to
// original object's Call. Example:
//
// TEST(FooTest, RunsCallbackWithBarArgument) {
//   MockFunction<int(string)> callback;
//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
//   Foo(callback.AsStdFunction());
// }
//
// The internal::SignatureOfT<F> indirection allows to use other types
// than just function signature type. This is typically useful when
// providing a mock for a predefined std::function type. Example:
//
// using FilterPredicate = std::function<bool(string)>;
// void MyFilterAlgorithm(FilterPredicate predicate);
//
// TEST(FooTest, FilterPredicateAlwaysAccepts) {
//   MockFunction<FilterPredicate> predicateMock;
//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
//   MyFilterAlgorithm(predicateMock.AsStdFunction());
// }
template <typename F>
class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
 
 public:
  using Base::Base;
};

// The style guide prohibits "using" statements in a namespace scope 
// inside a header file.  However, the MockSpec class template is 
// meant to be defined in the ::testing namespace.  The following line 
// is just a trick for working around a bug in MSVC 8.0, which cannot 
// handle it if we define MockSpec in ::testing. 
using internal::MockSpec; 
 
// Const(x) is a convenient function for obtaining a const reference 
// to x.  This is useful for setting expectations on an overloaded 
// const mock method, e.g. 
// 
//   class MockFoo : public FooInterface { 
//    public: 
//     MOCK_METHOD0(Bar, int()); 
//     MOCK_CONST_METHOD0(Bar, int&()); 
//   }; 
// 
//   MockFoo foo; 
//   // Expects a call to non-const MockFoo::Bar(). 
//   EXPECT_CALL(foo, Bar()); 
//   // Expects a call to const MockFoo::Bar(). 
//   EXPECT_CALL(Const(foo), Bar()); 
template <typename T> 
inline const T& Const(const T& x) { return x; } 
 
// Constructs an Expectation object that references and co-owns exp. 
inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT 
    : expectation_base_(exp.GetHandle().expectation_base()) {} 
 
}  // namespace testing 
 
GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 
// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
// required to avoid compile errors when the name of the method used in call is
// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
// tests in internal/gmock-spec-builders_test.cc for more details.
//
// This macro supports statements both with and without parameter matchers. If
// the parameter list is omitted, gMock will accept any parameters, which allows
// tests to be written that don't need to encode the number of method
// parameter. This technique may only be used for non-overloaded methods.
//
//   // These are the same:
//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
//
//   // As are these:
//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
//
//   // Can also specify args if you want, of course:
//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
//
//   // Overloads work as long as you specify parameters:
//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
//
//   // Oops! Which overload did you want?
//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
//
// How this works: The mock class uses two overloads of the gmock_Method
// expectation setter method plus an operator() overload on the MockSpec object.
// In the matcher list form, the macro expands to:
//
//   // This statement:
//   ON_CALL(mock, TwoArgsMethod(_, 45))...
//
//   // ...expands to:
//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
//   |-------------v---------------||------------v-------------|
//       invokes first overload        swallowed by operator()
//
//   // ...which is essentially:
//   mock.gmock_TwoArgsMethod(_, 45)...
//
// Whereas the form without a matcher list:
//
//   // This statement:
//   ON_CALL(mock, TwoArgsMethod)...
//
//   // ...expands to:
//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
//   |-----------------------v--------------------------|
//                 invokes second overload
//
//   // ...which is essentially:
//   mock.gmock_TwoArgsMethod(_, _)...
//
// The WithoutMatchers() argument is used to disambiguate overloads and to
// block the caller from accidentally invoking the second overload directly. The
// second argument is an internal type derived from the method signature. The
// failure to disambiguate two overloads of this method in the ON_CALL statement
// is how we block callers from setting expectations on overloaded methods.
#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
                             nullptr)                                   \
      .Setter(__FILE__, __LINE__, #mock_expr, #call)
 
#define ON_CALL(obj, call) \
  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)

#define EXPECT_CALL(obj, call) \
  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_