← Back to branch summary

~raof/mir/symbols-file

« back to all changes in this revision

Viewing changes to 3rd_party/gmock/include/gmock/gmock-generated-function-mockers.h

  • Committer: Tarmac
  • Author(s): Kevin DuBois
  • Date: 2013-07-12 06:12:08 UTC
  • mfrom: (835.4.12 rm-internal-gmock)
  • Revision ID: tarmac-20130712061208-axrnr0n8xgjgexhz
remove google mock from the internal source tree. Rather, use the google-mock package and build the source externally. Fixes: https://bugs.launchpad.net/bugs/1185265, https://bugs.launchpad.net/bugs/1194017.

Approved by Didier Roche, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/gmock/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
 
// 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
 
 
46
 
namespace testing {
47
 
namespace internal {
48
 
 
49
 
template <typename F>
50
 
class 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.
57
 
template <typename F>
58
 
class FunctionMocker;
59
 
 
60
 
template <typename R>
61
 
class 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
 
 
80
 
template <typename R, typename A1>
81
 
class 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
 
 
101
 
template <typename R, typename A1, typename A2>
102
 
class 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
 
 
122
 
template <typename R, typename A1, typename A2, typename A3>
123
 
class 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
 
 
144
 
template <typename R, typename A1, typename A2, typename A3, typename A4>
145
 
class 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
 
 
166
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
167
 
    typename A5>
168
 
class 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
 
 
190
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
191
 
    typename A5, typename A6>
192
 
class 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
 
 
215
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
216
 
    typename A5, typename A6, typename A7>
217
 
class 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
 
 
240
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
241
 
    typename A5, typename A6, typename A7, typename A8>
242
 
class 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
 
 
265
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
266
 
    typename A5, typename A6, typename A7, typename A8, typename A9>
267
 
class 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
 
 
291
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
292
 
    typename A5, typename A6, typename A7, typename A8, typename A9,
293
 
    typename A10>
294
 
class 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.
327
 
using internal::FunctionMocker;
328
 
 
329
 
// GMOCK_RESULT_(tn, F) expands to the result type of function type F.
330
 
// We define this as a variadic macro in case F contains unprotected
331
 
// commas (the same reason that we use variadic macros in other places
332
 
// in this file).
333
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
334
 
#define GMOCK_RESULT_(tn, ...) \
335
 
    tn ::testing::internal::Function<__VA_ARGS__>::Result
336
 
 
337
 
// The type of argument N of the given function type.
338
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
339
 
#define GMOCK_ARG_(tn, N, ...) \
340
 
    tn ::testing::internal::Function<__VA_ARGS__>::Argument##N
341
 
 
342
 
// The matcher type for argument N of the given function type.
343
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
344
 
#define GMOCK_MATCHER_(tn, N, ...) \
345
 
    const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>&
346
 
 
347
 
// The variable for mocking the given method.
348
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
349
 
#define GMOCK_MOCKER_(arity, constness, Method) \
350
 
    GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
351
 
 
352
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
353
 
#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \
354
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
355
 
      ) constness { \
356
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
357
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
358
 
            == 0), \
359
 
        this_method_does_not_take_0_arguments); \
360
 
    GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
361
 
    return GMOCK_MOCKER_(0, constness, Method).Invoke(); \
362
 
  } \
363
 
  ::testing::MockSpec<__VA_ARGS__>& \
364
 
      gmock_##Method() constness { \
365
 
    GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \
366
 
    return GMOCK_MOCKER_(0, constness, Method).With(); \
367
 
  } \
368
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \
369
 
      Method)
370
 
 
371
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
372
 
#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \
373
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
374
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
375
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
376
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
377
 
            == 1), \
378
 
        this_method_does_not_take_1_argument); \
379
 
    GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
380
 
    return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \
381
 
  } \
382
 
  ::testing::MockSpec<__VA_ARGS__>& \
383
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \
384
 
    GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \
