// This file was GENERATED by command:

//     pump.py gmock-generated-function-mockers.h.pump

// DO NOT EDIT BY HAND!!!

// 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 function mockers of various arities.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

#include "gmock/gmock-spec-builders.h"

#include "gmock/internal/gmock-internal-utils.h"

#if GTEST_HAS_STD_FUNCTION_

# include <functional>

#endif

namespace testing {

namespace internal {

template <typename F>

class FunctionMockerBase;

// Note: class FunctionMocker 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

// FunctionMocker in ::testing::internal and import it into ::testing.

template <typename F>

class FunctionMocker;

template <typename R>

class FunctionMocker<R()> : public

    internal::FunctionMockerBase<R()> {

 public:

  typedef R F();

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With() {

    return MockSpec<F>(this, ::testing::make_tuple());

  }

  R Invoke() {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple());

  }

};

template <typename R, typename A1>

class FunctionMocker<R(A1)> : public

    internal::FunctionMockerBase<R(A1)> {

 public:

  typedef R F(A1);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1) {

    return MockSpec<F>(this, ::testing::make_tuple(m1));

  }

  R Invoke(A1 a1) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1)));

  }

};

template <typename R, typename A1, typename A2>

class FunctionMocker<R(A1, A2)> : public

    internal::FunctionMockerBase<R(A1, A2)> {

 public:

  typedef R F(A1, A2);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2));

  }

  R Invoke(A1 a1, A2 a2) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2)));

  }

};

template <typename R, typename A1, typename A2, typename A3>

class FunctionMocker<R(A1, A2, A3)> : public

    internal::FunctionMockerBase<R(A1, A2, A3)> {

 public:

  typedef R F(A1, A2, A3);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3));

  }

  R Invoke(A1 a1, A2 a2, A3 a3) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4>

class FunctionMocker<R(A1, A2, A3, A4)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {

 public:

  typedef R F(A1, A2, A3, A4);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5>

class FunctionMocker<R(A1, A2, A3, A4, A5)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {

 public:

  typedef R F(A1, A2, A3, A4, A5);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5, typename A6>

class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {

 public:

  typedef R F(A1, A2, A3, A4, A5, A6);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,

      const Matcher<A6>& m6) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5),

        internal::forward<A6>(a6)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5, typename A6, typename A7>

class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {

 public:

  typedef R F(A1, A2, A3, A4, A5, A6, A7);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,

      const Matcher<A6>& m6, const Matcher<A7>& m7) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5),

        internal::forward<A6>(a6), internal::forward<A7>(a7)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5, typename A6, typename A7, typename A8>

class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {

 public:

  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,

      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,

        m8));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5),

        internal::forward<A6>(a6), internal::forward<A7>(a7),

        internal::forward<A8>(a8)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5, typename A6, typename A7, typename A8, typename A9>

class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {

 public:

  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,

      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,

      const Matcher<A9>& m9) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,

        m8, m9));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5),

        internal::forward<A6>(a6), internal::forward<A7>(a7),

        internal::forward<A8>(a8), internal::forward<A9>(a9)));

  }

};

template <typename R, typename A1, typename A2, typename A3, typename A4,

    typename A5, typename A6, typename A7, typename A8, typename A9,

    typename A10>

class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public

    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {

 public:

  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);

  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,

      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,

      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,

      const Matcher<A9>& m9, const Matcher<A10>& m10) {

    return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,

        m8, m9, m10));

  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,

      A10 a10) {

    // Even though gcc and MSVC don't enforce it, 'this->' is required

    // by the C++ standard [14.6.4] here, as the base class type is

    // dependent on the template argument (and thus shouldn't be

    // looked into when resolving InvokeWith).

    return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),

        internal::forward<A2>(a2), internal::forward<A3>(a3),

        internal::forward<A4>(a4), internal::forward<A5>(a5),

        internal::forward<A6>(a6), internal::forward<A7>(a7),

        internal::forward<A8>(a8), internal::forward<A9>(a9),

        internal::forward<A10>(a10)));

  }

};

// Removes the given pointer; this is a helper for the expectation setter method

// for parameterless matchers.

//

// We want to make sure that the user cannot set a parameterless expectation on

// overloaded methods, including methods which are overloaded on const. Example:

//

//   class MockClass {

//     MOCK_METHOD0(GetName, string&());

//     MOCK_CONST_METHOD0(GetName, const string&());

//   };

//

//   TEST() {

//     // This should be an error, as it's not clear which overload is expected.

//     EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value));

//   }

//

// Here are the generated expectation-setter methods:

//

//   class MockClass {

//     // Overload 1

//     MockSpec<string&()> gmock_GetName() { ... }

//     // Overload 2. Declared const so that the compiler will generate an

//     // error when trying to resolve between this and overload 4 in

//     // 'gmock_GetName(WithoutMatchers(), nullptr)'.

//     MockSpec<string&()> gmock_GetName(

//         const WithoutMatchers&, const Function<string&()>*) const {

//       // Removes const from this, calls overload 1

//       return AdjustConstness_(this)->gmock_GetName();

//     }

//

//     // Overload 3

//     const string& gmock_GetName() const { ... }

