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