385
 
    return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \
386
 
  } \
387
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \
388
 
      Method)
389
 
 
390
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
391
 
#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \
392
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
393
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
394
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
395
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
396
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
397
 
            == 2), \
398
 
        this_method_does_not_take_2_arguments); \
399
 
    GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
400
 
    return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \
401
 
  } \
402
 
  ::testing::MockSpec<__VA_ARGS__>& \
403
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
404
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \
405
 
    GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \
406
 
    return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \
407
 
  } \
408
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \
409
 
      Method)
410
 
 
411
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
412
 
#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \
413
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
414
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
415
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
416
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
417
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
418
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
419
 
            == 3), \
420
 
        this_method_does_not_take_3_arguments); \
421
 
    GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
422
 
    return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \
423
 
        gmock_a3); \
424
 
  } \
425
 
  ::testing::MockSpec<__VA_ARGS__>& \
426
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
427
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
428
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \
429
 
    GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \
430
 
    return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \
431
 
        gmock_a3); \
432
 
  } \
433
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \
434
 
      Method)
435
 
 
436
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
437
 
#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \
438
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
439
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
440
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
441
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
442
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
443
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
444
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
445
 
            == 4), \
446
 
        this_method_does_not_take_4_arguments); \
447
 
    GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
448
 
    return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \
449
 
        gmock_a3, gmock_a4); \
450
 
  } \
451
 
  ::testing::MockSpec<__VA_ARGS__>& \
452
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
453
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
454
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
455
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \
456
 
    GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \
457
 
    return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \
458
 
        gmock_a3, gmock_a4); \
459
 
  } \
460
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \
461
 
      Method)
462
 
 
463
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
464
 
#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \
465
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
466
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
467
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
468
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
469
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
470
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
471
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
472
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
473
 
            == 5), \
474
 
        this_method_does_not_take_5_arguments); \
475
 
    GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
476
 
    return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \
477
 
        gmock_a3, gmock_a4, gmock_a5); \
478
 
  } \
479
 
  ::testing::MockSpec<__VA_ARGS__>& \
480
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
481
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
482
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
483
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
484
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \
485
 
    GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \
486
 
    return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \
487
 
        gmock_a3, gmock_a4, gmock_a5); \
488
 
  } \
489
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \
490
 
      Method)
491
 
 
492
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
493
 
#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \
494
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
495
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
496
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
497
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
498
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
499
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
500
 
      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
501
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
502
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
503
 
            == 6), \
504
 
        this_method_does_not_take_6_arguments); \
505
 
    GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
506
 
    return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \
507
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
508
 
  } \
509
 
  ::testing::MockSpec<__VA_ARGS__>& \
510
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
511
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
512
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
513
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
514
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
515
 
                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \
516
 
    GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \
517
 
    return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \
518
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6); \
519
 
  } \
520
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \
521
 
      Method)
522
 
 
523
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
524
 
#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \
525
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
526
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
527
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
528
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
529
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
530
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
531
 
      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
532
 
      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
533
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
534
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
535
 
            == 7), \
536
 
        this_method_does_not_take_7_arguments); \
537
 
    GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
538
 
    return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \
539
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
540
 
  } \
541
 
  ::testing::MockSpec<__VA_ARGS__>& \
542
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
543
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
544
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
545
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
546
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
547
 
                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
548
 
                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \
549
 
    GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \
550
 
    return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \
551
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \
552
 
  } \
553
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \
554
 
      Method)
555
 
 
556
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
557
 
#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \
558
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
559
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
560
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
561
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
562
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
563
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
564
 
      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
565
 
      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
566
 
      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
567
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
568
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
569
 
            == 8), \
570
 
        this_method_does_not_take_8_arguments); \
571
 
    GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
572
 
    return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \
573
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
574
 
  } \
575
 
  ::testing::MockSpec<__VA_ARGS__>& \
576
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
577
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
578
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
579
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
580
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
581
 
                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