//     // Overload 4

//     MockSpec<const string&()> gmock_GetName(

//         const WithoutMatchers&, const Function<const string&()>*) const {

//       // Does not remove const, calls overload 3

//       return AdjustConstness_const(this)->gmock_GetName();

//     }

//   }

//

template <typename MockType>

const MockType* AdjustConstness_const(const MockType* mock) {

  return mock;

}

// Removes const from and returns the given pointer; this is a helper for the

// expectation setter method for parameterless matchers.

template <typename MockType>

MockType* AdjustConstness_(const MockType* mock) {

  return const_cast<MockType*>(mock);

}

}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope

// inside a header file.  However, the FunctionMocker 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 FunctionMocker in ::testing.

using internal::FunctionMocker;

// GMOCK_RESULT_(tn, F) expands to the result type of function type F.

// We define this as a variadic macro in case F contains unprotected

// commas (the same reason that we use variadic macros in other places

// in this file).

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_RESULT_(tn, ...) \

    tn ::testing::internal::Function<__VA_ARGS__>::Result

// The type of argument N of the given function type.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_ARG_(tn, N, ...) \

    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N

// The matcher type for argument N of the given function type.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_MATCHER_(tn, N, ...) \

    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&

// The variable for mocking the given method.

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_MOCKER_(arity, constness, Method) \

    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_METHOD0_(tn, constness, ct, Method, ...)                       \

  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method() constness {                     \

    GTEST_COMPILE_ASSERT_(                                                   \

        (::testing::tuple_size<tn ::testing::internal::Function<             \

             __VA_ARGS__>::ArgumentTuple>::value == 0),                      \

        this_method_does_not_take_0_arguments);                              \

    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method);      \

    return GMOCK_MOCKER_(0, constness, Method).Invoke();                     \

  }                                                                          \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method() constness {              \

    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this);                 \

    return GMOCK_MOCKER_(0, constness, Method).With();                       \

  }                                                                          \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                           \

      const ::testing::internal::WithoutMatchers&,                           \

      constness ::testing::internal::Function<__VA_ARGS__>*) const {         \

    return ::testing::internal::AdjustConstness_##constness(this)            \

        ->gmock_##Method();                                                  \

  }                                                                          \

  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \

                                                               Method)

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_METHOD1_(tn, constness, ct, Method, ...)                        \

  GMOCK_RESULT_(tn, __VA_ARGS__)                                              \

  ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness {              \

    GTEST_COMPILE_ASSERT_(                                                    \

        (::testing::tuple_size<tn ::testing::internal::Function<              \

             __VA_ARGS__>::ArgumentTuple>::value == 1),                       \

        this_method_does_not_take_1_argument);                                \

    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method);       \

    return GMOCK_MOCKER_(1, constness, Method)                                \

        .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \

            gmock_a1));                                                       \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \

      GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness {                \

    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this);                  \

    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1);                \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \

      const ::testing::internal::WithoutMatchers&,                            \

      constness ::testing::internal::Function<__VA_ARGS__>*) const {          \

    return ::testing::internal::AdjustConstness_##constness(this)             \

        ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>());     \

  }                                                                           \

  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness,  \

                                                               Method)

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_METHOD2_(tn, constness, ct, Method, ...)                        \

  GMOCK_RESULT_(tn, __VA_ARGS__)                                              \

  ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \

            GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness {              \

    GTEST_COMPILE_ASSERT_(                                                    \

        (::testing::tuple_size<tn ::testing::internal::Function<              \

             __VA_ARGS__>::ArgumentTuple>::value == 2),                       \

        this_method_does_not_take_2_arguments);                               \

    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method);       \

    return GMOCK_MOCKER_(2, constness, Method)                                \

        .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \

                    gmock_a1),                                                \

                ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \

                    gmock_a2));                                               \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \

      GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \

      GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness {                \

    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this);                  \

    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2);      \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \

      const ::testing::internal::WithoutMatchers&,                            \

      constness ::testing::internal::Function<__VA_ARGS__>*) const {          \

    return ::testing::internal::AdjustConstness_##constness(this)             \

        ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \

                         ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>());     \

  }                                                                           \

  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness,  \

                                                               Method)

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!

#define GMOCK_METHOD3_(tn, constness, ct, Method, ...)                        \

  GMOCK_RESULT_(tn, __VA_ARGS__)                                              \

  ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \

            GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \

            GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness {              \

    GTEST_COMPILE_ASSERT_(                                                    \

        (::testing::tuple_size<tn ::testing::internal::Function<              \

             __VA_ARGS__>::ArgumentTuple>::value == 3),                       \

        this_method_does_not_take_3_arguments);                               \

    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method);       \

    return GMOCK_MOCKER_(3, constness, Method)                                \

        .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \

                    gmock_a1),                                                \

                ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \

                    gmock_a2),                                                \

                ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \

                    gmock_a3));                                               \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \

      GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \

      GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \

      GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness {                \

    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this);                  \

    return GMOCK_MOCKER_(3, constness, Method)                                \

        .With(gmock_a1, gmock_a2, gmock_a3);                                  \

  }                                                                           \

  ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \