PageRenderTime 62ms CodeModel.GetById 22ms app.highlight 34ms RepoModel.GetById 1ms app.codeStats 0ms

/testlibs/gmock/include/gmock/gmock-generated-function-mockers.h

https://github.com/deltaforge/nebu-app-hadoop
C Header | 929 lines | 684 code | 101 blank | 144 comment | 11 complexity | 61ec32f4e14f62acf4b7c17b18e7ab94 MD5 | raw file
  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// Author: wan@google.com (Zhanyong Wan)
 35
 36// Google Mock - a framework for writing C++ mock classes.
 37//
 38// This file implements function mockers of various arities.
 39
 40#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
 41#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
 42
 43#include "gmock/gmock-spec-builders.h"
 44#include "gmock/internal/gmock-internal-utils.h"
 45
 46namespace testing {
 47namespace internal {
 48
 49template <typename F>
 50class FunctionMockerBase;
 51
 52// Note: class FunctionMocker really belongs to the ::testing
 53// namespace.  However if we define it in ::testing, MSVC will
 54// complain when classes in ::testing::internal declare it as a
 55// friend class template.  To workaround this compiler bug, we define
 56// FunctionMocker in ::testing::internal and import it into ::testing.
 57template <typename F>
 58class FunctionMocker;
 59
 60template <typename R>
 61class FunctionMocker<R()> : public
 62    internal::FunctionMockerBase<R()> {
 63 public:
 64  typedef R F();
 65  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 66
 67  MockSpec<F>& With() {
 68    return this->current_spec();
 69  }
 70
 71  R Invoke() {
 72    // Even though gcc and MSVC don't enforce it, 'this->' is required
 73    // by the C++ standard [14.6.4] here, as the base class type is
 74    // dependent on the template argument (and thus shouldn't be
 75    // looked into when resolving InvokeWith).
 76    return this->InvokeWith(ArgumentTuple());
 77  }
 78};
 79
 80template <typename R, typename A1>
 81class FunctionMocker<R(A1)> : public
 82    internal::FunctionMockerBase<R(A1)> {
 83 public:
 84  typedef R F(A1);
 85  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 86
 87  MockSpec<F>& With(const Matcher<A1>& m1) {
 88    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1));
 89    return this->current_spec();
 90  }
 91
 92  R Invoke(A1 a1) {
 93    // Even though gcc and MSVC don't enforce it, 'this->' is required
 94    // by the C++ standard [14.6.4] here, as the base class type is
 95    // dependent on the template argument (and thus shouldn't be
 96    // looked into when resolving InvokeWith).
 97    return this->InvokeWith(ArgumentTuple(a1));
 98  }
 99};