582
 
                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
583
 
                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \
584
 
    GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \
585
 
    return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \
586
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \
587
 
  } \
588
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \
589
 
      Method)
590
 
 
591
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
592
 
#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \
593
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
594
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
595
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
596
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
597
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
598
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
599
 
      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
600
 
      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
601
 
      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
602
 
      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
603
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
604
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
605
 
            == 9), \
606
 
        this_method_does_not_take_9_arguments); \
607
 
    GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
608
 
    return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \
609
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
610
 
        gmock_a9); \
611
 
  } \
612
 
  ::testing::MockSpec<__VA_ARGS__>& \
613
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
614
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
615
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
616
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
617
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
618
 
                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
619
 
                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
620
 
                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
621
 
                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \
622
 
    GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \
623
 
    return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \
624
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \
625
 
        gmock_a9); \
626
 
  } \
627
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \
628
 
      Method)
629
 
 
630
 
// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
631
 
#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \
632
 
  GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \
633
 
      GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \
634
 
      GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \
635
 
      GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \
636
 
      GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \
637
 
      GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \
638
 
      GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \
639
 
      GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \
640
 
      GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \
641
 
      GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \
642
 
      GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \
643
 
    GTEST_COMPILE_ASSERT_((::std::tr1::tuple_size<                          \
644
 
        tn ::testing::internal::Function<__VA_ARGS__>::ArgumentTuple>::value \
645
 
            == 10), \
646
 
        this_method_does_not_take_10_arguments); \
647
 
    GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \
648
 
    return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \
649
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
650
 
        gmock_a10); \
651
 
  } \
652
 
  ::testing::MockSpec<__VA_ARGS__>& \
653
 
      gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \
654
 
                     GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \
655
 
                     GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \
656
 
                     GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \
657
 
                     GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \
658
 
                     GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \
659
 
                     GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \
660
 
                     GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \
661
 
                     GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \
662
 
                     GMOCK_MATCHER_(tn, 10, \
663
 
                         __VA_ARGS__) gmock_a10) constness { \
664
 
    GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \
665
 
    return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \
666
 
        gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \
667
 
        gmock_a10); \
668
 
  } \
669
 
  mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \
670
 
      Method)
671
 
 
672
 
#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__)
673
 
#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__)
674
 
#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__)
675
 
#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__)
676
 
#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__)
677
 
#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__)
678
 
#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__)
679
 
#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__)
680
 
#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__)
681
 
#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__)
682
 
#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__)
683
 
 
684
 
#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__)
685
 
#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__)
686
 
#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__)
687
 
#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__)
688
 
#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__)
689
 
#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__)
690
 
#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__)
691
 
#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__)
692
 
#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__)
693
 
#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__)
694
 
#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__)
695
 
 
696
 
#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__)
697
 
#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__)
698
 
#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__)
699
 
#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__)
700
 
#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__)
701
 
#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__)
702
 
#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__)
703
 
#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__)
704
 
#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__)
705
 
#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__)
706
 
#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__)
707
 
 
708
 
#define MOCK_CONST_METHOD0_T(m, ...) \
709
 
    GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__)
710
 
#define MOCK_CONST_METHOD1_T(m, ...) \
711
 
    GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__)
712
 
#define MOCK_CONST_METHOD2_T(m, ...) \
713
 
    GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__)
714
 
#define MOCK_CONST_METHOD3_T(m, ...) \
715
 
    GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__)
716
 
#define MOCK_CONST_METHOD4_T(m, ...) \
717
 
    GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__)
718
 
#define MOCK_CONST_METHOD5_T(m, ...) \
719
 
    GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__)
720
 
#define MOCK_CONST_METHOD6_T(m, ...) \
721
 
    GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__)
722
 
#define MOCK_CONST_METHOD7_T(m, ...) \
723
 
    GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__)
724
 
#define MOCK_CONST_METHOD8_T(m, ...) \
725
 
    GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__)
