gmock-generated-function-mockers.h 40 KB
Newer Older
1
2
3
// This file was GENERATED by command:
//     pump.py gmock-generated-function-mockers.h.pump
// DO NOT EDIT BY HAND!!!
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)

// Google Mock - a framework for writing C++ mock classes.
//
// This file implements function mockers of various arities.

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_

43
44
#include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-internal-utils.h"
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

namespace testing {
namespace internal {

template <typename F>
class FunctionMockerBase;

// Note: class FunctionMocker really belongs to the ::testing
// namespace.  However if we define it in ::testing, MSVC will
// complain when classes in ::testing::internal declare it as a
// friend class template.  To workaround this compiler bug, we define
// FunctionMocker in ::testing::internal and import it into ::testing.
template <typename F>
class FunctionMocker;

template <typename R>
class FunctionMocker<R()> : public
    internal::FunctionMockerBase<R()> {
 public:
  typedef R F();
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With() {
    return this->current_spec();
  }

  R Invoke() {
72
73
74
75
76
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple());
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
  }
};

template <typename R, typename A1>
class FunctionMocker<R(A1)> : public
    internal::FunctionMockerBase<R(A1)> {
 public:
  typedef R F(A1);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1));
    return this->current_spec();
  }

  R Invoke(A1 a1) {
93
94
95
96
97
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1));
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
  }
};

template <typename R, typename A1, typename A2>
class FunctionMocker<R(A1, A2)> : public
    internal::FunctionMockerBase<R(A1, A2)> {
 public:
  typedef R F(A1, A2);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2) {
114
115
116
117
118
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2));
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
  }
};

template <typename R, typename A1, typename A2, typename A3>
class FunctionMocker<R(A1, A2, A3)> : public
    internal::FunctionMockerBase<R(A1, A2, A3)> {
 public:
  typedef R F(A1, A2, A3);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3) {
136
137
138
139
140
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3));
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4>
class FunctionMocker<R(A1, A2, A3, A4)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4)> {
 public:
  typedef R F(A1, A2, A3, A4);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) {
158
159
160
161
162
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4));
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5>
class FunctionMocker<R(A1, A2, A3, A4, A5)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> {
 public:
  typedef R F(A1, A2, A3, A4, A5);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4,
        m5));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
182
183
184
185
186
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5));
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5, typename A6>
class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> {
 public:
  typedef R F(A1, A2, A3, A4, A5, A6);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
      const Matcher<A6>& m6) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
        m6));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
207
208
209
210
211
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6));
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5, typename A6, typename A7>
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> {
 public:
  typedef R F(A1, A2, A3, A4, A5, A6, A7);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
      const Matcher<A6>& m6, const Matcher<A7>& m7) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
        m6, m7));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
232
233
234
235
236
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7));
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5, typename A6, typename A7, typename A8>
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
 public:
  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
        m6, m7, m8));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
257
258
259
260
261
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8));
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5, typename A6, typename A7, typename A8, typename A9>
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
 public:
  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
      const Matcher<A9>& m9) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
        m6, m7, m8, m9));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
283
284
285
286
287
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9));
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
  }
};

template <typename R, typename A1, typename A2, typename A3, typename A4,
    typename A5, typename A6, typename A7, typename A8, typename A9,
    typename A10>
class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public
    internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> {
 public:
  typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2,
      const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5,
      const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8,
      const Matcher<A9>& m9, const Matcher<A10>& m10) {
    this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5,
        m6, m7, m8, m9, m10));
    return this->current_spec();
  }

  R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
      A10 a10) {
311
312
313
314
315
316
    // Even though gcc and MSVC don't enforce it, 'this->' is required
    // by the C++ standard [14.6.4] here, as the base class type is
    // dependent on the template argument (and thus shouldn't be
    // looked into when resolving InvokeWith).
    return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9,
        a10));
317
318
319
320
321
322
323
324
325
326
327
328
329
330
  }
};

}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope
// inside a header file.  However, the FunctionMocker class template
// is meant to be defined in the ::testing namespace.  The following
// line is just a trick for working around a bug in MSVC 8.0, which
// cannot handle it if we define FunctionMocker in ::testing.
using internal::FunctionMocker;

// The result type of function type F.
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
331
#define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result
332
333
334

// The type of argument N of function type F.
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
335
#define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N
336
337
338

// The matcher type for argument N of function type F.
// 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
342

// The variable for mocking the given method.
// 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
348
#define GMOCK_METHOD0_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method() constness { \
349
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
350
351
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
        this_method_does_not_take_0_arguments); \
352
353
    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
354
355
356
  } \
  ::testing::MockSpec<F>& \
      gmock_##Method() constness { \
