3rdparty/googletest-1.8.1/googlemock/include/gmock/gmock-generated-function-mockers.h

   1 // This file was GENERATED by command:
   2 //     pump.py gmock-generated-function-mockers.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5 // Copyright 2007, Google Inc.
   6 // All rights reserved.
   7 //
   8 // Redistribution and use in source and binary forms, with or without
   9 // modification, are permitted provided that the following conditions are
  10 // met:
  11 //
  12 //     * Redistributions of source code must retain the above copyright
  13 // notice, this list of conditions and the following disclaimer.
  14 //     * Redistributions in binary form must reproduce the above
  15 // copyright notice, this list of conditions and the following disclaimer
  16 // in the documentation and/or other materials provided with the
  17 // distribution.
  18 //     * Neither the name of Google Inc. nor the names of its
  19 // contributors may be used to endorse or promote products derived from
  20 // this software without specific prior written permission.
  21 //
  22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33
  34
  35 // Google Mock - a framework for writing C++ mock classes.
  36 //
  37 // This file implements function mockers of various arities.
  38
  39 // GOOGLETEST_CM0002 DO NOT DELETE
  40
  41 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
  42 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
  43
  44 #include "gmock/gmock-spec-builders.h"
  45 #include "gmock/internal/gmock-internal-utils.h"
  46
  47 #if GTEST_HAS_STD_FUNCTION_
  48 # include <functional>
  49 #endif
  50
  51 namespace testing {
  52 namespace internal {
  53
  54 template <typename F>
  55 class FunctionMockerBase;
  56
  57 // Note: class FunctionMocker really belongs to the ::testing
  58 // namespace.  However if we define it in ::testing, MSVC will
  59 // complain when classes in ::testing::internal declare it as a
  60 // friend class template.  To workaround this compiler bug, we define
  61 // FunctionMocker in ::testing::internal and import it into ::testing.
  62 template <typename F>
  63 class FunctionMocker;
  64
  65 template <typename R>
  66 class FunctionMocker<R()> : public
  67     internal::FunctionMockerBase<R()> {
  68  public:
  69   typedef R F();
  70   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  71
  72   MockSpec<F> With() {
  73     return MockSpec<F>(this, ::testing::make_tuple());
  74   }
  75
  76   R Invoke() {
  77     // Even though gcc and MSVC don't enforce it, 'this->' is required
  78     // by the C++ standard [14.6.4] here, as the base class type is
  79     // dependent on the template argument (and thus shouldn't be
  80     // looked into when resolving InvokeWith).
  81     return this->InvokeWith(ArgumentTuple());
  82   }
  83 };
  84
  85 template <typename R, typename A1>
  86 class FunctionMocker<R(A1)> : public
  87     internal::FunctionMockerBase<R(A1)> {
  88  public:
  89   typedef R F(A1);
  90   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
  91
  92   MockSpec<F> With(const Matcher<A1>& m1) {
  93     return MockSpec<F>(this, ::testing::make_tuple(m1));
  94   }
  95
  96   R Invoke(A1 a1) {
  97     // Even though gcc and MSVC don't enforce it, 'this->' is required
  98     // by the C++ standard [14.6.4] here, as the base class type is
  99     // dependent on the template argument (and thus shouldn't be
 100     // looked into when resolving InvokeWith).
 101     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1)));
 102   }
 103 };
 104
 105 template <typename R, typename A1, typename A2>
 106 class FunctionMocker<R(A1, A2)> : public
 107     internal::FunctionMockerBase<R(A1, A2)> {
 108  public:
 109   typedef R F(A1, A2);
 110   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 111
 112   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
 113     return MockSpec<F>(this, ::testing::make_tuple(m1, m2));
 114   }
 115
 116   R Invoke(A1 a1, A2 a2) {
 117     // Even though gcc and MSVC don't enforce it, 'this->' is required
 118     // by the C++ standard [14.6.4] here, as the base class type is
 119     // dependent on the template argument (and thus shouldn't be
 120     // looked into when resolving InvokeWith).
 121     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 122         internal::forward<A2>(a2)));
 123   }
 124 };
 125
 126 template <typename R, typename A1, typename A2, typename A3>
 127 class FunctionMocker<R(A1, A2, A3)> : public
 128     internal::FunctionMockerBase<R(A1, A2, A3)> {
 129  public:
 130   typedef R F(A1, A2, A3);
 131   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 132
 133   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 134       const Matcher<A3>& m3) {
 135     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3));
 136   }
 137
 138   R Invoke(A1 a1, A2 a2, A3 a3) {
 139     // Even though gcc and MSVC don't enforce it, 'this->' is required
 140     // by the C++ standard [14.6.4] here, as the base class type is
 141     // dependent on the template argument (and thus shouldn't be
 142     // looked into when resolving InvokeWith).
 143     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 144         internal::forward<A2>(a2), internal::forward<A3>(a3)));
 145   }
 146 };
 147
 148 template <typename R, typename A1, typename A2, typename A3, typename A4>
 149 class FunctionMocker<R(A1, A2, A3, A4)> : public
 150     internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
 151  public:
 152   typedef R F(A1, A2, A3, A4);
 153   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 154
 155   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 156       const Matcher<A3>& m3, const Matcher<A4>& m4) {
 157     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4));
 158   }
 159
 160   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
 161     // Even though gcc and MSVC don't enforce it, 'this->' is required
 162     // by the C++ standard [14.6.4] here, as the base class type is
 163     // dependent on the template argument (and thus shouldn't be
 164     // looked into when resolving InvokeWith).
 165     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 166         internal::forward<A2>(a2), internal::forward<A3>(a3),
 167         internal::forward<A4>(a4)));
 168   }
 169 };
 170
 171 template <typename R, typename A1, typename A2, typename A3, typename A4,
 172     typename A5>
 173 class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
 174     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
 175  public:
 176   typedef R F(A1, A2, A3, A4, A5);
 177   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 178
 179   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 180       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
 181     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5));
 182   }
 183
 184   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
 185     // Even though gcc and MSVC don't enforce it, 'this->' is required
 186     // by the C++ standard [14.6.4] here, as the base class type is
 187     // dependent on the template argument (and thus shouldn't be
 188     // looked into when resolving InvokeWith).
 189     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 190         internal::forward<A2>(a2), internal::forward<A3>(a3),
 191         internal::forward<A4>(a4), internal::forward<A5>(a5)));
 192   }
 193 };
 194
 195 template <typename R, typename A1, typename A2, typename A3, typename A4,
 196     typename A5, typename A6>
 197 class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
 198     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
 199  public:
 200   typedef R F(A1, A2, A3, A4, A5, A6);
 201   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 202
 203   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 204       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
 205       const Matcher<A6>& m6) {
 206     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6));
 207   }
 208
 209   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
 210     // Even though gcc and MSVC don't enforce it, 'this->' is required
 211     // by the C++ standard [14.6.4] here, as the base class type is
 212     // dependent on the template argument (and thus shouldn't be
 213     // looked into when resolving InvokeWith).
 214     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 215         internal::forward<A2>(a2), internal::forward<A3>(a3),
 216         internal::forward<A4>(a4), internal::forward<A5>(a5),
 217         internal::forward<A6>(a6)));
 218   }
 219 };
 220
 221 template <typename R, typename A1, typename A2, typename A3, typename A4,
 222     typename A5, typename A6, typename A7>
 223 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
 224     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
 225  public:
 226   typedef R F(A1, A2, A3, A4, A5, A6, A7);
 227   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 228
 229   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 230       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
 231       const Matcher<A6>& m6, const Matcher<A7>& m7) {
 232     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7));
 233   }
 234
 235   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
 236     // Even though gcc and MSVC don't enforce it, 'this->' is required
 237     // by the C++ standard [14.6.4] here, as the base class type is
 238     // dependent on the template argument (and thus shouldn't be
 239     // looked into when resolving InvokeWith).
 240     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 241         internal::forward<A2>(a2), internal::forward<A3>(a3),
 242         internal::forward<A4>(a4), internal::forward<A5>(a5),
 243         internal::forward<A6>(a6), internal::forward<A7>(a7)));
 244   }
 245 };
 246
 247 template <typename R, typename A1, typename A2, typename A3, typename A4,
 248     typename A5, typename A6, typename A7, typename A8>
 249 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
 250     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
 251  public:
 252   typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
 253   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 254
 255   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 256       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
 257       const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
 258     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,
 259         m8));
 260   }
 261
 262   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
 263     // Even though gcc and MSVC don't enforce it, 'this->' is required
 264     // by the C++ standard [14.6.4] here, as the base class type is
 265     // dependent on the template argument (and thus shouldn't be
 266     // looked into when resolving InvokeWith).
 267     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 268         internal::forward<A2>(a2), internal::forward<A3>(a3),
 269         internal::forward<A4>(a4), internal::forward<A5>(a5),
 270         internal::forward<A6>(a6), internal::forward<A7>(a7),
 271         internal::forward<A8>(a8)));
 272   }
 273 };
 274
 275 template <typename R, typename A1, typename A2, typename A3, typename A4,
 276     typename A5, typename A6, typename A7, typename A8, typename A9>
 277 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
 278     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
 279  public:
 280   typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
 281   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 282
 283   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 284       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
 285       const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
 286       const Matcher<A9>& m9) {
 287     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,
 288         m8, m9));
 289   }
 290
 291   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
 292     // Even though gcc and MSVC don't enforce it, 'this->' is required
 293     // by the C++ standard [14.6.4] here, as the base class type is
 294     // dependent on the template argument (and thus shouldn't be
 295     // looked into when resolving InvokeWith).
 296     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 297         internal::forward<A2>(a2), internal::forward<A3>(a3),
 298         internal::forward<A4>(a4), internal::forward<A5>(a5),
 299         internal::forward<A6>(a6), internal::forward<A7>(a7),
 300         internal::forward<A8>(a8), internal::forward<A9>(a9)));
 301   }
 302 };
 303
 304 template <typename R, typename A1, typename A2, typename A3, typename A4,
 305     typename A5, typename A6, typename A7, typename A8, typename A9,
 306     typename A10>
 307 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
 308     internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
 309  public:
 310   typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
 311   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 312
 313   MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2,
 314       const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
 315       const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
 316       const Matcher<A9>& m9, const Matcher<A10>& m10) {
 317     return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7,
 318         m8, m9, m10));
 319   }
 320
 321   R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
 322       A10 a10) {
 323     // Even though gcc and MSVC don't enforce it, 'this->' is required
 324     // by the C++ standard [14.6.4] here, as the base class type is
 325     // dependent on the template argument (and thus shouldn't be
 326     // looked into when resolving InvokeWith).
 327     return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1),
 328         internal::forward<A2>(a2), internal::forward<A3>(a3),
 329         internal::forward<A4>(a4), internal::forward<A5>(a5),
 330         internal::forward<A6>(a6), internal::forward<A7>(a7),
 331         internal::forward<A8>(a8), internal::forward<A9>(a9),
 332         internal::forward<A10>(a10)));
 333   }
 334 };
 335
 336 // Removes the given pointer; this is a helper for the expectation setter method
 337 // for parameterless matchers.
 338 //
 339 // We want to make sure that the user cannot set a parameterless expectation on
 340 // overloaded methods, including methods which are overloaded on const. Example:
 341 //
 342 //   class MockClass {
 343 //     MOCK_METHOD0(GetName, string&());
 344 //     MOCK_CONST_METHOD0(GetName, const string&());
 345 //   };
 346 //
 347 //   TEST() {
 348 //     // This should be an error, as it's not clear which overload is expected.
 349 //     EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value));
 350 //   }
 351 //
 352 // Here are the generated expectation-setter methods:
 353 //
 354 //   class MockClass {
 355 //     // Overload 1
 356 //     MockSpec<string&()> gmock_GetName() { ... }
 357 //     // Overload 2. Declared const so that the compiler will generate an
 358 //     // error when trying to resolve between this and overload 4 in
 359 //     // 'gmock_GetName(WithoutMatchers(), nullptr)'.
 360 //     MockSpec<string&()> gmock_GetName(
 361 //         const WithoutMatchers&, const Function<string&()>*) const {
 362 //       // Removes const from this, calls overload 1
 363 //       return AdjustConstness_(this)->gmock_GetName();
 364 //     }
 365 //
 366 //     // Overload 3
 367 //     const string& gmock_GetName() const { ... }
 368 //     // Overload 4
 369 //     MockSpec<const string&()> gmock_GetName(
 370 //         const WithoutMatchers&, const Function<const string&()>*) const {
 371 //       // Does not remove const, calls overload 3
 372 //       return AdjustConstness_const(this)->gmock_GetName();
 373 //     }
 374 //   }
 375 //
 376 template <typename MockType>
 377 const MockType* AdjustConstness_const(const MockType* mock) {
 378   return mock;
 379 }
 380
 381 // Removes const from and returns the given pointer; this is a helper for the
 382 // expectation setter method for parameterless matchers.
 383 template <typename MockType>
 384 MockType* AdjustConstness_(const MockType* mock) {
 385   return const_cast<MockType*>(mock);
 386 }
 387
 388 }  // namespace internal
 389
 390 // The style guide prohibits "using" statements in a namespace scope
 391 // inside a header file.  However, the FunctionMocker class template
 392 // is meant to be defined in the ::testing namespace.  The following
 393 // line is just a trick for working around a bug in MSVC 8.0, which
 394 // cannot handle it if we define FunctionMocker in ::testing.
 395 using internal::FunctionMocker;
 396
 397 // GMOCK_RESULT_(tn, F) expands to the result type of function type F.
 398 // We define this as a variadic macro in case F contains unprotected
 399 // commas (the same reason that we use variadic macros in other places
 400 // in this file).
 401 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 402 #define GMOCK_RESULT_(tn, ...) \
 403     tn ::testing::internal::Function<__VA_ARGS__>::Result
 404
 405 // The type of argument N of the given function type.
 406 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 407 #define GMOCK_ARG_(tn, N, ...) \
 408     tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
 409
 410 // The matcher type for argument N of the given function type.
 411 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 412 #define GMOCK_MATCHER_(tn, N, ...) \
 413     const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
 414
 415 // The variable for mocking the given method.
 416 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 417 #define GMOCK_MOCKER_(arity, constness, Method) \
 418     GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
 419
 420 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 421 #define GMOCK_METHOD0_(tn, constness, ct, Method, ...)                       \
 422   GMOCK_RESULT_(tn, __VA_ARGS__) ct Method() constness {                     \
 423     GTEST_COMPILE_ASSERT_(                                                   \
 424         (::testing::tuple_size<tn ::testing::internal::Function<             \
 425              __VA_ARGS__>::ArgumentTuple>::value == 0),                      \
 426         this_method_does_not_take_0_arguments);                              \
 427     GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method);      \
 428     return GMOCK_MOCKER_(0, constness, Method).Invoke();                     \
 429   }                                                                          \
 430   ::testing::MockSpec<__VA_ARGS__> gmock_##Method() constness {              \
 431     GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this);                 \
 432     return GMOCK_MOCKER_(0, constness, Method).With();                       \
 433   }                                                                          \
 434   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                           \
 435       const ::testing::internal::WithoutMatchers&,                           \
 436       constness ::testing::internal::Function<__VA_ARGS__>*) const {         \
 437     return ::testing::internal::AdjustConstness_##constness(this)            \
 438         ->gmock_##Method();                                                  \
 439   }                                                                          \
 440   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
 441                                                                Method)
 442
 443 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 444 #define GMOCK_METHOD1_(tn, constness, ct, Method, ...)                        \
 445   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 446   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness {              \
 447     GTEST_COMPILE_ASSERT_(                                                    \
 448         (::testing::tuple_size<tn ::testing::internal::Function<              \
 449              __VA_ARGS__>::ArgumentTuple>::value == 1),                       \
 450         this_method_does_not_take_1_argument);                                \
 451     GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method);       \
 452     return GMOCK_MOCKER_(1, constness, Method)                                \
 453         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 454             gmock_a1));                                                       \
 455   }                                                                           \
 456   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 457       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness {                \
 458     GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this);                  \
 459     return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1);                \
 460   }                                                                           \
 461   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 462       const ::testing::internal::WithoutMatchers&,                            \
 463       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 464     return ::testing::internal::AdjustConstness_##constness(this)             \
 465         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>());     \
 466   }                                                                           \
 467   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness,  \
 468                                                                Method)
 469
 470 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 471 #define GMOCK_METHOD2_(tn, constness, ct, Method, ...)                        \
 472   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 473   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 474             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness {              \
 475     GTEST_COMPILE_ASSERT_(                                                    \
 476         (::testing::tuple_size<tn ::testing::internal::Function<              \
 477              __VA_ARGS__>::ArgumentTuple>::value == 2),                       \
 478         this_method_does_not_take_2_arguments);                               \
 479     GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method);       \
 480     return GMOCK_MOCKER_(2, constness, Method)                                \
 481         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 482                     gmock_a1),                                                \
 483                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 484                     gmock_a2));                                               \
 485   }                                                                           \
 486   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 487       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 488       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness {                \
 489     GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this);                  \
 490     return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2);      \
 491   }                                                                           \
 492   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 493       const ::testing::internal::WithoutMatchers&,                            \
 494       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 495     return ::testing::internal::AdjustConstness_##constness(this)             \
 496         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 497                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>());     \
 498   }                                                                           \
 499   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness,  \
 500                                                                Method)
 501
 502 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 503 #define GMOCK_METHOD3_(tn, constness, ct, Method, ...)                        \
 504   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 505   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 506             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 507             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness {              \
 508     GTEST_COMPILE_ASSERT_(                                                    \
 509         (::testing::tuple_size<tn ::testing::internal::Function<              \
 510              __VA_ARGS__>::ArgumentTuple>::value == 3),                       \
 511         this_method_does_not_take_3_arguments);                               \
 512     GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method);       \
 513     return GMOCK_MOCKER_(3, constness, Method)                                \
 514         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 515                     gmock_a1),                                                \
 516                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 517                     gmock_a2),                                                \
 518                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 519                     gmock_a3));                                               \
 520   }                                                                           \
 521   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 522       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 523       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 524       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness {                \
 525     GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this);                  \
 526     return GMOCK_MOCKER_(3, constness, Method)                                \
 527         .With(gmock_a1, gmock_a2, gmock_a3);                                  \
 528   }                                                                           \
 529   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 530       const ::testing::internal::WithoutMatchers&,                            \
 531       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 532     return ::testing::internal::AdjustConstness_##constness(this)             \
 533         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 534                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 535                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>());     \
 536   }                                                                           \
 537   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness,  \
 538                                                                Method)
 539
 540 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 541 #define GMOCK_METHOD4_(tn, constness, ct, Method, ...)                        \
 542   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 543   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 544             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 545             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 546             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness {              \
 547     GTEST_COMPILE_ASSERT_(                                                    \
 548         (::testing::tuple_size<tn ::testing::internal::Function<              \
 549              __VA_ARGS__>::ArgumentTuple>::value == 4),                       \
 550         this_method_does_not_take_4_arguments);                               \
 551     GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method);       \
 552     return GMOCK_MOCKER_(4, constness, Method)                                \
 553         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 554                     gmock_a1),                                                \
 555                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 556                     gmock_a2),                                                \
 557                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 558                     gmock_a3),                                                \
 559                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 560                     gmock_a4));                                               \
 561   }                                                                           \
 562   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 563       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 564       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 565       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 566       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness {                \
 567     GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this);                  \
 568     return GMOCK_MOCKER_(4, constness, Method)                                \
 569         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4);                        \
 570   }                                                                           \
 571   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 572       const ::testing::internal::WithoutMatchers&,                            \
 573       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 574     return ::testing::internal::AdjustConstness_##constness(this)             \
 575         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 576                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 577                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 578                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>());     \
 579   }                                                                           \
 580   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness,  \
 581                                                                Method)
 582
 583 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 584 #define GMOCK_METHOD5_(tn, constness, ct, Method, ...)                        \
 585   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 586   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 587             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 588             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 589             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                          \
 590             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness {              \
 591     GTEST_COMPILE_ASSERT_(                                                    \
 592         (::testing::tuple_size<tn ::testing::internal::Function<              \
 593              __VA_ARGS__>::ArgumentTuple>::value == 5),                       \
 594         this_method_does_not_take_5_arguments);                               \
 595     GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method);       \
 596     return GMOCK_MOCKER_(5, constness, Method)                                \
 597         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 598                     gmock_a1),                                                \
 599                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 600                     gmock_a2),                                                \
 601                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 602                     gmock_a3),                                                \
 603                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 604                     gmock_a4),                                                \
 605                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \
 606                     gmock_a5));                                               \
 607   }                                                                           \
 608   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 609       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 610       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 611       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 612       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                            \
 613       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness {                \
 614     GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this);                  \
 615     return GMOCK_MOCKER_(5, constness, Method)                                \
 616         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5);              \
 617   }                                                                           \
 618   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 619       const ::testing::internal::WithoutMatchers&,                            \
 620       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 621     return ::testing::internal::AdjustConstness_##constness(this)             \
 622         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 623                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 624                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 625                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),      \
 626                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>());     \
 627   }                                                                           \
 628   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness,  \
 629                                                                Method)
 630
 631 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 632 #define GMOCK_METHOD6_(tn, constness, ct, Method, ...)                        \
 633   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 634   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 635             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 636             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 637             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                          \
 638             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,                          \
 639             GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness {              \
 640     GTEST_COMPILE_ASSERT_(                                                    \
 641         (::testing::tuple_size<tn ::testing::internal::Function<              \
 642              __VA_ARGS__>::ArgumentTuple>::value == 6),                       \
 643         this_method_does_not_take_6_arguments);                               \
 644     GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method);       \
 645     return GMOCK_MOCKER_(6, constness, Method)                                \
 646         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 647                     gmock_a1),                                                \
 648                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 649                     gmock_a2),                                                \
 650                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 651                     gmock_a3),                                                \
 652                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 653                     gmock_a4),                                                \
 654                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \
 655                     gmock_a5),                                                \
 656                 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \
 657                     gmock_a6));                                               \
 658   }                                                                           \
 659   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 660       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 661       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 662       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 663       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                            \
 664       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,                            \
 665       GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness {                \
 666     GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this);                  \
 667     return GMOCK_MOCKER_(6, constness, Method)                                \
 668         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6);    \
 669   }                                                                           \
 670   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 671       const ::testing::internal::WithoutMatchers&,                            \
 672       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 673     return ::testing::internal::AdjustConstness_##constness(this)             \
 674         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 675                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 676                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 677                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),      \
 678                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),      \
 679                          ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>());     \
 680   }                                                                           \
 681   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness,  \
 682                                                                Method)
 683
 684 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 685 #define GMOCK_METHOD7_(tn, constness, ct, Method, ...)                        \
 686   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 687   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 688             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 689             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 690             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                          \
 691             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,                          \
 692             GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,                          \
 693             GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness {              \
 694     GTEST_COMPILE_ASSERT_(                                                    \
 695         (::testing::tuple_size<tn ::testing::internal::Function<              \
 696              __VA_ARGS__>::ArgumentTuple>::value == 7),                       \
 697         this_method_does_not_take_7_arguments);                               \
 698     GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method);       \
 699     return GMOCK_MOCKER_(7, constness, Method)                                \
 700         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 701                     gmock_a1),                                                \
 702                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 703                     gmock_a2),                                                \
 704                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 705                     gmock_a3),                                                \
 706                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 707                     gmock_a4),                                                \
 708                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \
 709                     gmock_a5),                                                \
 710                 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \
 711                     gmock_a6),                                                \
 712                 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \
 713                     gmock_a7));                                               \
 714   }                                                                           \
 715   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 716       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 717       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 718       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 719       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                            \
 720       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,                            \
 721       GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,                            \
 722       GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness {                \
 723     GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this);                  \
 724     return GMOCK_MOCKER_(7, constness, Method)                                \
 725         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6,     \
 726               gmock_a7);                                                      \
 727   }                                                                           \
 728   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 729       const ::testing::internal::WithoutMatchers&,                            \
 730       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 731     return ::testing::internal::AdjustConstness_##constness(this)             \
 732         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 733                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 734                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 735                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),      \
 736                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),      \
 737                          ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),      \
 738                          ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>());     \
 739   }                                                                           \
 740   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness,  \
 741                                                                Method)
 742
 743 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 744 #define GMOCK_METHOD8_(tn, constness, ct, Method, ...)                        \
 745   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 746   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 747             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 748             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 749             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                          \
 750             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,                          \
 751             GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,                          \
 752             GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,                          \
 753             GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness {              \
 754     GTEST_COMPILE_ASSERT_(                                                    \
 755         (::testing::tuple_size<tn ::testing::internal::Function<              \
 756              __VA_ARGS__>::ArgumentTuple>::value == 8),                       \
 757         this_method_does_not_take_8_arguments);                               \
 758     GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method);       \
 759     return GMOCK_MOCKER_(8, constness, Method)                                \
 760         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 761                     gmock_a1),                                                \
 762                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 763                     gmock_a2),                                                \
 764                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 765                     gmock_a3),                                                \
 766                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 767                     gmock_a4),                                                \
 768                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \
 769                     gmock_a5),                                                \
 770                 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \
 771                     gmock_a6),                                                \
 772                 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \
 773                     gmock_a7),                                                \
 774                 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>( \
 775                     gmock_a8));                                               \
 776   }                                                                           \
 777   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 778       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 779       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 780       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 781       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                            \
 782       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,                            \
 783       GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,                            \
 784       GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,                            \
 785       GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness {                \
 786     GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this);                  \
 787     return GMOCK_MOCKER_(8, constness, Method)                                \
 788         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6,     \
 789               gmock_a7, gmock_a8);                                            \
 790   }                                                                           \
 791   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 792       const ::testing::internal::WithoutMatchers&,                            \
 793       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 794     return ::testing::internal::AdjustConstness_##constness(this)             \
 795         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 796                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 797                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 798                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),      \
 799                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),      \
 800                          ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),      \
 801                          ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),      \
 802                          ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>());     \
 803   }                                                                           \
 804   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness,  \
 805                                                                Method)
 806
 807 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 808 #define GMOCK_METHOD9_(tn, constness, ct, Method, ...)                        \
 809   GMOCK_RESULT_(tn, __VA_ARGS__)                                              \
 810   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                          \
 811             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                          \
 812             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                          \
 813             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                          \
 814             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,                          \
 815             GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,                          \
 816             GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,                          \
 817             GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8,                          \
 818             GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness {              \
 819     GTEST_COMPILE_ASSERT_(                                                    \
 820         (::testing::tuple_size<tn ::testing::internal::Function<              \
 821              __VA_ARGS__>::ArgumentTuple>::value == 9),                       \
 822         this_method_does_not_take_9_arguments);                               \
 823     GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method);       \
 824     return GMOCK_MOCKER_(9, constness, Method)                                \
 825         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \
 826                     gmock_a1),                                                \
 827                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \
 828                     gmock_a2),                                                \
 829                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \
 830                     gmock_a3),                                                \
 831                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \
 832                     gmock_a4),                                                \
 833                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \
 834                     gmock_a5),                                                \
 835                 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \
 836                     gmock_a6),                                                \
 837                 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \
 838                     gmock_a7),                                                \
 839                 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>( \
 840                     gmock_a8),                                                \
 841                 ::testing::internal::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>( \
 842                     gmock_a9));                                               \
 843   }                                                                           \
 844   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 845       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                            \
 846       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                            \
 847       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                            \
 848       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                            \
 849       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,                            \
 850       GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,                            \
 851       GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,                            \
 852       GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8,                            \
 853       GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness {                \
 854     GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this);                  \
 855     return GMOCK_MOCKER_(9, constness, Method)                                \
 856         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6,     \
 857               gmock_a7, gmock_a8, gmock_a9);                                  \
 858   }                                                                           \
 859   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                            \
 860       const ::testing::internal::WithoutMatchers&,                            \
 861       constness ::testing::internal::Function<__VA_ARGS__>*) const {          \
 862     return ::testing::internal::AdjustConstness_##constness(this)             \
 863         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),      \
 864                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),      \
 865                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),      \
 866                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),      \
 867                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),      \
 868                          ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),      \
 869                          ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),      \
 870                          ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(),      \
 871                          ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>());     \
 872   }                                                                           \
 873   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness,  \
 874                                                                Method)
 875
 876 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 877 #define GMOCK_METHOD10_(tn, constness, ct, Method, ...)                        \
 878   GMOCK_RESULT_(tn, __VA_ARGS__)                                               \
 879   ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1,                           \
 880             GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2,                           \
 881             GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3,                           \
 882             GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4,                           \
 883             GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5,                           \
 884             GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6,                           \
 885             GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7,                           \
 886             GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8,                           \
 887             GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9,                           \
 888             GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness {             \
 889     GTEST_COMPILE_ASSERT_(                                                     \
 890         (::testing::tuple_size<tn ::testing::internal::Function<               \
 891              __VA_ARGS__>::ArgumentTuple>::value == 10),                       \
 892         this_method_does_not_take_10_arguments);                               \
 893     GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method);       \
 894     return GMOCK_MOCKER_(10, constness, Method)                                \
 895         .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(  \
 896                     gmock_a1),                                                 \
 897                 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(  \
 898                     gmock_a2),                                                 \
 899                 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(  \
 900                     gmock_a3),                                                 \
 901                 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(  \
 902                     gmock_a4),                                                 \
 903                 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(  \
 904                     gmock_a5),                                                 \
 905                 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(  \
 906                     gmock_a6),                                                 \
 907                 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(  \
 908                     gmock_a7),                                                 \
 909                 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(  \
 910                     gmock_a8),                                                 \
 911                 ::testing::internal::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(  \
 912                     gmock_a9),                                                 \
 913                 ::testing::internal::forward<GMOCK_ARG_(tn, 10, __VA_ARGS__)>( \
 914                     gmock_a10));                                               \
 915   }                                                                            \
 916   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                             \
 917       GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1,                             \
 918       GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2,                             \
 919       GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3,                             \
 920       GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4,                             \
 921       GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5,                             \
 922       GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6,                             \
 923       GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7,                             \
 924       GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8,                             \
 925       GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9,                             \
 926       GMOCK_MATCHER_(tn, 10, __VA_ARGS__) gmock_a10) constness {               \
 927     GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this);                  \
 928     return GMOCK_MOCKER_(10, constness, Method)                                \
 929         .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6,      \
 930               gmock_a7, gmock_a8, gmock_a9, gmock_a10);                        \
 931   }                                                                            \
 932   ::testing::MockSpec<__VA_ARGS__> gmock_##Method(                             \
 933       const ::testing::internal::WithoutMatchers&,                             \
 934       constness ::testing::internal::Function<__VA_ARGS__>*) const {           \
 935     return ::testing::internal::AdjustConstness_##constness(this)              \
 936         ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(),       \
 937                          ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(),       \
 938                          ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(),       \
 939                          ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(),       \
 940                          ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(),       \
 941                          ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(),       \
 942                          ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(),       \
 943                          ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(),       \
 944                          ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(),       \
 945                          ::testing::A<GMOCK_ARG_(tn, 10, __VA_ARGS__)>());     \
 946   }                                                                            \
 947   mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness,  \
 948                                                                Method)
 949
 950 #define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
 951 #define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
 952 #define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
 953 #define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
 954 #define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
 955 #define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
 956 #define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
 957 #define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
 958 #define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
 959 #define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
 960 #define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
 961
 962 #define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
 963 #define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
 964 #define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
 965 #define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
 966 #define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
 967 #define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
 968 #define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
 969 #define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
 970 #define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
 971 #define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
 972 #define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
 973
 974 #define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
 975 #define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
 976 #define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
 977 #define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
 978 #define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
 979 #define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
 980 #define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
 981 #define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
 982 #define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
 983 #define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
 984 #define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
 985
 986 #define MOCK_CONST_METHOD0_T(m, ...) \
 987     GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
 988 #define MOCK_CONST_METHOD1_T(m, ...) \
 989     GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
 990 #define MOCK_CONST_METHOD2_T(m, ...) \
 991     GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
 992 #define MOCK_CONST_METHOD3_T(m, ...) \
 993     GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
 994 #define MOCK_CONST_METHOD4_T(m, ...) \
 995     GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
 996 #define MOCK_CONST_METHOD5_T(m, ...) \
 997     GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
 998 #define MOCK_CONST_METHOD6_T(m, ...) \
 999     GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