100
101template <typename R, typename A1, typename A2>
102class FunctionMocker<R(A1, A2)> : public
103    internal::FunctionMockerBase<R(A1, A2)> {
104 public:
105  typedef R F(A1, A2);
106  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
107
108  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
109    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2));
110    return this->current_spec();
111  }
112
113  R Invoke(A1 a1, A2 a2) {
114    // Even though gcc and MSVC don't enforce it, 'this->' is required
115    // by the C++ standard [14.6.4] here, as the base class type is
116    // dependent on the template argument (and thus shouldn't be
117    // looked into when resolving InvokeWith).
118    return this->InvokeWith(ArgumentTuple(a1, a2));
119  }
120};
121
122template <typename R, typename A1, typename A2, typename A3>
123class FunctionMocker<R(A1, A2, A3)> : public
124    internal::FunctionMockerBase<R(A1, A2, A3)> {
125 public:
126  typedef R F(A1, A2, A3);
127  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
128
129  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
130      const Matcher<A3>& m3) {
131    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3));
132    return this->current_spec();
133  }
134
135  R Invoke(A1 a1, A2 a2, A3 a3) {
136    // Even though gcc and MSVC don't enforce it, 'this->' is required
137    // by the C++ standard [14.6.4] here, as the base class type is
138    // dependent on the template argument (and thus shouldn't be
139    // looked into when resolving InvokeWith).
140    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
141  }
142};
143
144template <typename R, typename A1, typename A2, typename A3, typename A4>
145class FunctionMocker<R(A1, A2, A3, A4)> : public
146    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
147 public:
148  typedef R F(A1, A2, A3, A4);
149  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
150
151  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
152      const Matcher<A3>& m3, const Matcher<A4>& m4) {
153    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4));
154    return this->current_spec();
155  }
156
157  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
158    // Even though gcc and MSVC don't enforce it, 'this->' is required
159    // by the C++ standard [14.6.4] here, as the base class type is
160    // dependent on the template argument (and thus shouldn't be
161    // looked into when resolving InvokeWith).
162    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
163  }
164};
165
166template <typename R, typename A1, typename A2, typename A3, typename A4,
167    typename A5>
168class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
169    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
170 public:
171  typedef R F(A1, A2, A3, A4, A5);
172  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
173
174  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
175      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
176    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4,
177        m5));
178    return this->current_spec();
179  }
180
181  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
182    // Even though gcc and MSVC don't enforce it, 'this->' is required
183    // by the C++ standard [14.6.4] here, as the base class type is
184    // dependent on the template argument (and thus shouldn't be
185    // looked into when resolving InvokeWith).
186    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
187  }
188};
189
190template <typename R, typename A1, typename A2, typename A3, typename A4,
191    typename A5, typename A6>
192class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
193    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
194 public:
195  typedef R F(A1, A2, A3, A4, A5, A6);
196  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
197
198  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
199      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
200      const Matcher<A6>& m6) {
201    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
202        m6));
203    return this->current_spec();
204  }
205
206  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
207    // Even though gcc and MSVC don't enforce it, 'this->' is required
208    // by the C++ standard [14.6.4] here, as the base class type is
209    // dependent on the template argument (and thus shouldn't be
210    // looked into when resolving InvokeWith).
211    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
212  }
213};
214
215template <typename R, typename A1, typename A2, typename A3, typename A4,
216    typename A5, typename A6, typename A7>
217class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
218    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
219 public:
220  typedef R F(A1, A2, A3, A4, A5, A6, A7);
221  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
222
223  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
224      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
225      const Matcher<A6>& m6, const Matcher<A7>& m7) {
226    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
227        m6, m7));
228    return this->current_spec();
229  }
230
231  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
232    // Even though gcc and MSVC don't enforce it, 'this->' is required
233    // by the C++ standard [14.6.4] here, as the base class type is
234    // dependent on the template argument (and thus shouldn't be
235    // looked into when resolving InvokeWith).
236    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
237  }
238};
239
240template <typename R, typename A1, typename A2, typename A3, typename A4,
241    typename A5, typename A6, typename A7, typename A8>
242class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
243    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
244 public:
245  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
246  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
247
248  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
249      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
250      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
251    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
252        m6, m7, m8));
253    return this->current_spec();
254  }
255
256  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
257    // Even though gcc and MSVC don't enforce it, 'this->' is required
258    // by the C++ standard [14.6.4] here, as the base class type is
259    // dependent on the template argument (and thus shouldn't be
260    // looked into when resolving InvokeWith).
261    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
262  }
263};
264
265template <typename R, typename A1, typename A2, typename A3, typename A4,
266    typename A5, typename A6, typename A7, typename A8, typename A9>
267class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
268    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
269 public:
270  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
271  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
272
273  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
274      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
275      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
276      const Matcher<A9>& m9) {
277    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
278        m6, m7, m8, m9));
279    return this->current_spec();
280  }
281
282  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
283    // Even though gcc and MSVC don't enforce it, 'this->' is required
284    // by the C++ standard [14.6.4] here, as the base class type is
285    // dependent on the template argument (and thus shouldn't be
286    // looked into when resolving InvokeWith).
287    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
288  }
289};
290
291template <typename R, typename A1, typename A2, typename A3, typename A4,
292    typename A5, typename A6, typename A7, typename A8, typename A9,
293    typename A10>
294class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
295    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
296 public:
297  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
298  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
299
300  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
301      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
302      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
303      const Matcher<A9>& m9, const Matcher<A10>& m10) {
304    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
305        m6, m7, m8, m9, m10));
306    return this->current_spec();
307  }
308
309  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
310      A10 a10) {
311    // Even though gcc and MSVC don't enforce it, 'this->' is required
312    // by the C++ standard [14.6.4] here, as the base class type is
313    // dependent on the template argument (and thus shouldn't be
314    // looked into when resolving InvokeWith).
315    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
316        a10));
317  }
318};
319
320}  // namespace internal
321
322// The style guide prohibits "using" statements in a namespace scope
323// inside a header file.  However, the FunctionMocker class template
324// is meant to be defined in the ::testing namespace.  The following
325// line is just a trick for working around a bug in MSVC 8.0, which
326// cannot handle it if we define FunctionMocker in ::testing.
327using internal::FunctionMocker;
328
329// The result type of function type F.
330// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
331#define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result
332
333// The type of argument N of function type F.
334// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
335#define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N
336
337// The matcher type for argument N of function type F.
338// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
339#define GMOCK_MATCHER_(tn, F, N) const ::testing::Matcher<GMOCK_ARG_(tn, F, N)>&
340
341// The variable for mocking the given method.
342// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
343#define GMOCK_MOCKER_(arity, constness, Method) \
344    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
345
346// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
347#define GMOCK_METHOD0_(tn, constness, ct, Method, F) \
348  GMOCK_RESULT_(tn, F) ct Method() constness { \
349    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
350        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
351        this_method_does_not_take_0_arguments); \
352    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
353    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
354  } \
355  ::testing::MockSpec<F>& \
356      gmock_##Method() constness { \
357    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
358    return GMOCK_MOCKER_(0, constness, Method).With(); \
359  } \
360  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(0, constness, Method)
361
362// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
363#define GMOCK_METHOD1_(tn, constness, ct, Method, F) \
364  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1) constness { \
365    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
366        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
367        this_method_does_not_take_1_argument); \
368    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
369    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
370  } \
371  ::testing::MockSpec<F>& \
372      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1) constness { \
373    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
374    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
375  } \
376  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(1, constness, Method)
377
378// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
379#define GMOCK_METHOD2_(tn, constness, ct, Method, F) \
380  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
381                                 GMOCK_ARG_(tn, F, 2) gmock_a2) constness { \
382    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
383        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
384        this_method_does_not_take_2_arguments); \
385    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
386    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
387  } \
388  ::testing::MockSpec<F>& \
389      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
390                     GMOCK_MATCHER_(tn, F, 2) gmock_a2) constness { \
391    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
392    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
393  } \
394  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(2, constness, Method)
395
396// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
397#define GMOCK_METHOD3_(tn, constness, ct, Method, F) \
398  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
399                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
400                                 GMOCK_ARG_(tn, F, 3) gmock_a3) constness { \
401    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
402        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
403        this_method_does_not_take_3_arguments); \
404    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
405    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
406        gmock_a3); \
407  } \
408  ::testing::MockSpec<F>& \
409      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
410                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
411                     GMOCK_MATCHER_(tn, F, 3) gmock_a3) constness { \
412    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
413    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
414        gmock_a3); \
415  } \
416  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(3, constness, Method)
417
418// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
419#define GMOCK_METHOD4_(tn, constness, ct, Method, F) \
420  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
421                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
422                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
423                                 GMOCK_ARG_(tn, F, 4) gmock_a4) constness { \
424    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
425        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
426        this_method_does_not_take_4_arguments); \
427    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
428    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
429        gmock_a3, gmock_a4); \
430  } \
431  ::testing::MockSpec<F>& \
432      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
433                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
434                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
435                     GMOCK_MATCHER_(tn, F, 4) gmock_a4) constness { \
436    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
437    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
438        gmock_a3, gmock_a4); \
439  } \
440  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(4, constness, Method)
441
442// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
443#define GMOCK_METHOD5_(tn, constness, ct, Method, F) \
444  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
445                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
446                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
447                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
448                                 GMOCK_ARG_(tn, F, 5) gmock_a5) constness { \
449    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
450        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
451        this_method_does_not_take_5_arguments); \
452    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
453    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
454        gmock_a3, gmock_a4, gmock_a5); \
455  } \
456  ::testing::MockSpec<F>& \
457      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
458                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
459                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
460                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
461                     GMOCK_MATCHER_(tn, F, 5) gmock_a5) constness { \
462    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
463    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
464        gmock_a3, gmock_a4, gmock_a5); \
465  } \
466  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(5, constness, Method)
467
468// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
469#define GMOCK_METHOD6_(tn, constness, ct, Method, F) \
470  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
471                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
472                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
473                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
474                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
475                                 GMOCK_ARG_(tn, F, 6) gmock_a6) constness { \
476    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
477        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
478        this_method_does_not_take_6_arguments); \
479    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
480    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
481        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
482  } \
483  ::testing::MockSpec<F>& \
484      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
485                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
486                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
487                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
488                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
489                     GMOCK_MATCHER_(tn, F, 6) gmock_a6) constness { \
490    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
491    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
492        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
493  } \
494  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(6, constness, Method)
495
496// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
497#define GMOCK_METHOD7_(tn, constness, ct, Method, F) \
498  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
499                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
500                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
501                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
502                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
503                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
504                                 GMOCK_ARG_(tn, F, 7) gmock_a7) constness { \
505    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
506        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
507        this_method_does_not_take_7_arguments); \
508    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
509    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
510        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
511  } \
512  ::testing::MockSpec<F>& \
513      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
514                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
515                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
516                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
517                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
518                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
519                     GMOCK_MATCHER_(tn, F, 7) gmock_a7) constness { \
520    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
521    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
522        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
523  } \
524  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(7, constness, Method)
525
526// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
527#define GMOCK_METHOD8_(tn, constness, ct, Method, F) \
528  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
529                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
530                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
531                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
532                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
533                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
534                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
535                                 GMOCK_ARG_(tn, F, 8) gmock_a8) constness { \
536    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
537        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
538        this_method_does_not_take_8_arguments); \
539    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
540    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
541        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
542  } \
543  ::testing::MockSpec<F>& \
544      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
545                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
546                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
547                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
548                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
549                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
550                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
551                     GMOCK_MATCHER_(tn, F, 8) gmock_a8) constness { \
552    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
553    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
554        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
555  } \
556  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(8, constness, Method)
557
558// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
559#define GMOCK_METHOD9_(tn, constness, ct, Method, F) \
560  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
561                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
562                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
563                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
564                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
565                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
566                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
567                                 GMOCK_ARG_(tn, F, 8) gmock_a8, \
568                                 GMOCK_ARG_(tn, F, 9) gmock_a9) constness { \
569    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
570        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
571        this_method_does_not_take_9_arguments); \
572    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
573    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
574        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
575        gmock_a9); \
576  } \
577  ::testing::MockSpec<F>& \
578      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
579                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
580                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
581                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
582                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
583                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
584                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
585                     GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
586                     GMOCK_MATCHER_(tn, F, 9) gmock_a9) constness { \
587    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
588    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
589        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
590        gmock_a9); \
591  } \
592  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(9, constness, Method)
593
594// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
595#define GMOCK_METHOD10_(tn, constness, ct, Method, F) \
596  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
597                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
598                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
599                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
600                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
601                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
602                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
603                                 GMOCK_ARG_(tn, F, 8) gmock_a8, \
604                                 GMOCK_ARG_(tn, F, 9) gmock_a9, \
605                                 GMOCK_ARG_(tn, F, 10) gmock_a10) constness { \
606    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
607        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
608        this_method_does_not_take_10_arguments); \
609    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
610    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
611        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
612        gmock_a10); \
613  } \
614  ::testing::MockSpec<F>& \
615      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
616                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
617                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
618                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
619                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
620                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
621                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
622                     GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
623                     GMOCK_MATCHER_(tn, F, 9) gmock_a9, \
624                     GMOCK_MATCHER_(tn, F, 10) gmock_a10) constness { \
625    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
626    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
627        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
628        gmock_a10); \
629  } \
630  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(10, constness, Method)
631
632#define MOCK_METHOD0(m, F) GMOCK_METHOD0_(, , , m, F)
633#define MOCK_METHOD1(m, F) GMOCK_METHOD1_(, , , m, F)
634#define MOCK_METHOD2(m, F) GMOCK_METHOD2_(, , , m, F)
635#define MOCK_METHOD3(m, F) GMOCK_METHOD3_(, , , m, F)
636#define MOCK_METHOD4(m, F) GMOCK_METHOD4_(, , , m, F)
637#define MOCK_METHOD5(m, F) GMOCK_METHOD5_(, , , m, F)
638#define MOCK_METHOD6(m, F) GMOCK_METHOD6_(, , , m, F)
639#define MOCK_METHOD7(m, F) GMOCK_METHOD7_(, , , m, F)
640#define MOCK_METHOD8(m, F) GMOCK_METHOD8_(, , , m, F)
641#define MOCK_METHOD9(m, F) GMOCK_METHOD9_(, , , m, F)
642#define MOCK_METHOD10(m, F) GMOCK_METHOD10_(, , , m, F)
643
644#define MOCK_CONST_METHOD0(m, F) GMOCK_METHOD0_(, const, , m, F)
645#define MOCK_CONST_METHOD1(m, F) GMOCK_METHOD1_(, const, , m, F)
646#define MOCK_CONST_METHOD2(m, F) GMOCK_METHOD2_(, const, , m, F)
647#define MOCK_CONST_METHOD3(m, F) GMOCK_METHOD3_(, const, , m, F)
648#define MOCK_CONST_METHOD4(m, F) GMOCK_METHOD4_(, const, , m, F)
649#define MOCK_CONST_METHOD5(m, F) GMOCK_METHOD5_(, const, , m, F)
650#define MOCK_CONST_METHOD6(m, F) GMOCK_METHOD6_(, const, , m, F)
651#define MOCK_CONST_METHOD7(m, F) GMOCK_METHOD7_(, const, , m, F)
652#define MOCK_CONST_METHOD8(m, F) GMOCK_METHOD8_(, const, , m, F)
653#define MOCK_CONST_METHOD9(m, F) GMOCK_METHOD9_(, const, , m, F)
654#define MOCK_CONST_METHOD10(m, F) GMOCK_METHOD10_(, const, , m, F)
655
656#define MOCK_METHOD0_T(m, F) GMOCK_METHOD0_(typename, , , m, F)
657#define MOCK_METHOD1_T(m, F) GMOCK_METHOD1_(typename, , , m, F)
658#define MOCK_METHOD2_T(m, F) GMOCK_METHOD2_(typename, , , m, F)
659#define MOCK_METHOD3_T(m, F) GMOCK_METHOD3_(typename, , , m, F)
660#define MOCK_METHOD4_T(m, F) GMOCK_METHOD4_(typename, , , m, F)
661#define MOCK_METHOD5_T(m, F) GMOCK_METHOD5_(typename, , , m, F)
662#define MOCK_METHOD6_T(m, F) GMOCK_METHOD6_(typename, , , m, F)
663#define MOCK_METHOD7_T(m, F) GMOCK_METHOD7_(typename, , , m, F)
664#define MOCK_METHOD8_T(m, F) GMOCK_METHOD8_(typename, , , m, F)
665#define MOCK_METHOD9_T(m, F) GMOCK_METHOD9_(typename, , , m, F)
666#define MOCK_METHOD10_T(m, F) GMOCK_METHOD10_(typename, , , m, F)
667
668#define MOCK_CONST_METHOD0_T(m, F) GMOCK_METHOD0_(typename, const, , m, F)
669#define MOCK_CONST_METHOD1_T(m, F) GMOCK_METHOD1_(typename, const, , m, F)
670#define MOCK_CONST_METHOD2_T(m, F) GMOCK_METHOD2_(typename, const, , m, F)
671#define MOCK_CONST_METHOD3_T(m, F) GMOCK_METHOD3_(typename, const, , m, F)
672#define MOCK_CONST_METHOD4_T(m, F) GMOCK_METHOD4_(typename, const, , m, F)
673#define MOCK_CONST_METHOD5_T(m, F) GMOCK_METHOD5_(typename, const, , m, F)
674#define MOCK_CONST_METHOD6_T(m, F) GMOCK_METHOD6_(typename, const, , m, F)
675#define MOCK_CONST_METHOD7_T(m, F) GMOCK_METHOD7_(typename, const, , m, F)
676#define MOCK_CONST_METHOD8_T(m, F) GMOCK_METHOD8_(typename, const, , m, F)
677#define MOCK_CONST_METHOD9_T(m, F) GMOCK_METHOD9_(typename, const, , m, F)
678#define MOCK_CONST_METHOD10_T(m, F) GMOCK_METHOD10_(typename, const, , m, F)
679
680#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD0_(, , ct, m, F)
681#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD1_(, , ct, m, F)
682#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD2_(, , ct, m, F)
683#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD3_(, , ct, m, F)
684#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD4_(, , ct, m, F)
685#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD5_(, , ct, m, F)
686#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD6_(, , ct, m, F)
687#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD7_(, , ct, m, F)
688#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD8_(, , ct, m, F)
689#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD9_(, , ct, m, F)
690#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD10_(, , ct, m, F)
691
692#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, F) \
693    GMOCK_METHOD0_(, const, ct, m, F)
694#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, F) \
695    GMOCK_METHOD1_(, const, ct, m, F)
696#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, F) \
697    GMOCK_METHOD2_(, const, ct, m, F)
698#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, F) \
699    GMOCK_METHOD3_(, const, ct, m, F)
700#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, F) \
701    GMOCK_METHOD4_(, const, ct, m, F)
702#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, F) \
703    GMOCK_METHOD5_(, const, ct, m, F)
704#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, F) \
705    GMOCK_METHOD6_(, const, ct, m, F)
706#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, F) \
707    GMOCK_METHOD7_(, const, ct, m, F)
708#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, F) \
709    GMOCK_METHOD8_(, const, ct, m, F)
710#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, F) \
711    GMOCK_METHOD9_(, const, ct, m, F)
712#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, F) \
713    GMOCK_METHOD10_(, const, ct, m, F)
714
715#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, F) \
716    GMOCK_METHOD0_(typename, , ct, m, F)
717#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, F) \
718    GMOCK_METHOD1_(typename, , ct, m, F)
719#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, F) \
720    GMOCK_METHOD2_(typename, , ct, m, F)
721#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, F) \
722    GMOCK_METHOD3_(typename, , ct, m, F)
723#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, F) \
724    GMOCK_METHOD4_(typename, , ct, m, F)
725#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, F) \
726    GMOCK_METHOD5_(typename, , ct, m, F)
727#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, F) \
728    GMOCK_METHOD6_(typename, , ct, m, F)
729#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, F) \
730    GMOCK_METHOD7_(typename, , ct, m, F)
731#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, F) \
732    GMOCK_METHOD8_(typename, , ct, m, F)
733#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, F) \
734    GMOCK_METHOD9_(typename, , ct, m, F)
735#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, F) \
736    GMOCK_METHOD10_(typename, , ct, m, F)
737
738#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, F) \
739    GMOCK_METHOD0_(typename, const, ct, m, F)
740#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, F) \
741    GMOCK_METHOD1_(typename, const, ct, m, F)
742#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, F) \
743    GMOCK_METHOD2_(typename, const, ct, m, F)
744#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, F) \
745    GMOCK_METHOD3_(typename, const, ct, m, F)
746#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, F) \
747    GMOCK_METHOD4_(typename, const, ct, m, F)
748#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, F) \
749    GMOCK_METHOD5_(typename, const, ct, m, F)
750#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, F) \
751    GMOCK_METHOD6_(typename, const, ct, m, F)
752#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, F) \
753    GMOCK_METHOD7_(typename, const, ct, m, F)
754#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, F) \
755    GMOCK_METHOD8_(typename, const, ct, m, F)
756#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, F) \
757    GMOCK_METHOD9_(typename, const, ct, m, F)
758#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, F) \
759    GMOCK_METHOD10_(typename, const, ct, m, F)
760
761// A MockFunction<F> class has one mock method whose type is F.  It is
762// useful when you just want your test code to emit some messages and
763// have Google Mock verify the right messages are sent (and perhaps at
764// the right times).  For example, if you are exercising code:
765//
766//   Foo(1);
767//   Foo(2);
768//   Foo(3);
769//
770// and want to verify that Foo(1) and Foo(3) both invoke
771// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
772//
773// TEST(FooTest, InvokesBarCorrectly) {
774//   MyMock mock;
775//   MockFunction<void(string check_point_name)> check;
776//   {
777//     InSequence s;
778//
779//     EXPECT_CALL(mock, Bar("a"));
780//     EXPECT_CALL(check, Call("1"));
781//     EXPECT_CALL(check, Call("2"));
782//     EXPECT_CALL(mock, Bar("a"));
783//   }
784//   Foo(1);
785//   check.Call("1");
786//   Foo(2);
787//   check.Call("2");
788//   Foo(3);
789// }
790//
791// The expectation spec says that the first Bar("a") must happen
792// before check point "1", the second Bar("a") must happen after check
793// point "2", and nothing should happen between the two check
794// points. The explicit check points make it easy to tell which
795// Bar("a") is called by which call to Foo().
796template <typename F>
797class MockFunction;
798
799template <typename R>
800class MockFunction<R()> {
801 public:
802  MockFunction() {}
803
804  MOCK_METHOD0_T(Call, R());
805
806 private:
807  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
808};
809
810template <typename R, typename A0>
811class MockFunction<R(A0)> {
812 public:
813  MockFunction() {}
814
815  MOCK_METHOD1_T(Call, R(A0));
816
817 private:
818  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
819};
820
821template <typename R, typename A0, typename A1>
822class MockFunction<R(A0, A1)> {
823 public:
824  MockFunction() {}
825
826  MOCK_METHOD2_T(Call, R(A0, A1));
827
828 private:
829  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
830};
831
832template <typename R, typename A0, typename A1, typename A2>
833class MockFunction<R(A0, A1, A2)> {
834 public:
835  MockFunction() {}
836
837  MOCK_METHOD3_T(Call, R(A0, A1, A2));
838
839 private:
840  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
841};
842
843template <typename R, typename A0, typename A1, typename A2, typename A3>
844class MockFunction<R(A0, A1, A2, A3)> {
845 public:
846  MockFunction() {}
847
848  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
849
850 private:
851  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
852};
853
854template <typename R, typename A0, typename A1, typename A2, typename A3,
855    typename A4>
856class MockFunction<R(A0, A1, A2, A3, A4)> {
857 public:
858  MockFunction() {}
859
860  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
861
862 private:
863  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
864};
865
866template <typename R, typename A0, typename A1, typename A2, typename A3,
867    typename A4, typename A5>
868class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
869 public:
870  MockFunction() {}
871
872  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
873
874 private:
875  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
876};
877
878template <typename R, typename A0, typename A1, typename A2, typename A3,
879    typename A4, typename A5, typename A6>
880class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
881 public:
882  MockFunction() {}
883
884  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
885
886 private:
887  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
888};
889
890template <typename R, typename A0, typename A1, typename A2, typename A3,
891    typename A4, typename A5, typename A6, typename A7>
892class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
893 public:
894  MockFunction() {}
895
896  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
897
898 private:
899  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
900};
901
902template <typename R, typename A0, typename A1, typename A2, typename A3,
903    typename A4, typename A5, typename A6, typename A7, typename A8>
904class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
905 public:
906  MockFunction() {}
907
908  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
909
910 private:
911  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
912};
913
914template <typename R, typename A0, typename A1, typename A2, typename A3,
915    typename A4, typename A5, typename A6, typename A7, typename A8,
916    typename A9>
917class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
918 public:
919  MockFunction() {}
920
921  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
922
923 private:
924  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
925};
926
927}  // namespace testing
928
929#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_