357
358
    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
    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
364
#define GMOCK_METHOD1_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1) constness { \
365
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
366
367
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
        this_method_does_not_take_1_argument); \
368
369
    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
    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
374
    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
    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
380
381
#define GMOCK_METHOD2_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2) constness { \
382
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
383
384
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
        this_method_does_not_take_2_arguments); \
385
386
    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
387
388
  } \
  ::testing::MockSpec<F>& \
389
390
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2) constness { \
391
392
    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
    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
398
399
400
#define GMOCK_METHOD3_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3) constness { \
401
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
402
403
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
        this_method_does_not_take_3_arguments); \
404
405
406
    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3); \
407
408
  } \
  ::testing::MockSpec<F>& \
409
410
411
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3) constness { \
412
413
414
    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
        gmock_a3); \
415
  } \
416
  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(3, constness, Method)
417
418

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
419
420
421
422
423
#define GMOCK_METHOD4_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4) constness { \
424
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
425
426
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
        this_method_does_not_take_4_arguments); \
427
428
429
    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4); \
430
431
  } \
  ::testing::MockSpec<F>& \
432
433
434
435
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4) constness { \
436
437
438
    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
        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
444
445
446
447
448
#define GMOCK_METHOD5_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5) constness { \
449
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
450
451
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
        this_method_does_not_take_5_arguments); \
452
453
454
    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5); \
455
456
  } \
  ::testing::MockSpec<F>& \
457
458
459
460
461
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5) constness { \
462
463
464
    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
        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
470
471
472
473
474
475
#define GMOCK_METHOD6_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                 GMOCK_ARG_(tn, F, 6) gmock_a6) constness { \
476
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
477
478
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
        this_method_does_not_take_6_arguments); \
479
480
481
    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
482
483
  } \
  ::testing::MockSpec<F>& \
484
485
486
487
488
489
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
                     GMOCK_MATCHER_(tn, F, 6) gmock_a6) constness { \
490
491
492
    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
        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
498
499
500
501
502
503
504
#define GMOCK_METHOD7_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                 GMOCK_ARG_(tn, F, 7) gmock_a7) constness { \
505
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
506
507
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
        this_method_does_not_take_7_arguments); \
508
509
510
    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
511
512
  } \
  ::testing::MockSpec<F>& \
513
514
515
516
517
518
519
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
                     GMOCK_MATCHER_(tn, F, 7) gmock_a7) constness { \
520
521
522
    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
        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
528
529
530
531
532
533
534
535
#define GMOCK_METHOD8_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
                                 GMOCK_ARG_(tn, F, 8) gmock_a8) constness { \
536
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
537
538
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
        this_method_does_not_take_8_arguments); \
539
540
541
    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
542
543
  } \
  ::testing::MockSpec<F>& \
544
545
546
547
548
549
550
551
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
                     GMOCK_MATCHER_(tn, F, 8) gmock_a8) constness { \
552
553
554
    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
        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
560
561
562
563
564
565
566
567
568
#define GMOCK_METHOD9_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
                                 GMOCK_ARG_(tn, F, 8) gmock_a8, \
                                 GMOCK_ARG_(tn, F, 9) gmock_a9) constness { \
569
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
570
571
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
        this_method_does_not_take_9_arguments); \
572
573
574
575
    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
        gmock_a9); \
576
577
  } \
  ::testing::MockSpec<F>& \
578
579
580
581
582
583
584
585
586
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
                     GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
                     GMOCK_MATCHER_(tn, F, 9) gmock_a9) constness { \
587
588
589
590
    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
        gmock_a9); \
591
  } \
592
  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(9, constness, Method)
593
594

// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
595
596
597
598
599
600
601
602
603
604
605
#define GMOCK_METHOD10_(tn, constness, ct, Method, F) \
  GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                 GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                 GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                 GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                 GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                 GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                 GMOCK_ARG_(tn, F, 7) gmock_a7, \
                                 GMOCK_ARG_(tn, F, 8) gmock_a8, \
                                 GMOCK_ARG_(tn, F, 9) gmock_a9, \
                                 GMOCK_ARG_(tn, F, 10) gmock_a10) constness { \
606
    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
607
608
        tn ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
        this_method_does_not_take_10_arguments); \
609
610
611
    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
612
613
614
        gmock_a10); \
  } \
  ::testing::MockSpec<F>& \
