googlemock/include/gmock/gmock-spec-builders.h - third_party/github/google/googletest - Git at Google

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

 // IWYU pragma: private, include "gmock/gmock.h"
 // IWYU pragma: friend gmock/.*

 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_

 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <ostream>
 #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);

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

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

  protected:
   typedef std::vector<const void*> UntypedOnCallSpecs;

   using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;

   struct UninterestingCallCleanupHandler;
   struct FailureCleanupHandler;

   // 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(uintptr_t 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(uintptr_t mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);

   // Tells Google Mock to fail uninteresting calls on the given mock
   // object.
   static void FailUninterestingCalls(uintptr_t 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(uintptr_t 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() = default;

   // 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_;

   InSequence(const InSequence&) = delete;
   InSequence& operator=(const InSequence&) = delete;
 };

 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;

   // Do not rely on this for correctness.
   // This is only for making human-readable test output easier to understand.
   void UntypedDescription(std::string description) {
     description_ = std::move(description);
   }

  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 a human-readable description of this expectation.
   // Do not rely on this for correctness. It is only for human readability.
   const std::string& GetDescription() const { return description_; }

   // 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.
   std::string description_;        // User-readable name for the expectation.
   // 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

 template <typename F>
 class TypedExpectation;

 // Implements an expectation for the given function type.
 template <typename R, typename... Args>
 class TypedExpectation<R(Args...)> : public ExpectationBase {
  private:
   using F = R(Args...);

  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;
   }

   // Do not rely on this for correctness.
   // This is only for making human-readable test output easier to understand.
   TypedExpectation& Description(std::string name) {
     ExpectationBase::UntypedDescription(std::move(name));
     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);
   }

   // Preferred, type-safe overload: consume anything that can be directly
   // converted to a OnceAction, except for Action<F> objects themselves.
   TypedExpectation& WillOnce(OnceAction<F> once_action) {
     // Call the overload below, smuggling the OnceAction as a copyable callable.
     // We know this is safe because a WillOnce action will not be called more
     // than once.
     return WillOnce(Action<F>(ActionAdaptor{
         std::make_shared<OnceAction<F>>(std::move(once_action)),
     }));
   }

   // Fallback overload: accept Action<F> objects and those actions that define
   // `operator Action<F>` but not `operator OnceAction<F>`.
   //
   // This is templated in order to cause the overload above to be preferred
   // when the input is convertible to either type.
   template <int&... ExplicitArgumentBarrier, typename = void>
   TypedExpectation& WillOnce(Action<F> action) {
     ExpectSpecProperty(last_clause_ <= kWillOnce,
                        ".WillOnce() cannot appear after "
                        ".WillRepeatedly() or .RetiresOnSaturation().");
     last_clause_ = kWillOnce;

     untyped_actions_.push_back(new Action<F>(std::move(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;

   // An adaptor that turns a OneAction<F> into something compatible with
   // Action<F>. Must be called at most once.
   struct ActionAdaptor {
     std::shared_ptr<OnceAction<R(Args...)>> once_action;

     R operator()(Args&&... args) const {
       return std::move(*once_action).Call(std::forward<Args>(args)...);
     }
   };

   // 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();
     const ::std::string& expectation_description = GetDescription();
     if (IsSaturated()) {
       // We have an excessive call.
       IncrementCallCount();
       *what << "Mock function ";
       if (!expectation_description.empty()) {
         *what << "\"" << expectation_description << "\" ";
       }
       *what << "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 ";
     if (!expectation_description.empty()) {
       *what << "\"" << expectation_description << "\" ";
     }
     *what << "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_;

   TypedExpectation(const TypedExpectation&) = delete;
   TypedExpectation& operator=(const TypedExpectation&) = delete;
 };  // 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_;
 };

 // Prints the held value as an action's result to os.
 template <typename T>
 void PrintAsActionResult(const T& result, std::ostream& os) {
   os << "\n          Returns: ";
   // T may be a reference type, so we don't use UniversalPrint().
   UniversalPrinter<T>::Print(result, &os);
 }

 // Reports an uninteresting call (whose description is in msg) in the
 // manner specified by 'reaction'.
 GTEST_API_ void ReportUninterestingCall(CallReaction reaction,
                                         const std::string& msg);

 // A generic RAII type that runs a user-provided function in its destructor.
 class Cleanup final {
  public:
   explicit Cleanup(std::function<void()> f) : f_(std::move(f)) {}
   ~Cleanup() { f_(); }

  private:
   std::function<void()> f_;
 };

 struct UntypedFunctionMockerBase::UninterestingCallCleanupHandler {
   CallReaction reaction;
   std::stringstream& ss;

   ~UninterestingCallCleanupHandler() {
     ReportUninterestingCall(reaction, ss.str());
   }
 };

 struct UntypedFunctionMockerBase::FailureCleanupHandler {
   std::stringstream& ss;
   std::stringstream& why;
   std::stringstream& loc;
   const ExpectationBase* untyped_expectation;
   bool found;
   bool is_excessive;

   ~FailureCleanupHandler() {
     ss << "\n" << why.str();

     if (!found) {
       // No expectation matches this call - reports a failure.
       Expect(false, nullptr, -1, ss.str());
     } else if (is_excessive) {
       // We had an upper-bound violation and the failure message is in ss.
       Expect(false, untyped_expectation->file(), untyped_expectation->line(),
              ss.str());
     } else {
       // We had an expected call and the matching expectation is
       // described in ss.
       Log(kInfo, loc.str() + ss.str(), 2);
     }
   }
 };

 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() = default;

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

   // 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) {
     return InvokeWith(ArgumentTuple(std::forward<Args>(args)...));
   }

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

  protected:
   template <typename Function>
   friend class MockSpec;

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

   // Performs the given action (or the default if it's null) with the given
   // arguments and returns the action's result.
   // L = *
   R PerformAction(const void* untyped_action, ArgumentTuple&& args,
                   const std::string& call_description) const {
     if (untyped_action == nullptr) {
       return PerformDefaultAction(std::move(args), call_description);
     }

     // 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);
     return action.Perform(std::move(args));
   }

   // Is it possible to store an object of the supplied type in a local variable
   // for the sake of printing it, then return it on to the caller?
   template <typename T>
   using can_print_result = internal::conjunction<
       // void can't be stored as an object (and we also don't need to print it).
       internal::negation<std::is_void<T>>,
       // Non-moveable types can't be returned on to the user, so there's no way
       // for us to intercept and print them.
       std::is_move_constructible<T>>;

   // Perform the supplied action, printing the result to os.
   template <typename T = R,
             typename std::enable_if<can_print_result<T>::value, int>::type = 0>
   R PerformActionAndPrintResult(const void* const untyped_action,
                                 ArgumentTuple&& args,
                                 const std::string& call_description,
                                 std::ostream& os) {
     R result = PerformAction(untyped_action, std::move(args), call_description);

     PrintAsActionResult(result, os);
     return std::forward<R>(result);
   }

   // An overload for when it's not possible to print the result. In this case we
   // simply perform the action.
   template <typename T = R,
             typename std::enable_if<
                 internal::negation<can_print_result<T>>::value, int>::type = 0>
   R PerformActionAndPrintResult(const void* const untyped_action,
                                 ArgumentTuple&& args,
                                 const std::string& call_description,
                                 std::ostream&) {
     return PerformAction(untyped_action, std::move(args), call_description);
   }

   // Returns the result of invoking this mock function with the given
   // arguments. This function can be safely called from multiple
   // threads concurrently.
   R InvokeWith(ArgumentTuple&& args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
 };  // class FunctionMocker

 // Calculates the result of invoking this mock function with the given
 // arguments, prints it, and returns it.
 template <typename R, typename... Args>
 R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
     GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
   // See the definition of untyped_expectations_ for why access to it
   // is unprotected here.
   if (untyped_expectations_.size() == 0) {
     // No expectation is set on this mock method - we have an
     // uninteresting call.

     // We must get Google Mock's reaction on uninteresting calls
     // made on this mock object BEFORE performing the action,
     // because the action may DELETE the mock object and make the
     // following expression meaningless.
     const CallReaction reaction =
         Mock::GetReactionOnUninterestingCalls(MockObject());

     // True if and only if we need to print this call's arguments and return
     // value.  This definition must be kept in sync with
     // the behavior of ReportUninterestingCall().
     const bool need_to_report_uninteresting_call =
         // If the user allows this uninteresting call, we print it
         // only when they want informational messages.
         reaction == kAllow ? LogIsVisible(kInfo) :
                            // If the user wants this to be a warning, we print
                            // it only when they want to see warnings.
             reaction == kWarn
             ? LogIsVisible(kWarning)
             :
             // Otherwise, the user wants this to be an error, and we
             // should always print detailed information in the error.
             true;

     if (!need_to_report_uninteresting_call) {
       // Perform the action without printing the call information.
       return this->PerformDefaultAction(
           std::move(args), "Function call: " + std::string(Name()));
     }

     // Warns about the uninteresting call.
     ::std::stringstream ss;
     this->UntypedDescribeUninterestingCall(&args, &ss);

     // Perform the action, print the result, and then report the uninteresting
     // call.
     //
     // We use RAII to do the latter in case R is void or a non-moveable type. In
     // either case we can't assign it to a local variable.
     //
     // Note that std::bind() is essential here.
     // We *don't* use any local callback types (like lambdas).
     // Doing so slows down compilation dramatically because the *constructor* of
     // std::function<T> is re-instantiated with different template
     // parameters each time.
     const UninterestingCallCleanupHandler report_uninteresting_call = {reaction,
                                                                        ss};

     return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
   }

   bool is_excessive = false;
   ::std::stringstream ss;
   ::std::stringstream why;
   ::std::stringstream loc;
   const void* untyped_action = nullptr;

   // The UntypedFindMatchingExpectation() function acquires and
   // releases g_gmock_mutex.

   const ExpectationBase* const untyped_expectation =
       this->UntypedFindMatchingExpectation(&args, &untyped_action,
                                            &is_excessive, &ss, &why);
   const bool found = untyped_expectation != nullptr;

   // True if and only if we need to print the call's arguments
   // and return value.
   // This definition must be kept in sync with the uses of Expect()
   // and Log() in this function.
   const bool need_to_report_call =
       !found || is_excessive || LogIsVisible(kInfo);
   if (!need_to_report_call) {
     // Perform the action without printing the call information.
     return PerformAction(untyped_action, std::move(args), "");
   }

   ss << "    Function call: " << Name();
   this->UntypedPrintArgs(&args, &ss);

   // In case the action deletes a piece of the expectation, we
   // generate the message beforehand.
   if (found && !is_excessive) {
     untyped_expectation->DescribeLocationTo(&loc);
   }

   // Perform the action, print the result, and then fail or log in whatever way
   // is appropriate.
   //
   // We use RAII to do the latter in case R is void or a non-moveable type. In
   // either case we can't assign it to a local variable.
   //
   // Note that we *don't* use any local callback types (like lambdas) here.
   // Doing so slows down compilation dramatically because the *constructor* of
   // std::function<T> is re-instantiated with different template
   // parameters each time.
   const FailureCleanupHandler handle_failures = {
       ss, why, loc, untyped_expectation, found, is_excessive};

   return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
                                      ss);
 }

 }  // 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_