726
 
#define MOCK_CONST_METHOD9_T(m, ...) \
727
 
    GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__)
728
 
#define MOCK_CONST_METHOD10_T(m, ...) \
729
 
    GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__)
730
 
 
731
 
#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
732
 
    GMOCK_METHOD0_(, , ct, m, __VA_ARGS__)
733
 
#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
734
 
    GMOCK_METHOD1_(, , ct, m, __VA_ARGS__)
735
 
#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
736
 
    GMOCK_METHOD2_(, , ct, m, __VA_ARGS__)
737
 
#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
738
 
    GMOCK_METHOD3_(, , ct, m, __VA_ARGS__)
739
 
#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
740
 
    GMOCK_METHOD4_(, , ct, m, __VA_ARGS__)
741
 
#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
742
 
    GMOCK_METHOD5_(, , ct, m, __VA_ARGS__)
743
 
#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
744
 
    GMOCK_METHOD6_(, , ct, m, __VA_ARGS__)
745
 
#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
746
 
    GMOCK_METHOD7_(, , ct, m, __VA_ARGS__)
747
 
#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
748
 
    GMOCK_METHOD8_(, , ct, m, __VA_ARGS__)
749
 
#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
750
 
    GMOCK_METHOD9_(, , ct, m, __VA_ARGS__)
751
 
#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
752
 
    GMOCK_METHOD10_(, , ct, m, __VA_ARGS__)
753
 
 
754
 
#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
755
 
    GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__)
756
 
#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
757
 
    GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__)
758
 
#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
759
 
    GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__)
760
 
#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
761
 
    GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__)
762
 
#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
763
 
    GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__)
764
 
#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
765
 
    GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__)
766
 
#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
767
 
    GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__)
768
 
#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
769
 
    GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__)
770
 
#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
771
 
    GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__)
772
 
#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
773
 
    GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__)
774
 
#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
775
 
    GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__)
776
 
 
777
 
#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
778
 
    GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__)
779
 
#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
780
 
    GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__)
781
 
#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
782
 
    GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__)
783
 
#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
784
 
    GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__)
785
 
#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
786
 
    GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__)
787
 
#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
788
 
    GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__)
789
 
#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
790
 
    GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__)
791
 
#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
792
 
    GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__)
793
 
#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
794
 
    GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__)
795
 
#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
796
 
    GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__)
797
 
#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
798
 
    GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__)
799
 
 
800
 
#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
801
 
    GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__)
802
 
#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
803
 
    GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__)
804
 
#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
805
 
    GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__)
806
 
#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
807
 
    GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__)
808
 
#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
809
 
    GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__)
810
 
#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
811
 
    GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__)
812
 
#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
813
 
    GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__)
814
 
#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
815
 
    GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__)
816
 
#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
817
 
    GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__)
818
 
#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
819
 
    GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__)
820
 
#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
821
 
    GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__)
822
 
 
823
 
// A MockFunction<F> class has one mock method whose type is F.  It is
824
 
// useful when you just want your test code to emit some messages and
825
 
// have Google Mock verify the right messages are sent (and perhaps at
826
 
// the right times).  For example, if you are exercising code:
827
 
//
828
 
//   Foo(1);
829
 
//   Foo(2);
830
 
//   Foo(3);
831
 
//
832
 
// and want to verify that Foo(1) and Foo(3) both invoke
833
 
// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
834
 
//
835
 
// TEST(FooTest, InvokesBarCorrectly) {
836
 
//   MyMock mock;
837
 
//   MockFunction<void(string check_point_name)> check;
838
 
//   {
839
 
//     InSequence s;
840
 
//
841
 
//     EXPECT_CALL(mock, Bar("a"));
842
 
//     EXPECT_CALL(check, Call("1"));
843
 
//     EXPECT_CALL(check, Call("2"));
844
 
//     EXPECT_CALL(mock, Bar("a"));
845
 