615
616
617
618
619
620
621
622
623
624
      gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \
                     GMOCK_MATCHER_(tn, F, 2) gmock_a2, \
                     GMOCK_MATCHER_(tn, F, 3) gmock_a3, \
                     GMOCK_MATCHER_(tn, F, 4) gmock_a4, \
                     GMOCK_MATCHER_(tn, F, 5) gmock_a5, \
                     GMOCK_MATCHER_(tn, F, 6) gmock_a6, \
                     GMOCK_MATCHER_(tn, F, 7) gmock_a7, \
                     GMOCK_MATCHER_(tn, F, 8) gmock_a8, \
                     GMOCK_MATCHER_(tn, F, 9) gmock_a9, \
                     GMOCK_MATCHER_(tn, F, 10) gmock_a10) constness { \
625
626
627
    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
628
629
        gmock_a10); \
  } \
630
  mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(10, constness, Method)
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690

#define MOCK_METHOD0(m, F) GMOCK_METHOD0_(, , , m, F)
#define MOCK_METHOD1(m, F) GMOCK_METHOD1_(, , , m, F)
#define MOCK_METHOD2(m, F) GMOCK_METHOD2_(, , , m, F)
#define MOCK_METHOD3(m, F) GMOCK_METHOD3_(, , , m, F)
#define MOCK_METHOD4(m, F) GMOCK_METHOD4_(, , , m, F)
#define MOCK_METHOD5(m, F) GMOCK_METHOD5_(, , , m, F)
#define MOCK_METHOD6(m, F) GMOCK_METHOD6_(, , , m, F)
#define MOCK_METHOD7(m, F) GMOCK_METHOD7_(, , , m, F)
#define MOCK_METHOD8(m, F) GMOCK_METHOD8_(, , , m, F)
#define MOCK_METHOD9(m, F) GMOCK_METHOD9_(, , , m, F)
#define MOCK_METHOD10(m, F) GMOCK_METHOD10_(, , , m, F)

#define MOCK_CONST_METHOD0(m, F) GMOCK_METHOD0_(, const, , m, F)
#define MOCK_CONST_METHOD1(m, F) GMOCK_METHOD1_(, const, , m, F)
#define MOCK_CONST_METHOD2(m, F) GMOCK_METHOD2_(, const, , m, F)
#define MOCK_CONST_METHOD3(m, F) GMOCK_METHOD3_(, const, , m, F)
#define MOCK_CONST_METHOD4(m, F) GMOCK_METHOD4_(, const, , m, F)
#define MOCK_CONST_METHOD5(m, F) GMOCK_METHOD5_(, const, , m, F)
#define MOCK_CONST_METHOD6(m, F) GMOCK_METHOD6_(, const, , m, F)
#define MOCK_CONST_METHOD7(m, F) GMOCK_METHOD7_(, const, , m, F)
#define MOCK_CONST_METHOD8(m, F) GMOCK_METHOD8_(, const, , m, F)
#define MOCK_CONST_METHOD9(m, F) GMOCK_METHOD9_(, const, , m, F)
#define MOCK_CONST_METHOD10(m, F) GMOCK_METHOD10_(, const, , m, F)

#define MOCK_METHOD0_T(m, F) GMOCK_METHOD0_(typename, , , m, F)
#define MOCK_METHOD1_T(m, F) GMOCK_METHOD1_(typename, , , m, F)
#define MOCK_METHOD2_T(m, F) GMOCK_METHOD2_(typename, , , m, F)
#define MOCK_METHOD3_T(m, F) GMOCK_METHOD3_(typename, , , m, F)
#define MOCK_METHOD4_T(m, F) GMOCK_METHOD4_(typename, , , m, F)
#define MOCK_METHOD5_T(m, F) GMOCK_METHOD5_(typename, , , m, F)
#define MOCK_METHOD6_T(m, F) GMOCK_METHOD6_(typename, , , m, F)
#define MOCK_METHOD7_T(m, F) GMOCK_METHOD7_(typename, , , m, F)
#define MOCK_METHOD8_T(m, F) GMOCK_METHOD8_(typename, , , m, F)
#define MOCK_METHOD9_T(m, F) GMOCK_METHOD9_(typename, , , m, F)
#define MOCK_METHOD10_T(m, F) GMOCK_METHOD10_(typename, , , m, F)