1000 #define MOCK_CONST_METHOD7_T(m, ...) \
1001     GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
1002 #define MOCK_CONST_METHOD8_T(m, ...) \
1003     GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
1004 #define MOCK_CONST_METHOD9_T(m, ...) \
1005     GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
1006 #define MOCK_CONST_METHOD10_T(m, ...) \
1007     GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
1008
1009 #define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
1010     GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
1011 #define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
1012     GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
1013 #define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
1014     GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
1015 #define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
1016     GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
1017 #define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
1018     GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
1019 #define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
1020     GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
1021 #define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
1022     GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
1023 #define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
1024     GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
1025 #define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
1026     GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
1027 #define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
1028     GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
1029 #define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
1030     GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
1031
1032 #define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
1033     GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
1034 #define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
1035     GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
1036 #define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
1037     GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
1038 #define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
1039     GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
1040 #define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
1041     GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
1042 #define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
1043     GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
1044 #define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
1045     GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
1046 #define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
1047     GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
1048 #define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
1049     GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
1050 #define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
1051     GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
1052 #define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
1053     GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
1054
1055 #define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
1056     GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
1057 #define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
1058     GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
1059 #define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
1060     GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
1061 #define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
1062     GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
1063 #define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
1064     GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
1065 #define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
1066     GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
1067 #define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
1068     GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
1069 #define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
1070     GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
1071 #define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
1072     GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
1073 #define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
1074     GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
1075 #define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
1076     GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
1077
1078 #define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
1079     GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
1080 #define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
1081     GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
1082 #define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
1083     GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
1084 #define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
1085     GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
1086 #define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
1087     GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
1088 #define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
1089     GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
1090 #define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
1091     GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
1092 #define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
1093     GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
1094 #define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
1095     GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
1096 #define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
1097     GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
1098 #define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
1099     GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
1100
1101 // A MockFunction<F> class has one mock method whose type is F.  It is
1102 // useful when you just want your test code to emit some messages and
1103 // have Google Mock verify the right messages are sent (and perhaps at
1104 // the right times).  For example, if you are exercising code:
1105 //
1106 //   Foo(1);
1107 //   Foo(2);
1108 //   Foo(3);
1109 //
1110 // and want to verify that Foo(1) and Foo(3) both invoke
1111 // mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
1112 //
1113 // TEST(FooTest, InvokesBarCorrectly) {
1114 //   MyMock mock;
1115 //   MockFunction<void(string check_point_name)> check;
1116 //   {
1117 //     InSequence s;
1118 //
1119 //     EXPECT_CALL(mock, Bar("a"));
1120 //     EXPECT_CALL(check, Call("1"));
1121 //     EXPECT_CALL(check, Call("2"));
1122 //     EXPECT_CALL(mock, Bar("a"));
1123 //   }
1124 //   Foo(1);
1125 //   check.Call("1");
1126 //   Foo(2);
1127 //   check.Call("2");
1128 //   Foo(3);
1129 // }
1130 //
1131 // The expectation spec says that the first Bar("a") must happen
1132 // before check point "1", the second Bar("a") must happen after check
1133 // point "2", and nothing should happen between the two check
1134 // points. The explicit check points make it easy to tell which
1135 // Bar("a") is called by which call to Foo().
1136 //
1137 // MockFunction<F> can also be used to exercise code that accepts
1138 // std::function<F> callbacks. To do so, use AsStdFunction() method
1139 // to create std::function proxy forwarding to original object's Call.
1140 // Example:
1141 //
1142 // TEST(FooTest, RunsCallbackWithBarArgument) {
1143 //   MockFunction<int(string)> callback;
1144 //   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
1145 //   Foo(callback.AsStdFunction());
1146 // }
1147 template <typename F>
1148 class MockFunction;
1149
1150 template <typename R>
1151 class MockFunction<R()> {
1152  public:
1153   MockFunction() {}
1154
1155   MOCK_METHOD0_T(Call, R());
1156
1157 #if GTEST_HAS_STD_FUNCTION_
1158   ::std::function<R()> AsStdFunction() {
1159     return [this]() -> R {
1160       return this->Call();
1161     };
1162   }
1163 #endif  // GTEST_HAS_STD_FUNCTION_
1164
1165  private:
1166   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1167 };
1168
1169 template <typename R, typename A0>
1170 class MockFunction<R(A0)> {
1171  public:
1172   MockFunction() {}
1173
1174   MOCK_METHOD1_T(Call, R(A0));
1175
1176 #if GTEST_HAS_STD_FUNCTION_
1177   ::std::function<R(A0)> AsStdFunction() {
1178     return [this](A0 a0) -> R {
1179       return this->Call(::std::move(a0));
1180     };
1181   }
1182 #endif  // GTEST_HAS_STD_FUNCTION_
1183
1184  private:
1185   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1186 };
1187
1188 template <typename R, typename A0, typename A1>
1189 class MockFunction<R(A0, A1)> {
1190  public:
1191   MockFunction() {}
1192
1193   MOCK_METHOD2_T(Call, R(A0, A1));
1194
1195 #if GTEST_HAS_STD_FUNCTION_
1196   ::std::function<R(A0, A1)> AsStdFunction() {
1197     return [this](A0 a0, A1 a1) -> R {
1198       return this->Call(::std::move(a0), ::std::move(a1));
1199     };
1200   }
1201 #endif  // GTEST_HAS_STD_FUNCTION_
1202
1203  private:
1204   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1205 };
1206
1207 template <typename R, typename A0, typename A1, typename A2>
1208 class MockFunction<R(A0, A1, A2)> {
1209  public:
1210   MockFunction() {}
1211
1212   MOCK_METHOD3_T(Call, R(A0, A1, A2));
1213
1214 #if GTEST_HAS_STD_FUNCTION_
1215   ::std::function<R(A0, A1, A2)> AsStdFunction() {
1216     return [this](A0 a0, A1 a1, A2 a2) -> R {
1217       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2));
1218     };
1219   }
1220 #endif  // GTEST_HAS_STD_FUNCTION_
1221
1222  private:
1223   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1224 };
1225
1226 template <typename R, typename A0, typename A1, typename A2, typename A3>
1227 class MockFunction<R(A0, A1, A2, A3)> {
1228  public:
1229   MockFunction() {}
1230
1231   MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
1232
1233 #if GTEST_HAS_STD_FUNCTION_
1234   ::std::function<R(A0, A1, A2, A3)> AsStdFunction() {
1235     return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R {
1236       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1237           ::std::move(a3));
1238     };
1239   }
1240 #endif  // GTEST_HAS_STD_FUNCTION_
1241
1242  private:
1243   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1244 };
1245
1246 template <typename R, typename A0, typename A1, typename A2, typename A3,
1247     typename A4>
1248 class MockFunction<R(A0, A1, A2, A3, A4)> {
1249  public:
1250   MockFunction() {}
1251
1252   MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
1253
1254 #if GTEST_HAS_STD_FUNCTION_
1255   ::std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() {
1256     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R {
1257       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1258           ::std::move(a3), ::std::move(a4));
1259     };
1260   }
1261 #endif  // GTEST_HAS_STD_FUNCTION_
1262
1263  private:
1264   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1265 };
1266
1267 template <typename R, typename A0, typename A1, typename A2, typename A3,
1268     typename A4, typename A5>
1269 class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
1270  public:
1271   MockFunction() {}
1272
1273   MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
1274
1275 #if GTEST_HAS_STD_FUNCTION_
1276   ::std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() {
1277     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R {
1278       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1279           ::std::move(a3), ::std::move(a4), ::std::move(a5));
1280     };
1281   }
1282 #endif  // GTEST_HAS_STD_FUNCTION_
1283
1284  private:
1285   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1286 };
1287
1288 template <typename R, typename A0, typename A1, typename A2, typename A3,
1289     typename A4, typename A5, typename A6>
1290 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
1291  public:
1292   MockFunction() {}
1293
1294   MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
1295
1296 #if GTEST_HAS_STD_FUNCTION_
1297   ::std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() {
1298     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R {
1299       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1300           ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6));
1301     };
1302   }
1303 #endif  // GTEST_HAS_STD_FUNCTION_
1304
1305  private:
1306   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1307 };
1308
1309 template <typename R, typename A0, typename A1, typename A2, typename A3,
1310     typename A4, typename A5, typename A6, typename A7>
1311 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
1312  public:
1313   MockFunction() {}
1314
1315   MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
1316
1317 #if GTEST_HAS_STD_FUNCTION_
1318   ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() {
1319     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R {
1320       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1321           ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6),
1322           ::std::move(a7));
1323     };
1324   }
1325 #endif  // GTEST_HAS_STD_FUNCTION_
1326
1327  private:
1328   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1329 };
1330
1331 template <typename R, typename A0, typename A1, typename A2, typename A3,
1332     typename A4, typename A5, typename A6, typename A7, typename A8>
1333 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
1334  public:
1335   MockFunction() {}
1336
1337   MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
1338
1339 #if GTEST_HAS_STD_FUNCTION_
1340   ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() {
1341     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
1342         A8 a8) -> R {
1343       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1344           ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6),
1345           ::std::move(a7), ::std::move(a8));
1346     };
1347   }
1348 #endif  // GTEST_HAS_STD_FUNCTION_
1349
1350  private:
1351   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1352 };
1353
1354 template <typename R, typename A0, typename A1, typename A2, typename A3,
1355     typename A4, typename A5, typename A6, typename A7, typename A8,
1356     typename A9>
1357 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
1358  public:
1359   MockFunction() {}
1360
1361   MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
1362
1363 #if GTEST_HAS_STD_FUNCTION_
1364   ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() {
1365     return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7,
1366         A8 a8, A9 a9) -> R {
1367       return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2),
1368           ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6),
1369           ::std::move(a7), ::std::move(a8), ::std::move(a9));
1370     };
1371   }
1372 #endif  // GTEST_HAS_STD_FUNCTION_
1373
1374  private:
1375   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
1376 };
1377
1378 }  // namespace testing
1379
1380 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_