//   }
846
 
//   Foo(1);
847
 
//   check.Call("1");
848
 
//   Foo(2);
849
 
//   check.Call("2");
850
 
//   Foo(3);
851
 
// }
852
 
//
853
 
// The expectation spec says that the first Bar("a") must happen
854
 
// before check point "1", the second Bar("a") must happen after check
855
 
// point "2", and nothing should happen between the two check
856
 
// points. The explicit check points make it easy to tell which
857
 
// Bar("a") is called by which call to Foo().
858
 
template <typename F>
859
 
class MockFunction;
860
 
 
861
 
template <typename R>
862
 
class MockFunction<R()> {
863
 
 public:
864
 
  MockFunction() {}
865
 
 
866
 
  MOCK_METHOD0_T(Call, R());
867
 
 
868
 
 private:
869
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
870
 
};
871
 
 
872
 
template <typename R, typename A0>
873
 
class MockFunction<R(A0)> {
874
 
 public:
875
 
  MockFunction() {}
876
 
 
877
 
  MOCK_METHOD1_T(Call, R(A0));
878
 
 
879
 
 private:
880
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
881
 
};
882
 
 
883
 
template <typename R, typename A0, typename A1>
884
 
class MockFunction<R(A0, A1)> {
885
 
 public:
886
 
  MockFunction() {}
887
 
 
888
 
  MOCK_METHOD2_T(Call, R(A0, A1));
889
 
 
890
 
 private:
891
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
892
 
};
893
 
 
894
 
template <typename R, typename A0, typename A1, typename A2>
895
 
class MockFunction<R(A0, A1, A2)> {
896
 
 public:
897
 
  MockFunction() {}
898
 
 
899
 
  MOCK_METHOD3_T(Call, R(A0, A1, A2));
900
 
 
901
 
 private:
902
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
903
 
};
904
 
 
905
 
template <typename R, typename A0, typename A1, typename A2, typename A3>
906
 
class MockFunction<R(A0, A1, A2, A3)> {
907
 
 public:
908
 
  MockFunction() {}
909
 
 
910
 
  MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
911
 
 
912
 
 private:
913
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
914
 
};
915
 
 
916
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
917
 
    typename A4>
918
 
class MockFunction<R(A0, A1, A2, A3, A4)> {
919
 
 public:
920
 
  MockFunction() {}
921
 
 
922
 
  MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
923
 
 
924
 
 private:
925
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
926
 
};
927
 
 
928
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
929
 
    typename A4, typename A5>
930
 
class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
931
 
 public:
932
 
  MockFunction() {}
933
 
 
934
 
  MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
935
 
 
936
 
 private:
937
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
938
 
};
939
 
 
940
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
941
 
    typename A4, typename A5, typename A6>
942
 
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
943
 
 public:
944
 
  MockFunction() {}
945
 
 
946
 
  MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
947
 
 
948
 
 private:
949
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
950
 
};
951
 
 
952
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
953
 
    typename A4, typename A5, typename A6, typename A7>
954
 
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
955
 
 public:
956
 
  MockFunction() {}
957
 
 
958
 
  MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
959
 
 
960
 
 private:
961
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
962
 
};
963
 
 
964
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
965
 
    typename A4, typename A5, typename A6, typename A7, typename A8>
966
 
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
967
 
 public:
968
 
  MockFunction() {}
969
 
 
970
 
  MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
971
 
 
972
 
 private:
973
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
974
 
};
975
 
 
976
 
template <typename R, typename A0, typename A1, typename A2, typename A3,
977
 
    typename A4, typename A5, typename A6, typename A7, typename A8,
978
 
    typename A9>
979
 
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
980
 
 public:
981
 
  MockFunction() {}
982
 
 
983
 
  MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
984
 
 
985
 
 private:
986
 
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
987
 
};
988
 
 
989
 
}  // namespace testing
990
 
 
991
 
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_