#define MOCK_CONST_METHOD0_T(m, F) GMOCK_METHOD0_(typename, const, , m, F)
#define MOCK_CONST_METHOD1_T(m, F) GMOCK_METHOD1_(typename, const, , m, F)
#define MOCK_CONST_METHOD2_T(m, F) GMOCK_METHOD2_(typename, const, , m, F)
#define MOCK_CONST_METHOD3_T(m, F) GMOCK_METHOD3_(typename, const, , m, F)
#define MOCK_CONST_METHOD4_T(m, F) GMOCK_METHOD4_(typename, const, , m, F)
#define MOCK_CONST_METHOD5_T(m, F) GMOCK_METHOD5_(typename, const, , m, F)
#define MOCK_CONST_METHOD6_T(m, F) GMOCK_METHOD6_(typename, const, , m, F)
#define MOCK_CONST_METHOD7_T(m, F) GMOCK_METHOD7_(typename, const, , m, F)
#define MOCK_CONST_METHOD8_T(m, F) GMOCK_METHOD8_(typename, const, , m, F)
#define MOCK_CONST_METHOD9_T(m, F) GMOCK_METHOD9_(typename, const, , m, F)
#define MOCK_CONST_METHOD10_T(m, F) GMOCK_METHOD10_(typename, const, , m, F)

#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD0_(, , ct, m, F)
#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD1_(, , ct, m, F)
#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD2_(, , ct, m, F)
#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD3_(, , ct, m, F)
#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD4_(, , ct, m, F)
#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD5_(, , ct, m, F)
#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD6_(, , ct, m, F)
#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD7_(, , ct, m, F)
#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD8_(, , ct, m, F)
#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD9_(, , ct, m, F)
#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
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
// A MockFunction<F> class has one mock method whose type is F.  It is
// useful when you just want your test code to emit some messages and
// have Google Mock verify the right messages are sent (and perhaps at
// the right times).  For example, if you are exercising code:
//
//   Foo(1);
//   Foo(2);
//   Foo(3);
//
// and want to verify that Foo(1) and Foo(3) both invoke
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
//
// TEST(FooTest, InvokesBarCorrectly) {
//   MyMock mock;
//   MockFunction<void(string check_point_name)> check;
//   {
//     InSequence s;
//
//     EXPECT_CALL(mock, Bar("a"));
//     EXPECT_CALL(check, Call("1"));
//     EXPECT_CALL(check, Call("2"));
//     EXPECT_CALL(mock, Bar("a"));
//   }
//   Foo(1);
//   check.Call("1");
//   Foo(2);
//   check.Call("2");
//   Foo(3);
// }
//
// The expectation spec says that the first Bar("a") must happen
// before check point "1", the second Bar("a") must happen after check
// point "2", and nothing should happen between the two check
// points. The explicit check points make it easy to tell which
// Bar("a") is called by which call to Foo().
template <typename F>
class MockFunction;

template <typename R>
class MockFunction<R()> {
 public:
802
803
  MockFunction() {}

804
  MOCK_METHOD0_T(Call, R());
805
806
807

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
808
809
810
811
812
};

template <typename R, typename A0>
class MockFunction<R(A0)> {
 public:
813
814
  MockFunction() {}

815
  MOCK_METHOD1_T(Call, R(A0));
816
817
818

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
819
820
821
822
823
};

template <typename R, typename A0, typename A1>
class MockFunction<R(A0, A1)> {
 public:
824
825
  MockFunction() {}

826
  MOCK_METHOD2_T(Call, R(A0, A1));
827
828
829

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
830
831
832
833
834
};

template <typename R, typename A0, typename A1, typename A2>
class MockFunction<R(A0, A1, A2)> {
 public:
835
836
  MockFunction() {}

837
  MOCK_METHOD3_T(Call, R(A0, A1, A2));
838
839
840

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
841
842
843
844
845
};

template <typename R, typename A0, typename A1, typename A2, typename A3>
class MockFunction<R(A0, A1, A2, A3)> {
 public:
846
847
  MockFunction() {}

848
  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
849
850
851

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
852
853
854
855
856
857
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4>
class MockFunction<R(A0, A1, A2, A3, A4)> {
 public:
858
859
  MockFunction() {}

860
  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
861
862
863

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
864
865
866
867
868
869
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4, typename A5>
class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
 public:
870
871
  MockFunction() {}

872
  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
873
874
875

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
876
877
878
879
880
881
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4, typename A5, typename A6>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
 public:
882
883
  MockFunction() {}

884
  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
885
886
887

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
888
889
890
891
892
893
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4, typename A5, typename A6, typename A7>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
 public:
894
895
  MockFunction() {}

896
  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
897
898
899

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
900
901
902
903
904
905
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4, typename A5, typename A6, typename A7, typename A8>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
 public:
906
907
  MockFunction() {}

908
  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
909
910
911

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
912
913
914
915
916
917
918
};

template <typename R, typename A0, typename A1, typename A2, typename A3,
    typename A4, typename A5, typename A6, typename A7, typename A8,
    typename A9>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
 public:
919
920
  MockFunction() {}

921
  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
922
923
924

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
925
926
};

927
928
929
}  // namespace testing

#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_