OpenCores
URL https://opencores.org/ocsvn/s80186/s80186/trunk

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googlemock/] [include/] [gmock/] [gmock-generated-actions.h] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 jamieiles 
// This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
2 
 
3 
// Copyright 2007, Google Inc.
4 
// All rights reserved.
5 
//
6 
// Redistribution and use in source and binary forms, with or without
7 
// modification, are permitted provided that the following conditions are
8 
// met:
9 
//
10 
//     * Redistributions of source code must retain the above copyright
11 
// notice, this list of conditions and the following disclaimer.
12 
//     * Redistributions in binary form must reproduce the above
13 
// copyright notice, this list of conditions and the following disclaimer
14 
// in the documentation and/or other materials provided with the
15 
// distribution.
16 
//     * Neither the name of Google Inc. nor the names of its
17 
// contributors may be used to endorse or promote products derived from
18 
// this software without specific prior written permission.
19 
//
20 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 
//
32 
// Author: wan@google.com (Zhanyong Wan)
33 
 
34 
// Google Mock - a framework for writing C++ mock classes.
35 
//
36 
// This file implements some commonly used variadic actions.
37 
 
38 
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
39 
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
40 
 
41 
#include "gmock/gmock-actions.h"
42 
#include "gmock/internal/gmock-port.h"
43 
 
44 
namespace testing {
45 
namespace internal {
46 
 
47 
// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary
48 
// function or method with the unpacked values, where F is a function
49 
// type that takes N arguments.
50 
template <typename Result, typename ArgumentTuple>
51 
class InvokeHelper;
52 
 
53 
template <typename R>
54 
class InvokeHelper<R, ::testing::tuple<> > {
55 
 public:
56 
  template <typename Function>
57 
  static R Invoke(Function function, const ::testing::tuple<>&) {
58 
           return function();
59 
  }
60 
 
61 
  template <class Class, typename MethodPtr>
62 
  static R InvokeMethod(Class* obj_ptr,
63 
                        MethodPtr method_ptr,
64 
                        const ::testing::tuple<>&) {
65 
           return (obj_ptr->*method_ptr)();
66 
  }
67 
};
68 
 
69 
template <typename R, typename A1>
70 
class InvokeHelper<R, ::testing::tuple<A1> > {
71 
 public:
72 
  template <typename Function>
73 
  static R Invoke(Function function, const ::testing::tuple<A1>& args) {
74 
           return function(get<0>(args));
75 
  }
76 
 
77 
  template <class Class, typename MethodPtr>
78 
  static R InvokeMethod(Class* obj_ptr,
79 
                        MethodPtr method_ptr,
80 
                        const ::testing::tuple<A1>& args) {
81 
           return (obj_ptr->*method_ptr)(get<0>(args));
82 
  }
83 
};
84 
 
85 
template <typename R, typename A1, typename A2>
86 
class InvokeHelper<R, ::testing::tuple<A1, A2> > {
87 
 public:
88 
  template <typename Function>
89 
  static R Invoke(Function function, const ::testing::tuple<A1, A2>& args) {
90 
           return function(get<0>(args), get<1>(args));
91 
  }
92 
 
93 
  template <class Class, typename MethodPtr>
94 
  static R InvokeMethod(Class* obj_ptr,
95 
                        MethodPtr method_ptr,
96 
                        const ::testing::tuple<A1, A2>& args) {
97 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args));
98 
  }
99 
};
100 
 
101 
template <typename R, typename A1, typename A2, typename A3>
102 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3> > {
103 
 public:
104 
  template <typename Function>
105 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3>& args) {
106 
           return function(get<0>(args), get<1>(args), get<2>(args));
107 
  }
108 
 
109 
  template <class Class, typename MethodPtr>
110 
  static R InvokeMethod(Class* obj_ptr,
111 
                        MethodPtr method_ptr,
112 
                        const ::testing::tuple<A1, A2, A3>& args) {
113 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
114 
               get<2>(args));
115 
  }
116 
};
117 
 
118 
template <typename R, typename A1, typename A2, typename A3, typename A4>
119 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4> > {
120 
 public:
121 
  template <typename Function>
122 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3,
123 
      A4>& args) {
124 
           return function(get<0>(args), get<1>(args), get<2>(args),
125 
               get<3>(args));
126 
  }
127 
 
128 
  template <class Class, typename MethodPtr>
129 
  static R InvokeMethod(Class* obj_ptr,
130 
                        MethodPtr method_ptr,
131 
                        const ::testing::tuple<A1, A2, A3, A4>& args) {
132 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
133 
               get<2>(args), get<3>(args));
134 
  }
135 
};
136 
 
137 
template <typename R, typename A1, typename A2, typename A3, typename A4,
138 
    typename A5>
139 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5> > {
140 
 public:
141 
  template <typename Function>
142 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4,
143 
      A5>& args) {
144 
           return function(get<0>(args), get<1>(args), get<2>(args),
145 
               get<3>(args), get<4>(args));
146 
  }
147 
 
148 
  template <class Class, typename MethodPtr>
149 
  static R InvokeMethod(Class* obj_ptr,
150 
                        MethodPtr method_ptr,
151 
                        const ::testing::tuple<A1, A2, A3, A4, A5>& args) {
152 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
153 
               get<2>(args), get<3>(args), get<4>(args));
154 
  }
155 
};
156 
 
157 
template <typename R, typename A1, typename A2, typename A3, typename A4,
158 
    typename A5, typename A6>
159 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
160 
 public:
161 
  template <typename Function>
162 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
163 
      A6>& args) {
164 
           return function(get<0>(args), get<1>(args), get<2>(args),
165 
               get<3>(args), get<4>(args), get<5>(args));
166 
  }
167 
 
168 
  template <class Class, typename MethodPtr>
169 
  static R InvokeMethod(Class* obj_ptr,
170 
                        MethodPtr method_ptr,
171 
                        const ::testing::tuple<A1, A2, A3, A4, A5, A6>& args) {
172 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
173 
               get<2>(args), get<3>(args), get<4>(args), get<5>(args));
174 
  }
175 
};
176 
 
177 
template <typename R, typename A1, typename A2, typename A3, typename A4,
178 
    typename A5, typename A6, typename A7>
179 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
180 
 public:
181 
  template <typename Function>
182 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
183 
      A6, A7>& args) {
184 
           return function(get<0>(args), get<1>(args), get<2>(args),
185 
               get<3>(args), get<4>(args), get<5>(args), get<6>(args));
186 
  }
187 
 
188 
  template <class Class, typename MethodPtr>
189 
  static R InvokeMethod(Class* obj_ptr,
190 
                        MethodPtr method_ptr,
191 
                        const ::testing::tuple<A1, A2, A3, A4, A5, A6,
192 
                            A7>& args) {
193 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
194 
               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
195 
               get<6>(args));
196 
  }
197 
};
198 
 
199 
template <typename R, typename A1, typename A2, typename A3, typename A4,
200 
    typename A5, typename A6, typename A7, typename A8>
201 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
202 
 public:
203 
  template <typename Function>
204 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
205 
      A6, A7, A8>& args) {
206 
           return function(get<0>(args), get<1>(args), get<2>(args),
207 
               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
208 
               get<7>(args));
209 
  }
210 
 
211 
  template <class Class, typename MethodPtr>
212 
  static R InvokeMethod(Class* obj_ptr,
213 
                        MethodPtr method_ptr,
214 
                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7,
215 
                            A8>& args) {
216 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
217 
               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
218 
               get<6>(args), get<7>(args));
219 
  }
220 
};
221 
 
222 
template <typename R, typename A1, typename A2, typename A3, typename A4,
223 
    typename A5, typename A6, typename A7, typename A8, typename A9>
224 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
225 
 public:
226 
  template <typename Function>
227 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
228 
      A6, A7, A8, A9>& args) {
229 
           return function(get<0>(args), get<1>(args), get<2>(args),
230 
               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
231 
               get<7>(args), get<8>(args));
232 
  }
233 
 
234 
  template <class Class, typename MethodPtr>
235 
  static R InvokeMethod(Class* obj_ptr,
236 
                        MethodPtr method_ptr,
237 
                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
238 
                            A9>& args) {
239 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
240 
               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
241 
               get<6>(args), get<7>(args), get<8>(args));
242 
  }
243 
};
244 
 
245 
template <typename R, typename A1, typename A2, typename A3, typename A4,
246 
    typename A5, typename A6, typename A7, typename A8, typename A9,
247 
    typename A10>
248 
class InvokeHelper<R, ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
249 
    A10> > {
250 
 public:
251 
  template <typename Function>
252 
  static R Invoke(Function function, const ::testing::tuple<A1, A2, A3, A4, A5,
253 
      A6, A7, A8, A9, A10>& args) {
254 
           return function(get<0>(args), get<1>(args), get<2>(args),
255 
               get<3>(args), get<4>(args), get<5>(args), get<6>(args),
256 
               get<7>(args), get<8>(args), get<9>(args));
257 
  }
258 
 
259 
  template <class Class, typename MethodPtr>
260 
  static R InvokeMethod(Class* obj_ptr,
261 
                        MethodPtr method_ptr,
262 
                        const ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8,
263 
                            A9, A10>& args) {
264 
           return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args),
265 
               get<2>(args), get<3>(args), get<4>(args), get<5>(args),
266 
               get<6>(args), get<7>(args), get<8>(args), get<9>(args));
267 
  }
268 
};
269 
 
270 
// An INTERNAL macro for extracting the type of a tuple field.  It's
271 
// subject to change without notice - DO NOT USE IN USER CODE!
272 
#define GMOCK_FIELD_(Tuple, N) \
273 
    typename ::testing::tuple_element<N, Tuple>::type
274 
 
275 
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the
276 
// type of an n-ary function whose i-th (1-based) argument type is the
277 
// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple
278 
// type, and whose return type is Result.  For example,
279 
//   SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type
280 
// is int(bool, long).
281 
//
282 
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args)
283 
// returns the selected fields (k1, k2, ..., k_n) of args as a tuple.
284 
// For example,
285 
//   SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select(
286 
//       ::testing::make_tuple(true, 'a', 2.5))
287 
// returns tuple (2.5, true).
288 
//
289 
// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be
290 
// in the range [0, 10].  Duplicates are allowed and they don't have
291 
// to be in an ascending or descending order.
292 
 
293 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
294 
    int k4, int k5, int k6, int k7, int k8, int k9, int k10>
295 
class SelectArgs {
296 
 public:
297 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
298 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
299 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
300 
      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
301 
      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9),
302 
      GMOCK_FIELD_(ArgumentTuple, k10));
303 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
304 
  static SelectedArgs Select(const ArgumentTuple& args) {
305 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
306 
        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
307 
        get<k8>(args), get<k9>(args), get<k10>(args));
308 
  }
309 
};
310 
 
311 
template <typename Result, typename ArgumentTuple>
312 
class SelectArgs<Result, ArgumentTuple,
313 
                 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
314 
 public:
315 
  typedef Result type();
316 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
317 
  static SelectedArgs Select(const ArgumentTuple& /* args */) {
318 
    return SelectedArgs();
319 
  }
320 
};
321 
 
322 
template <typename Result, typename ArgumentTuple, int k1>
323 
class SelectArgs<Result, ArgumentTuple,
324 
                 k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
325 
 public:
326 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1));
327 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
328 
  static SelectedArgs Select(const ArgumentTuple& args) {
329 
    return SelectedArgs(get<k1>(args));
330 
  }
331 
};
332 
 
333 
template <typename Result, typename ArgumentTuple, int k1, int k2>
334 
class SelectArgs<Result, ArgumentTuple,
335 
                 k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> {
336 
 public:
337 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
338 
      GMOCK_FIELD_(ArgumentTuple, k2));
339 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
340 
  static SelectedArgs Select(const ArgumentTuple& args) {
341 
    return SelectedArgs(get<k1>(args), get<k2>(args));
342 
  }
343 
};
344 
 
345 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3>
346 
class SelectArgs<Result, ArgumentTuple,
347 
                 k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> {
348 
 public:
349 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
350 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3));
351 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
352 
  static SelectedArgs Select(const ArgumentTuple& args) {
353 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args));
354 
  }
355 
};
356 
 
357 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
358 
    int k4>
359 
class SelectArgs<Result, ArgumentTuple,
360 
                 k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> {
361 
 public:
362 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
363 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
364 
      GMOCK_FIELD_(ArgumentTuple, k4));
365 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
366 
  static SelectedArgs Select(const ArgumentTuple& args) {
367 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
368 
        get<k4>(args));
369 
  }
370 
};
371 
 
372 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
373 
    int k4, int k5>
374 
class SelectArgs<Result, ArgumentTuple,
375 
                 k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> {
376 
 public:
377 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
378 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
379 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5));
380 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
381 
  static SelectedArgs Select(const ArgumentTuple& args) {
382 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
383 
        get<k4>(args), get<k5>(args));
384 
  }
385 
};
386 
 
387 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
388 
    int k4, int k5, int k6>
389 
class SelectArgs<Result, ArgumentTuple,
390 
                 k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> {
391 
 public:
392 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
393 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
394 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
395 
      GMOCK_FIELD_(ArgumentTuple, k6));
396 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
397 
  static SelectedArgs Select(const ArgumentTuple& args) {
398 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
399 
        get<k4>(args), get<k5>(args), get<k6>(args));
400 
  }
401 
};
402 
 
403 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
404 
    int k4, int k5, int k6, int k7>
405 
class SelectArgs<Result, ArgumentTuple,
406 
                 k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> {
407 
 public:
408 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
409 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
410 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
411 
      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7));
412 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
413 
  static SelectedArgs Select(const ArgumentTuple& args) {
414 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
415 
        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args));
416 
  }
417 
};
418 
 
419 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
420 
    int k4, int k5, int k6, int k7, int k8>
421 
class SelectArgs<Result, ArgumentTuple,
422 
                 k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> {
423 
 public:
424 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
425 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
426 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
427 
      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
428 
      GMOCK_FIELD_(ArgumentTuple, k8));
429 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
430 
  static SelectedArgs Select(const ArgumentTuple& args) {
431 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
432 
        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
433 
        get<k8>(args));
434 
  }
435 
};
436 
 
437 
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3,
438 
    int k4, int k5, int k6, int k7, int k8, int k9>
439 
class SelectArgs<Result, ArgumentTuple,
440 
                 k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> {
441 
 public:
442 
  typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1),
443 
      GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3),
444 
      GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5),
445 
      GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7),
446 
      GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9));
447 
  typedef typename Function<type>::ArgumentTuple SelectedArgs;
448 
  static SelectedArgs Select(const ArgumentTuple& args) {
449 
    return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args),
450 
        get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args),
451 
        get<k8>(args), get<k9>(args));
452 
  }
453 
};
454 
 
455 
#undef GMOCK_FIELD_
456 
 
457 
// Implements the WithArgs action.
458 
template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1,
459 
    int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1,
460 
    int k9 = -1, int k10 = -1>
461 
class WithArgsAction {
462 
 public:
463 
  explicit WithArgsAction(const InnerAction& action) : action_(action) {}
464 
 
465 
  template <typename F>
466 
  operator Action<F>() const { return MakeAction(new Impl<F>(action_)); }
467 
 
468 
 private:
469 
  template <typename F>
470 
  class Impl : public ActionInterface<F> {
471 
   public:
472 
    typedef typename Function<F>::Result Result;
473 
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
474 
 
475 
    explicit Impl(const InnerAction& action) : action_(action) {}
476 
 
477 
    virtual Result Perform(const ArgumentTuple& args) {
478 
      return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4,
479 
          k5, k6, k7, k8, k9, k10>::Select(args));
480 
    }
481 
 
482 
   private:
483 
    typedef typename SelectArgs<Result, ArgumentTuple,
484 
        k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType;
485 
 
486 
    Action<InnerFunctionType> action_;
487 
  };
488 
 
489 
  const InnerAction action_;
490 
 
491 
  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
492 
};
493 
 
494 
// A macro from the ACTION* family (defined later in this file)
495 
// defines an action that can be used in a mock function.  Typically,
496 
// these actions only care about a subset of the arguments of the mock
497 
// function.  For example, if such an action only uses the second
498 
// argument, it can be used in any mock function that takes >= 2
499 
// arguments where the type of the second argument is compatible.
500 
//
501 
// Therefore, the action implementation must be prepared to take more
502 
// arguments than it needs.  The ExcessiveArg type is used to
503 
// represent those excessive arguments.  In order to keep the compiler
504 
// error messages tractable, we define it in the testing namespace
505 
// instead of testing::internal.  However, this is an INTERNAL TYPE
506 
// and subject to change without notice, so a user MUST NOT USE THIS
507 
// TYPE DIRECTLY.
508 
struct ExcessiveArg {};
509 
 
510 
// A helper class needed for implementing the ACTION* macros.
511 
template <typename Result, class Impl>
512 
class ActionHelper {
513 
 public:
514 
  static Result Perform(Impl* impl, const ::testing::tuple<>& args) {
515 
    return impl->template gmock_PerformImpl<>(args, ExcessiveArg(),
516 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
517 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
518 
        ExcessiveArg());
519 
  }
520 
 
521 
  template <typename A0>
522 
  static Result Perform(Impl* impl, const ::testing::tuple<A0>& args) {
523 
    return impl->template gmock_PerformImpl<A0>(args, get<0>(args),
524 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
525 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
526 
        ExcessiveArg());
527 
  }
528 
 
529 
  template <typename A0, typename A1>
530 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1>& args) {
531 
    return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args),
532 
        get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
533 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
534 
        ExcessiveArg());
535 
  }
536 
 
537 
  template <typename A0, typename A1, typename A2>
538 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2>& args) {
539 
    return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args),
540 
        get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(),
541 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
542 
        ExcessiveArg());
543 
  }
544 
 
545 
  template <typename A0, typename A1, typename A2, typename A3>
546 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2,
547 
      A3>& args) {
548 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args),
549 
        get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(),
550 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
551 
        ExcessiveArg());
552 
  }
553 
 
554 
  template <typename A0, typename A1, typename A2, typename A3, typename A4>
555 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3,
556 
      A4>& args) {
557 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args,
558 
        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
559 
        ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
560 
        ExcessiveArg());
561 
  }
562 
 
563 
  template <typename A0, typename A1, typename A2, typename A3, typename A4,
564 
      typename A5>
565 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
566 
      A5>& args) {
567 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args,
568 
        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
569 
        get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(),
570 
        ExcessiveArg());
571 
  }
572 
 
573 
  template <typename A0, typename A1, typename A2, typename A3, typename A4,
574 
      typename A5, typename A6>
575 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
576 
      A5, A6>& args) {
577 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args,
578 
        get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args),
579 
        get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(),
580 
        ExcessiveArg());
581 
  }
582 
 
583 
  template <typename A0, typename A1, typename A2, typename A3, typename A4,
584 
      typename A5, typename A6, typename A7>
585 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
586 
      A5, A6, A7>& args) {
587 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6,
588 
        A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
589 
        get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(),
590 
        ExcessiveArg());
591 
  }
592 
 
593 
  template <typename A0, typename A1, typename A2, typename A3, typename A4,
594 
      typename A5, typename A6, typename A7, typename A8>
595 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
596 
      A5, A6, A7, A8>& args) {
597 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7,
598 
        A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
599 
        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
600 
        ExcessiveArg());
601 
  }
602 
 
603 
  template <typename A0, typename A1, typename A2, typename A3, typename A4,
604 
      typename A5, typename A6, typename A7, typename A8, typename A9>
605 
  static Result Perform(Impl* impl, const ::testing::tuple<A0, A1, A2, A3, A4,
606 
      A5, A6, A7, A8, A9>& args) {
607 
    return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8,
608 
        A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args),
609 
        get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args),
610 
        get<9>(args));
611 
  }
612 
};
613 
 
614 
}  // namespace internal
615 
 
616 
// Various overloads for Invoke().
617 
 
618 
// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
619 
// the selected arguments of the mock function to an_action and
620 
// performs it.  It serves as an adaptor between actions with
621 
// different argument lists.  C++ doesn't support default arguments for
622 
// function templates, so we have to overload it.
623 
template <int k1, typename InnerAction>
624 
inline internal::WithArgsAction<InnerAction, k1>
625 
WithArgs(const InnerAction& action) {
626 
  return internal::WithArgsAction<InnerAction, k1>(action);
627 
}
628 
 
629 
template <int k1, int k2, typename InnerAction>
630 
inline internal::WithArgsAction<InnerAction, k1, k2>
631 
WithArgs(const InnerAction& action) {
632 
  return internal::WithArgsAction<InnerAction, k1, k2>(action);
633 
}
634 
 
635 
template <int k1, int k2, int k3, typename InnerAction>
636 
inline internal::WithArgsAction<InnerAction, k1, k2, k3>
637 
WithArgs(const InnerAction& action) {
638 
  return internal::WithArgsAction<InnerAction, k1, k2, k3>(action);
639 
}
640 
 
641 
template <int k1, int k2, int k3, int k4, typename InnerAction>
642 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4>
643 
WithArgs(const InnerAction& action) {
644 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action);
645 
}
646 
 
647 
template <int k1, int k2, int k3, int k4, int k5, typename InnerAction>
648 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>
649 
WithArgs(const InnerAction& action) {
650 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action);
651 
}
652 
 
653 
template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction>
654 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>
655 
WithArgs(const InnerAction& action) {
656 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action);
657 
}
658 
 
659 
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7,
660 
    typename InnerAction>
661 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7>
662 
WithArgs(const InnerAction& action) {
663 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6,
664 
      k7>(action);
665 
}
666 
 
667 
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
668 
    typename InnerAction>
669 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8>
670 
WithArgs(const InnerAction& action) {
671 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7,
672 
      k8>(action);
673 
}
674 
 
675 
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
676 
    int k9, typename InnerAction>
677 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9>
678 
WithArgs(const InnerAction& action) {
679 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
680 
      k9>(action);
681 
}
682 
 
683 
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8,
684 
    int k9, int k10, typename InnerAction>
685 
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
686 
    k9, k10>
687 
WithArgs(const InnerAction& action) {
688 
  return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8,
689 
      k9, k10>(action);
690 
}
691 
 
692 
// Creates an action that does actions a1, a2, ..., sequentially in
693 
// each invocation.
694 
template <typename Action1, typename Action2>
695 
inline internal::DoBothAction<Action1, Action2>
696 
DoAll(Action1 a1, Action2 a2) {
697 
  return internal::DoBothAction<Action1, Action2>(a1, a2);
698 
}
699 
 
700 
template <typename Action1, typename Action2, typename Action3>
701 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
702 
    Action3> >
703 
DoAll(Action1 a1, Action2 a2, Action3 a3) {
704 
  return DoAll(a1, DoAll(a2, a3));
705 
}
706 
 
707 
template <typename Action1, typename Action2, typename Action3,
708 
    typename Action4>
709 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
710 
    internal::DoBothAction<Action3, Action4> > >
711 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) {
712 
  return DoAll(a1, DoAll(a2, a3, a4));
713 
}
714 
 
715 
template <typename Action1, typename Action2, typename Action3,
716 
    typename Action4, typename Action5>
717 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
718 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
719 
    Action5> > > >
720 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) {
721 
  return DoAll(a1, DoAll(a2, a3, a4, a5));
722 
}
723 
 
724 
template <typename Action1, typename Action2, typename Action3,
725 
    typename Action4, typename Action5, typename Action6>
726 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
727 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
728 
    internal::DoBothAction<Action5, Action6> > > > >
729 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) {
730 
  return DoAll(a1, DoAll(a2, a3, a4, a5, a6));
731 
}
732 
 
733 
template <typename Action1, typename Action2, typename Action3,
734 
    typename Action4, typename Action5, typename Action6, typename Action7>
735 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
736 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
737 
    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
738 
    Action7> > > > > >
739 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
740 
    Action7 a7) {
741 
  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7));
742 
}
743 
 
744 
template <typename Action1, typename Action2, typename Action3,
745 
    typename Action4, typename Action5, typename Action6, typename Action7,
746 
    typename Action8>
747 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
748 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
749 
    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
750 
    internal::DoBothAction<Action7, Action8> > > > > > >
751 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
752 
    Action7 a7, Action8 a8) {
753 
  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8));
754 
}
755 
 
756 
template <typename Action1, typename Action2, typename Action3,
757 
    typename Action4, typename Action5, typename Action6, typename Action7,
758 
    typename Action8, typename Action9>
759 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
760 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
761 
    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
762 
    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
763 
    Action9> > > > > > > >
764 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
765 
    Action7 a7, Action8 a8, Action9 a9) {
766 
  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9));
767 
}
768 
 
769 
template <typename Action1, typename Action2, typename Action3,
770 
    typename Action4, typename Action5, typename Action6, typename Action7,
771 
    typename Action8, typename Action9, typename Action10>
772 
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2,
773 
    internal::DoBothAction<Action3, internal::DoBothAction<Action4,
774 
    internal::DoBothAction<Action5, internal::DoBothAction<Action6,
775 
    internal::DoBothAction<Action7, internal::DoBothAction<Action8,
776 
    internal::DoBothAction<Action9, Action10> > > > > > > > >
777 
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
778 
    Action7 a7, Action8 a8, Action9 a9, Action10 a10) {
779 
  return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10));
780 
}
781 
 
782 
}  // namespace testing
783 
 
784 
// The ACTION* family of macros can be used in a namespace scope to
785 
// define custom actions easily.  The syntax:
786 
//
787 
//   ACTION(name) { statements; }
788 
//
789 
// will define an action with the given name that executes the
790 
// statements.  The value returned by the statements will be used as
791 
// the return value of the action.  Inside the statements, you can
792 
// refer to the K-th (0-based) argument of the mock function by
793 
// 'argK', and refer to its type by 'argK_type'.  For example:
794 
//
795 
//   ACTION(IncrementArg1) {
796 
//     arg1_type temp = arg1;
797 
//     return ++(*temp);
798 
//   }
799 
//
800 
// allows you to write
801 
//
802 
//   ...WillOnce(IncrementArg1());
803 
//
804 
// You can also refer to the entire argument tuple and its type by
805 
// 'args' and 'args_type', and refer to the mock function type and its
806 
// return type by 'function_type' and 'return_type'.
807 
//
808 
// Note that you don't need to specify the types of the mock function
809 
// arguments.  However rest assured that your code is still type-safe:
810 
// you'll get a compiler error if *arg1 doesn't support the ++
811 
// operator, or if the type of ++(*arg1) isn't compatible with the
812 
// mock function's return type, for example.
813 
//
814 
// Sometimes you'll want to parameterize the action.   For that you can use
815 
// another macro:
816 
//
817 
//   ACTION_P(name, param_name) { statements; }
818 
//
819 
// For example:
820 
//
821 
//   ACTION_P(Add, n) { return arg0 + n; }
822 
//
823 
// will allow you to write:
824 
//
825 
//   ...WillOnce(Add(5));
826 
//
827 
// Note that you don't need to provide the type of the parameter
828 
// either.  If you need to reference the type of a parameter named
829 
// 'foo', you can write 'foo_type'.  For example, in the body of
830 
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
831 
// of 'n'.
832 
//
833 
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
834 
// multi-parameter actions.
835 
//
836 
// For the purpose of typing, you can view
837 
//
838 
//   ACTION_Pk(Foo, p1, ..., pk) { ... }
839 
//
840 
// as shorthand for
841 
//
842 
//   template <typename p1_type, ..., typename pk_type>
843 
//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
844 
//
845 
// In particular, you can provide the template type arguments
846 
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
847 
// although usually you can rely on the compiler to infer the types
848 
// for you automatically.  You can assign the result of expression
849 
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
850 
// pk_type>.  This can be useful when composing actions.
851 
//
852 
// You can also overload actions with different numbers of parameters:
853 
//
854 
//   ACTION_P(Plus, a) { ... }
855 
//   ACTION_P2(Plus, a, b) { ... }
856 
//
857 
// While it's tempting to always use the ACTION* macros when defining
858 
// a new action, you should also consider implementing ActionInterface
859 
// or using MakePolymorphicAction() instead, especially if you need to
860 
// use the action a lot.  While these approaches require more work,
861 
// they give you more control on the types of the mock function
862 
// arguments and the action parameters, which in general leads to
863 
// better compiler error messages that pay off in the long run.  They
864 
// also allow overloading actions based on parameter types (as opposed
865 
// to just based on the number of parameters).
866 
//
867 
// CAVEAT:
868 
//
869 
// ACTION*() can only be used in a namespace scope.  The reason is
870 
// that C++ doesn't yet allow function-local types to be used to
871 
// instantiate templates.  The up-coming C++0x standard will fix this.
872 
// Once that's done, we'll consider supporting using ACTION*() inside
873 
// a function.
874 
//
875 
// MORE INFORMATION:
876 
//
877 
// To learn more about using these macros, please search for 'ACTION'
878 
// on http://code.google.com/p/googlemock/wiki/CookBook.
879 
 
880 
// An internal macro needed for implementing ACTION*().
881 
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
882 
    const args_type& args GTEST_ATTRIBUTE_UNUSED_, \
883 
    arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_, \
884 
    arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_, \
885 
    arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_, \
886 
    arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_, \
887 
    arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_, \
888 
    arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_, \
889 
    arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_, \
890 
    arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_, \
891 
    arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_, \
892 
    arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_
893 
 
894 
// Sometimes you want to give an action explicit template parameters
895 
// that cannot be inferred from its value parameters.  ACTION() and
896 
// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
897 
// and can be viewed as an extension to ACTION() and ACTION_P*().
898 
//
899 
// The syntax:
900 
//
901 
//   ACTION_TEMPLATE(ActionName,
902 
//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
903 
//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
904 
//
905 
// defines an action template that takes m explicit template
906 
// parameters and n value parameters.  name_i is the name of the i-th
907 
// template parameter, and kind_i specifies whether it's a typename,
908 
// an integral constant, or a template.  p_i is the name of the i-th
909 
// value parameter.
910 
//
911 
// Example:
912 
//
913 
//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
914 
//   // function to type T and copies it to *output.
915 
//   ACTION_TEMPLATE(DuplicateArg,
916 
//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
917 
//                   AND_1_VALUE_PARAMS(output)) {
918 
//     *output = T(::testing::get<k>(args));
919 
//   }
920 
//   ...
921 
//     int n;
922 
//     EXPECT_CALL(mock, Foo(_, _))
923 
//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
924 
//
925 
// To create an instance of an action template, write:
926 
//
927 
//   ActionName<t1, ..., t_m>(v1, ..., v_n)
928 
//
929 
// where the ts are the template arguments and the vs are the value
930 
// arguments.  The value argument types are inferred by the compiler.
931 
// If you want to explicitly specify the value argument types, you can
932 
// provide additional template arguments:
933 
//
934 
//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
935 
//
936 
// where u_i is the desired type of v_i.
937 
//
938 
// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
939 
// number of value parameters, but not on the number of template
940 
// parameters.  Without the restriction, the meaning of the following
941 
// is unclear:
942 
//
943 
//   OverloadedAction<int, bool>(x);
944 
//
945 
// Are we using a single-template-parameter action where 'bool' refers
946 
// to the type of x, or are we using a two-template-parameter action
947 
// where the compiler is asked to infer the type of x?
948 
//
949 
// Implementation notes:
950 
//
951 
// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
952 
// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
953 
// implementing ACTION_TEMPLATE.  The main trick we use is to create
954 
// new macro invocations when expanding a macro.  For example, we have
955 
//
956 
//   #define ACTION_TEMPLATE(name, template_params, value_params)
957 
//       ... GMOCK_INTERNAL_DECL_##template_params ...
958 
//
959 
// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
960 
// to expand to
961 
//
962 
//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
963 
//
964 
// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
965 
// preprocessor will continue to expand it to
966 
//
967 
//       ... typename T ...
968 
//
969 
// This technique conforms to the C++ standard and is portable.  It
970 
// allows us to implement action templates using O(N) code, where N is
971 
// the maximum number of template/value parameters supported.  Without
972 
// using it, we'd have to devote O(N^2) amount of code to implement all
973 
// combinations of m and n.
974 
 
975 
// Declares the template parameters.
976 
#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
977 
#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
978 
    name1) kind0 name0, kind1 name1
979 
#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
980 
    kind2, name2) kind0 name0, kind1 name1, kind2 name2
981 
#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
982 
    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
983 
    kind3 name3
984 
#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
985 
    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
986 
    kind2 name2, kind3 name3, kind4 name4
987 
#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
988 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
989 
    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
990 
#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
991 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
992 
    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
993 
    kind5 name5, kind6 name6
994 
#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
995 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
996 
    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
997 
    kind4 name4, kind5 name5, kind6 name6, kind7 name7
998 
#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
999 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1000 
    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
1001 
    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
1002 
    kind8 name8
1003 
#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1004 
    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1005 
    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
1006 
    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
1007 
    kind6 name6, kind7 name7, kind8 name8, kind9 name9
1008 
 
1009 
// Lists the template parameters.
1010 
#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
1011 
#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
1012 
    name1) name0, name1
1013 
#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1014 
    kind2, name2) name0, name1, name2
1015 
#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1016 
    kind2, name2, kind3, name3) name0, name1, name2, name3
1017 
#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1018 
    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
1019 
    name4
1020 
#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1021 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
1022 
    name2, name3, name4, name5
1023 
#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1024 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1025 
    name6) name0, name1, name2, name3, name4, name5, name6
1026 
#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1027 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1028 
    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
1029 
#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
1030 
    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
1031 
    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
1032 
    name6, name7, name8
1033 
#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
1034 
    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
1035 
    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
1036 
    name3, name4, name5, name6, name7, name8, name9
1037 
 
1038 
// Declares the types of value parameters.
1039 
#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
1040 
#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
1041 
#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
1042 
    typename p0##_type, typename p1##_type
1043 
#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
1044 
    typename p0##_type, typename p1##_type, typename p2##_type
1045 
#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1046 
    typename p0##_type, typename p1##_type, typename p2##_type, \
1047 
    typename p3##_type
1048 
#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1049 
    typename p0##_type, typename p1##_type, typename p2##_type, \
1050 
    typename p3##_type, typename p4##_type
1051 
#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1052 
    typename p0##_type, typename p1##_type, typename p2##_type, \
1053 
    typename p3##_type, typename p4##_type, typename p5##_type
1054 
#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1055 
    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
1056 
    typename p3##_type, typename p4##_type, typename p5##_type, \
1057 
    typename p6##_type
1058 
#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1059 
    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
1060 
    typename p3##_type, typename p4##_type, typename p5##_type, \
1061 
    typename p6##_type, typename p7##_type
1062 
#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1063 
    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
1064 
    typename p3##_type, typename p4##_type, typename p5##_type, \
1065 
    typename p6##_type, typename p7##_type, typename p8##_type
1066 
#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1067 
    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
1068 
    typename p2##_type, typename p3##_type, typename p4##_type, \
1069 
    typename p5##_type, typename p6##_type, typename p7##_type, \
1070 
    typename p8##_type, typename p9##_type
1071 
 
1072 
// Initializes the value parameters.
1073 
#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
1074 
    ()
1075 
#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
1076 
    (p0##_type gmock_p0) : p0(gmock_p0)
1077 
#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
1078 
    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), p1(gmock_p1)
1079 
#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
1080 
    (p0##_type gmock_p0, p1##_type gmock_p1, \
1081 
        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2)
1082 
#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
1083 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1084 
        p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1085 
        p3(gmock_p3)
1086 
#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
1087 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1088 
        p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), \
1089 
        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4)
1090 
#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
1091 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1092 
        p3##_type gmock_p3, p4##_type gmock_p4, \
1093 
        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1094 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5)
1095 
#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
1096 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1097 
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1098 
        p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1099 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6)
1100 
#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
1101 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1102 
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1103 
        p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), \
1104 
        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1105 
        p7(gmock_p7)
1106 
#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1107 
    p7, p8)\
1108 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1109 
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1110 
        p6##_type gmock_p6, p7##_type gmock_p7, \
1111 
        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1112 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1113 
        p8(gmock_p8)
1114 
#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1115 
    p7, p8, p9)\
1116 
    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1117 
        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1118 
        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
1119 
        p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1120 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1121 
        p8(gmock_p8), p9(gmock_p9)
1122 
 
1123 
// Declares the fields for storing the value parameters.
1124 
#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
1125 
#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
1126 
#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
1127 
    p1##_type p1;
1128 
#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
1129 
    p1##_type p1; p2##_type p2;
1130 
#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
1131 
    p1##_type p1; p2##_type p2; p3##_type p3;
1132 
#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1133 
    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
1134 
#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1135 
    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1136 
    p5##_type p5;
1137 
#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1138 
    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1139 
    p5##_type p5; p6##_type p6;
1140 
#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1141 
    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
1142 
    p5##_type p5; p6##_type p6; p7##_type p7;
1143 
#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1144 
    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1145 
    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
1146 
#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1147 
    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
1148 
    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
1149 
    p9##_type p9;
1150 
 
1151 
// Lists the value parameters.
1152 
#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
1153 
#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
1154 
#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
1155 
#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
1156 
#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
1157 
#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
1158 
    p2, p3, p4
1159 
#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
1160 
    p1, p2, p3, p4, p5
1161 
#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1162 
    p6) p0, p1, p2, p3, p4, p5, p6
1163 
#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1164 
    p7) p0, p1, p2, p3, p4, p5, p6, p7
1165 
#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1166 
    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
1167 
#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1168 
    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
1169 
 
1170 
// Lists the value parameter types.
1171 
#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
1172 
#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
1173 
#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
1174 
    p1##_type
1175 
#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
1176 
    p1##_type, p2##_type
1177 
#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
1178 
    p0##_type, p1##_type, p2##_type, p3##_type
1179 
#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
1180 
    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
1181 
#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
1182 
    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
1183 
#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1184 
    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
1185 
    p6##_type
1186 
#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1187 
    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1188 
    p5##_type, p6##_type, p7##_type
1189 
#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1190 
    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1191 
    p5##_type, p6##_type, p7##_type, p8##_type
1192 
#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1193 
    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1194 
    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
1195 
 
1196 
// Declares the value parameters.
1197 
#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
1198 
#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
1199 
#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
1200 
    p1##_type p1
1201 
#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
1202 
    p1##_type p1, p2##_type p2
1203 
#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
1204 
    p1##_type p1, p2##_type p2, p3##_type p3
1205 
#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
1206 
    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
1207 
#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
1208 
    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1209 
    p5##_type p5
1210 
#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
1211 
    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1212 
    p5##_type p5, p6##_type p6
1213 
#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1214 
    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
1215 
    p5##_type p5, p6##_type p6, p7##_type p7
1216 
#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1217 
    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1218 
    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
1219 
#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1220 
    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1221 
    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
1222 
    p9##_type p9
1223 
 
1224 
// The suffix of the class template implementing the action template.
1225 
#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
1226 
#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
1227 
#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
1228 
#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
1229 
#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
1230 
#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
1231 
#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
1232 
#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
1233 
#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1234 
    p7) P8
1235 
#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1236 
    p7, p8) P9
1237 
#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
1238 
    p7, p8, p9) P10
1239 
 
1240 
// The name of the class template implementing the action template.
1241 
#define GMOCK_ACTION_CLASS_(name, value_params)\
1242 
    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
1243 
 
1244 
#define ACTION_TEMPLATE(name, template_params, value_params)\
1245 
  template <GMOCK_INTERNAL_DECL_##template_params\
1246 
            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1247 
  class GMOCK_ACTION_CLASS_(name, value_params) {\
1248 
   public:\
1249 
    explicit GMOCK_ACTION_CLASS_(name, value_params)\
1250 
        GMOCK_INTERNAL_INIT_##value_params {}\
1251 
    template <typename F>\
1252 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1253 
     public:\
1254 
      typedef F function_type;\
1255 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1256 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1257 
          args_type;\
1258 
      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\
1259 
      virtual return_type Perform(const args_type& args) {\
1260 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1261 
            Perform(this, args);\
1262 
      }\
1263 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1264 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1265 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1266 
          typename arg9_type>\
1267 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1268 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1269 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1270 
          arg9_type arg9) const;\
1271 
      GMOCK_INTERNAL_DEFN_##value_params\
1272 
     private:\
1273 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1274 
    };\
1275 
    template <typename F> operator ::testing::Action<F>() const {\
1276 
      return ::testing::Action<F>(\
1277 
          new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
1278 
    }\
1279 
    GMOCK_INTERNAL_DEFN_##value_params\
1280 
   private:\
1281 
    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
1282 
  };\
1283 
  template <GMOCK_INTERNAL_DECL_##template_params\
1284 
            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1285 
  inline GMOCK_ACTION_CLASS_(name, value_params)<\
1286 
      GMOCK_INTERNAL_LIST_##template_params\
1287 
      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\
1288 
          GMOCK_INTERNAL_DECL_##value_params) {\
1289 
    return GMOCK_ACTION_CLASS_(name, value_params)<\
1290 
        GMOCK_INTERNAL_LIST_##template_params\
1291 
        GMOCK_INTERNAL_LIST_TYPE_##value_params>(\
1292 
            GMOCK_INTERNAL_LIST_##value_params);\
1293 
  }\
1294 
  template <GMOCK_INTERNAL_DECL_##template_params\
1295 
            GMOCK_INTERNAL_DECL_TYPE_##value_params>\
1296 
  template <typename F>\
1297 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1298 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1299 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1300 
      typename arg9_type>\
1301 
  typename ::testing::internal::Function<F>::Result\
1302 
      GMOCK_ACTION_CLASS_(name, value_params)<\
1303 
          GMOCK_INTERNAL_LIST_##template_params\
1304 
          GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\
1305 
              gmock_PerformImpl(\
1306 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1307 
 
1308 
#define ACTION(name)\
1309 
  class name##Action {\
1310 
   public:\
1311 
    name##Action() {}\
1312 
    template <typename F>\
1313 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1314 
     public:\
1315 
      typedef F function_type;\
1316 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1317 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1318 
          args_type;\
1319 
      gmock_Impl() {}\
1320 
      virtual return_type Perform(const args_type& args) {\
1321 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1322 
            Perform(this, args);\
1323 
      }\
1324 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1325 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1326 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1327 
          typename arg9_type>\
1328 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1329 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1330 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1331 
          arg9_type arg9) const;\
1332 
     private:\
1333 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1334 
    };\
1335 
    template <typename F> operator ::testing::Action<F>() const {\
1336 
      return ::testing::Action<F>(new gmock_Impl<F>());\
1337 
    }\
1338 
   private:\
1339 
    GTEST_DISALLOW_ASSIGN_(name##Action);\
1340 
  };\
1341 
  inline name##Action name() {\
1342 
    return name##Action();\
1343 
  }\
1344 
  template <typename F>\
1345 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1346 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1347 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1348 
      typename arg9_type>\
1349 
  typename ::testing::internal::Function<F>::Result\
1350 
      name##Action::gmock_Impl<F>::gmock_PerformImpl(\
1351 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1352 
 
1353 
#define ACTION_P(name, p0)\
1354 
  template <typename p0##_type>\
1355 
  class name##ActionP {\
1356 
   public:\
1357 
    explicit name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\
1358 
    template <typename F>\
1359 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1360 
     public:\
1361 
      typedef F function_type;\
1362 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1363 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1364 
          args_type;\
1365 
      explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\
1366 
      virtual return_type Perform(const args_type& args) {\
1367 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1368 
            Perform(this, args);\
1369 
      }\
1370 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1371 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1372 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1373 
          typename arg9_type>\
1374 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1375 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1376 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1377 
          arg9_type arg9) const;\
1378 
      p0##_type p0;\
1379 
     private:\
1380 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1381 
    };\
1382 
    template <typename F> operator ::testing::Action<F>() const {\
1383 
      return ::testing::Action<F>(new gmock_Impl<F>(p0));\
1384 
    }\
1385 
    p0##_type p0;\
1386 
   private:\
1387 
    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
1388 
  };\
1389 
  template <typename p0##_type>\
1390 
  inline name##ActionP<p0##_type> name(p0##_type p0) {\
1391 
    return name##ActionP<p0##_type>(p0);\
1392 
  }\
1393 
  template <typename p0##_type>\
1394 
  template <typename F>\
1395 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1396 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1397 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1398 
      typename arg9_type>\
1399 
  typename ::testing::internal::Function<F>::Result\
1400 
      name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1401 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1402 
 
1403 
#define ACTION_P2(name, p0, p1)\
1404 
  template <typename p0##_type, typename p1##_type>\
1405 
  class name##ActionP2 {\
1406 
   public:\
1407 
    name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1408 
        p1(gmock_p1) {}\
1409 
    template <typename F>\
1410 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1411 
     public:\
1412 
      typedef F function_type;\
1413 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1414 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1415 
          args_type;\
1416 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \
1417 
          p1(gmock_p1) {}\
1418 
      virtual return_type Perform(const args_type& args) {\
1419 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1420 
            Perform(this, args);\
1421 
      }\
1422 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1423 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1424 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1425 
          typename arg9_type>\
1426 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1427 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1428 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1429 
          arg9_type arg9) const;\
1430 
      p0##_type p0;\
1431 
      p1##_type p1;\
1432 
     private:\
1433 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1434 
    };\
1435 
    template <typename F> operator ::testing::Action<F>() const {\
1436 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
1437 
    }\
1438 
    p0##_type p0;\
1439 
    p1##_type p1;\
1440 
   private:\
1441 
    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
1442 
  };\
1443 
  template <typename p0##_type, typename p1##_type>\
1444 
  inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
1445 
      p1##_type p1) {\
1446 
    return name##ActionP2<p0##_type, p1##_type>(p0, p1);\
1447 
  }\
1448 
  template <typename p0##_type, typename p1##_type>\
1449 
  template <typename F>\
1450 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1451 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1452 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1453 
      typename arg9_type>\
1454 
  typename ::testing::internal::Function<F>::Result\
1455 
      name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1456 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1457 
 
1458 
#define ACTION_P3(name, p0, p1, p2)\
1459 
  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1460 
  class name##ActionP3 {\
1461 
   public:\
1462 
    name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \
1463 
        p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1464 
    template <typename F>\
1465 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1466 
     public:\
1467 
      typedef F function_type;\
1468 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1469 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1470 
          args_type;\
1471 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \
1472 
          p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\
1473 
      virtual return_type Perform(const args_type& args) {\
1474 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1475 
            Perform(this, args);\
1476 
      }\
1477 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1478 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1479 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1480 
          typename arg9_type>\
1481 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1482 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1483 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1484 
          arg9_type arg9) const;\
1485 
      p0##_type p0;\
1486 
      p1##_type p1;\
1487 
      p2##_type p2;\
1488 
     private:\
1489 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1490 
    };\
1491 
    template <typename F> operator ::testing::Action<F>() const {\
1492 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
1493 
    }\
1494 
    p0##_type p0;\
1495 
    p1##_type p1;\
1496 
    p2##_type p2;\
1497 
   private:\
1498 
    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
1499 
  };\
1500 
  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1501 
  inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
1502 
      p1##_type p1, p2##_type p2) {\
1503 
    return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\
1504 
  }\
1505 
  template <typename p0##_type, typename p1##_type, typename p2##_type>\
1506 
  template <typename F>\
1507 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1508 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1509 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1510 
      typename arg9_type>\
1511 
  typename ::testing::internal::Function<F>::Result\
1512 
      name##ActionP3<p0##_type, p1##_type, \
1513 
          p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1514 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1515 
 
1516 
#define ACTION_P4(name, p0, p1, p2, p3)\
1517 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1518 
      typename p3##_type>\
1519 
  class name##ActionP4 {\
1520 
   public:\
1521 
    name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \
1522 
        p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \
1523 
        p2(gmock_p2), p3(gmock_p3) {}\
1524 
    template <typename F>\
1525 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1526 
     public:\
1527 
      typedef F function_type;\
1528 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1529 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1530 
          args_type;\
1531 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1532 
          p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1533 
          p3(gmock_p3) {}\
1534 
      virtual return_type Perform(const args_type& args) {\
1535 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1536 
            Perform(this, args);\
1537 
      }\
1538 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1539 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1540 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1541 
          typename arg9_type>\
1542 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1543 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1544 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1545 
          arg9_type arg9) const;\
1546 
      p0##_type p0;\
1547 
      p1##_type p1;\
1548 
      p2##_type p2;\
1549 
      p3##_type p3;\
1550 
     private:\
1551 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1552 
    };\
1553 
    template <typename F> operator ::testing::Action<F>() const {\
1554 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
1555 
    }\
1556 
    p0##_type p0;\
1557 
    p1##_type p1;\
1558 
    p2##_type p2;\
1559 
    p3##_type p3;\
1560 
   private:\
1561 
    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
1562 
  };\
1563 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1564 
      typename p3##_type>\
1565 
  inline name##ActionP4<p0##_type, p1##_type, p2##_type, \
1566 
      p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1567 
      p3##_type p3) {\
1568 
    return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \
1569 
        p2, p3);\
1570 
  }\
1571 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1572 
      typename p3##_type>\
1573 
  template <typename F>\
1574 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1575 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1576 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1577 
      typename arg9_type>\
1578 
  typename ::testing::internal::Function<F>::Result\
1579 
      name##ActionP4<p0##_type, p1##_type, p2##_type, \
1580 
          p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1581 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1582 
 
1583 
#define ACTION_P5(name, p0, p1, p2, p3, p4)\
1584 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1585 
      typename p3##_type, typename p4##_type>\
1586 
  class name##ActionP5 {\
1587 
   public:\
1588 
    name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \
1589 
        p2##_type gmock_p2, p3##_type gmock_p3, \
1590 
        p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1591 
        p3(gmock_p3), p4(gmock_p4) {}\
1592 
    template <typename F>\
1593 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1594 
     public:\
1595 
      typedef F function_type;\
1596 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1597 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1598 
          args_type;\
1599 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1600 
          p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \
1601 
          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\
1602 
      virtual return_type Perform(const args_type& args) {\
1603 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1604 
            Perform(this, args);\
1605 
      }\
1606 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1607 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1608 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1609 
          typename arg9_type>\
1610 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1611 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1612 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1613 
          arg9_type arg9) const;\
1614 
      p0##_type p0;\
1615 
      p1##_type p1;\
1616 
      p2##_type p2;\
1617 
      p3##_type p3;\
1618 
      p4##_type p4;\
1619 
     private:\
1620 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1621 
    };\
1622 
    template <typename F> operator ::testing::Action<F>() const {\
1623 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
1624 
    }\
1625 
    p0##_type p0;\
1626 
    p1##_type p1;\
1627 
    p2##_type p2;\
1628 
    p3##_type p3;\
1629 
    p4##_type p4;\
1630 
   private:\
1631 
    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
1632 
  };\
1633 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1634 
      typename p3##_type, typename p4##_type>\
1635 
  inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1636 
      p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1637 
      p4##_type p4) {\
1638 
    return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1639 
        p4##_type>(p0, p1, p2, p3, p4);\
1640 
  }\
1641 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1642 
      typename p3##_type, typename p4##_type>\
1643 
  template <typename F>\
1644 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1645 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1646 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1647 
      typename arg9_type>\
1648 
  typename ::testing::internal::Function<F>::Result\
1649 
      name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \
1650 
          p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1651 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1652 
 
1653 
#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\
1654 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1655 
      typename p3##_type, typename p4##_type, typename p5##_type>\
1656 
  class name##ActionP6 {\
1657 
   public:\
1658 
    name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \
1659 
        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1660 
        p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1661 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1662 
    template <typename F>\
1663 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1664 
     public:\
1665 
      typedef F function_type;\
1666 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1667 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1668 
          args_type;\
1669 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1670 
          p3##_type gmock_p3, p4##_type gmock_p4, \
1671 
          p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1672 
          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\
1673 
      virtual return_type Perform(const args_type& args) {\
1674 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1675 
            Perform(this, args);\
1676 
      }\
1677 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1678 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1679 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1680 
          typename arg9_type>\
1681 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1682 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1683 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1684 
          arg9_type arg9) const;\
1685 
      p0##_type p0;\
1686 
      p1##_type p1;\
1687 
      p2##_type p2;\
1688 
      p3##_type p3;\
1689 
      p4##_type p4;\
1690 
      p5##_type p5;\
1691 
     private:\
1692 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1693 
    };\
1694 
    template <typename F> operator ::testing::Action<F>() const {\
1695 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
1696 
    }\
1697 
    p0##_type p0;\
1698 
    p1##_type p1;\
1699 
    p2##_type p2;\
1700 
    p3##_type p3;\
1701 
    p4##_type p4;\
1702 
    p5##_type p5;\
1703 
   private:\
1704 
    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
1705 
  };\
1706 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1707 
      typename p3##_type, typename p4##_type, typename p5##_type>\
1708 
  inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1709 
      p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \
1710 
      p3##_type p3, p4##_type p4, p5##_type p5) {\
1711 
    return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \
1712 
        p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\
1713 
  }\
1714 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1715 
      typename p3##_type, typename p4##_type, typename p5##_type>\
1716 
  template <typename F>\
1717 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1718 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1719 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1720 
      typename arg9_type>\
1721 
  typename ::testing::internal::Function<F>::Result\
1722 
      name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1723 
          p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1724 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1725 
 
1726 
#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\
1727 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1728 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1729 
      typename p6##_type>\
1730 
  class name##ActionP7 {\
1731 
   public:\
1732 
    name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \
1733 
        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1734 
        p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \
1735 
        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \
1736 
        p6(gmock_p6) {}\
1737 
    template <typename F>\
1738 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1739 
     public:\
1740 
      typedef F function_type;\
1741 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1742 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1743 
          args_type;\
1744 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1745 
          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1746 
          p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1747 
          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\
1748 
      virtual return_type Perform(const args_type& args) {\
1749 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1750 
            Perform(this, args);\
1751 
      }\
1752 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1753 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1754 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1755 
          typename arg9_type>\
1756 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1757 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1758 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1759 
          arg9_type arg9) const;\
1760 
      p0##_type p0;\
1761 
      p1##_type p1;\
1762 
      p2##_type p2;\
1763 
      p3##_type p3;\
1764 
      p4##_type p4;\
1765 
      p5##_type p5;\
1766 
      p6##_type p6;\
1767 
     private:\
1768 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1769 
    };\
1770 
    template <typename F> operator ::testing::Action<F>() const {\
1771 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1772 
          p6));\
1773 
    }\
1774 
    p0##_type p0;\
1775 
    p1##_type p1;\
1776 
    p2##_type p2;\
1777 
    p3##_type p3;\
1778 
    p4##_type p4;\
1779 
    p5##_type p5;\
1780 
    p6##_type p6;\
1781 
   private:\
1782 
    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
1783 
  };\
1784 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1785 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1786 
      typename p6##_type>\
1787 
  inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1788 
      p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \
1789 
      p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1790 
      p6##_type p6) {\
1791 
    return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \
1792 
        p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\
1793 
  }\
1794 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1795 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1796 
      typename p6##_type>\
1797 
  template <typename F>\
1798 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1799 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1800 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1801 
      typename arg9_type>\
1802 
  typename ::testing::internal::Function<F>::Result\
1803 
      name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1804 
          p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1805 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1806 
 
1807 
#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\
1808 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1809 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1810 
      typename p6##_type, typename p7##_type>\
1811 
  class name##ActionP8 {\
1812 
   public:\
1813 
    name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \
1814 
        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1815 
        p5##_type gmock_p5, p6##_type gmock_p6, \
1816 
        p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1817 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1818 
        p7(gmock_p7) {}\
1819 
    template <typename F>\
1820 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1821 
     public:\
1822 
      typedef F function_type;\
1823 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1824 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1825 
          args_type;\
1826 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1827 
          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1828 
          p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \
1829 
          p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \
1830 
          p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\
1831 
      virtual return_type Perform(const args_type& args) {\
1832 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1833 
            Perform(this, args);\
1834 
      }\
1835 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1836 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1837 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1838 
          typename arg9_type>\
1839 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1840 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1841 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1842 
          arg9_type arg9) const;\
1843 
      p0##_type p0;\
1844 
      p1##_type p1;\
1845 
      p2##_type p2;\
1846 
      p3##_type p3;\
1847 
      p4##_type p4;\
1848 
      p5##_type p5;\
1849 
      p6##_type p6;\
1850 
      p7##_type p7;\
1851 
     private:\
1852 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1853 
    };\
1854 
    template <typename F> operator ::testing::Action<F>() const {\
1855 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1856 
          p6, p7));\
1857 
    }\
1858 
    p0##_type p0;\
1859 
    p1##_type p1;\
1860 
    p2##_type p2;\
1861 
    p3##_type p3;\
1862 
    p4##_type p4;\
1863 
    p5##_type p5;\
1864 
    p6##_type p6;\
1865 
    p7##_type p7;\
1866 
   private:\
1867 
    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
1868 
  };\
1869 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1870 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1871 
      typename p6##_type, typename p7##_type>\
1872 
  inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1873 
      p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \
1874 
      p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \
1875 
      p6##_type p6, p7##_type p7) {\
1876 
    return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \
1877 
        p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \
1878 
        p6, p7);\
1879 
  }\
1880 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1881 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1882 
      typename p6##_type, typename p7##_type>\
1883 
  template <typename F>\
1884 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1885 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1886 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1887 
      typename arg9_type>\
1888 
  typename ::testing::internal::Function<F>::Result\
1889 
      name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1890 
          p5##_type, p6##_type, \
1891 
          p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1892 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1893 
 
1894 
#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\
1895 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1896 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1897 
      typename p6##_type, typename p7##_type, typename p8##_type>\
1898 
  class name##ActionP9 {\
1899 
   public:\
1900 
    name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \
1901 
        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1902 
        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1903 
        p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1904 
        p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \
1905 
        p8(gmock_p8) {}\
1906 
    template <typename F>\
1907 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
1908 
     public:\
1909 
      typedef F function_type;\
1910 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
1911 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
1912 
          args_type;\
1913 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
1914 
          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
1915 
          p6##_type gmock_p6, p7##_type gmock_p7, \
1916 
          p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
1917 
          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1918 
          p7(gmock_p7), p8(gmock_p8) {}\
1919 
      virtual return_type Perform(const args_type& args) {\
1920 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
1921 
            Perform(this, args);\
1922 
      }\
1923 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
1924 
          typename arg3_type, typename arg4_type, typename arg5_type, \
1925 
          typename arg6_type, typename arg7_type, typename arg8_type, \
1926 
          typename arg9_type>\
1927 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
1928 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
1929 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
1930 
          arg9_type arg9) const;\
1931 
      p0##_type p0;\
1932 
      p1##_type p1;\
1933 
      p2##_type p2;\
1934 
      p3##_type p3;\
1935 
      p4##_type p4;\
1936 
      p5##_type p5;\
1937 
      p6##_type p6;\
1938 
      p7##_type p7;\
1939 
      p8##_type p8;\
1940 
     private:\
1941 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
1942 
    };\
1943 
    template <typename F> operator ::testing::Action<F>() const {\
1944 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
1945 
          p6, p7, p8));\
1946 
    }\
1947 
    p0##_type p0;\
1948 
    p1##_type p1;\
1949 
    p2##_type p2;\
1950 
    p3##_type p3;\
1951 
    p4##_type p4;\
1952 
    p5##_type p5;\
1953 
    p6##_type p6;\
1954 
    p7##_type p7;\
1955 
    p8##_type p8;\
1956 
   private:\
1957 
    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
1958 
  };\
1959 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1960 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1961 
      typename p6##_type, typename p7##_type, typename p8##_type>\
1962 
  inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1963 
      p4##_type, p5##_type, p6##_type, p7##_type, \
1964 
      p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
1965 
      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \
1966 
      p8##_type p8) {\
1967 
    return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \
1968 
        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \
1969 
        p3, p4, p5, p6, p7, p8);\
1970 
  }\
1971 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1972 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1973 
      typename p6##_type, typename p7##_type, typename p8##_type>\
1974 
  template <typename F>\
1975 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
1976 
      typename arg3_type, typename arg4_type, typename arg5_type, \
1977 
      typename arg6_type, typename arg7_type, typename arg8_type, \
1978 
      typename arg9_type>\
1979 
  typename ::testing::internal::Function<F>::Result\
1980 
      name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
1981 
          p5##_type, p6##_type, p7##_type, \
1982 
          p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\
1983 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1984 
 
1985 
#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\
1986 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
1987 
      typename p3##_type, typename p4##_type, typename p5##_type, \
1988 
      typename p6##_type, typename p7##_type, typename p8##_type, \
1989 
      typename p9##_type>\
1990 
  class name##ActionP10 {\
1991 
   public:\
1992 
    name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \
1993 
        p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \
1994 
        p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \
1995 
        p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \
1996 
        p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
1997 
        p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
1998 
    template <typename F>\
1999 
    class gmock_Impl : public ::testing::ActionInterface<F> {\
2000 
     public:\
2001 
      typedef F function_type;\
2002 
      typedef typename ::testing::internal::Function<F>::Result return_type;\
2003 
      typedef typename ::testing::internal::Function<F>::ArgumentTuple\
2004 
          args_type;\
2005 
      gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
2006 
          p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
2007 
          p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
2008 
          p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \
2009 
          p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \
2010 
          p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\
2011 
      virtual return_type Perform(const args_type& args) {\
2012 
        return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\
2013 
            Perform(this, args);\
2014 
      }\
2015 
      template <typename arg0_type, typename arg1_type, typename arg2_type, \
2016 
          typename arg3_type, typename arg4_type, typename arg5_type, \
2017 
          typename arg6_type, typename arg7_type, typename arg8_type, \
2018 
          typename arg9_type>\
2019 
      return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \
2020 
          arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
2021 
          arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
2022 
          arg9_type arg9) const;\
2023 
      p0##_type p0;\
2024 
      p1##_type p1;\
2025 
      p2##_type p2;\
2026 
      p3##_type p3;\
2027 
      p4##_type p4;\
2028 
      p5##_type p5;\
2029 
      p6##_type p6;\
2030 
      p7##_type p7;\
2031 
      p8##_type p8;\
2032 
      p9##_type p9;\
2033 
     private:\
2034 
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
2035 
    };\
2036 
    template <typename F> operator ::testing::Action<F>() const {\
2037 
      return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
2038 
          p6, p7, p8, p9));\
2039 
    }\
2040 
    p0##_type p0;\
2041 
    p1##_type p1;\
2042 
    p2##_type p2;\
2043 
    p3##_type p3;\
2044 
    p4##_type p4;\
2045 
    p5##_type p5;\
2046 
    p6##_type p6;\
2047 
    p7##_type p7;\
2048 
    p8##_type p8;\
2049 
    p9##_type p9;\
2050 
   private:\
2051 
    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
2052 
  };\
2053 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
2054 
      typename p3##_type, typename p4##_type, typename p5##_type, \
2055 
      typename p6##_type, typename p7##_type, typename p8##_type, \
2056 
      typename p9##_type>\
2057 
  inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2058 
      p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \
2059 
      p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
2060 
      p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
2061 
      p9##_type p9) {\
2062 
    return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \
2063 
        p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \
2064 
        p1, p2, p3, p4, p5, p6, p7, p8, p9);\
2065 
  }\
2066 
  template <typename p0##_type, typename p1##_type, typename p2##_type, \
2067 
      typename p3##_type, typename p4##_type, typename p5##_type, \
2068 
      typename p6##_type, typename p7##_type, typename p8##_type, \
2069 
      typename p9##_type>\
2070 
  template <typename F>\
2071 
  template <typename arg0_type, typename arg1_type, typename arg2_type, \
2072 
      typename arg3_type, typename arg4_type, typename arg5_type, \
2073 
      typename arg6_type, typename arg7_type, typename arg8_type, \
2074 
      typename arg9_type>\
2075 
  typename ::testing::internal::Function<F>::Result\
2076 
      name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
2077 
          p5##_type, p6##_type, p7##_type, p8##_type, \
2078 
          p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\
2079 
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
2080 
 
2081 
namespace testing {
2082 
 
2083 
 
2084 
// The ACTION*() macros trigger warning C4100 (unreferenced formal
2085 
// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
2086 
// the macro definition, as the warnings are generated when the macro
2087 
// is expanded and macro expansion cannot contain #pragma.  Therefore
2088 
// we suppress them here.
2089 
#ifdef _MSC_VER
2090 
# pragma warning(push)
2091 
# pragma warning(disable:4100)
2092 
#endif
2093 
 
2094 
// Various overloads for InvokeArgument<N>().
2095 
//
2096 
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
2097 
// (0-based) argument, which must be a k-ary callable, of the mock
2098 
// function, with arguments a1, a2, ..., a_k.
2099 
//
2100 
// Notes:
2101 
//
2102 
//   1. The arguments are passed by value by default.  If you need to
2103 
//   pass an argument by reference, wrap it inside ByRef().  For
2104 
//   example,
2105 
//
2106 
//     InvokeArgument<1>(5, string("Hello"), ByRef(foo))
2107 
//
2108 
//   passes 5 and string("Hello") by value, and passes foo by
2109 
//   reference.
2110 
//
2111 
//   2. If the callable takes an argument by reference but ByRef() is
2112 
//   not used, it will receive the reference to a copy of the value,
2113 
//   instead of the original value.  For example, when the 0-th
2114 
//   argument of the mock function takes a const string&, the action
2115 
//
2116 
//     InvokeArgument<0>(string("Hello"))
2117 
//
2118 
//   makes a copy of the temporary string("Hello") object and passes a
2119 
//   reference of the copy, instead of the original temporary object,
2120 
//   to the callable.  This makes it easy for a user to define an
2121 
//   InvokeArgument action from temporary values and have it performed
2122 
//   later.
2123 
 
2124 
namespace internal {
2125 
namespace invoke_argument {
2126 
 
2127 
// Appears in InvokeArgumentAdl's argument list to help avoid
2128 
// accidental calls to user functions of the same name.
2129 
struct AdlTag {};
2130 
 
2131 
// InvokeArgumentAdl - a helper for InvokeArgument.
2132 
// The basic overloads are provided here for generic functors.
2133 
// Overloads for other custom-callables are provided in the
2134 
// internal/custom/callback-actions.h header.
2135 
 
2136 
template <typename R, typename F>
2137 
R InvokeArgumentAdl(AdlTag, F f) {
2138 
  return f();
2139 
}
2140 
template <typename R, typename F, typename A1>
2141 
R InvokeArgumentAdl(AdlTag, F f, A1 a1) {
2142 
  return f(a1);
2143 
}
2144 
template <typename R, typename F, typename A1, typename A2>
2145 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) {
2146 
  return f(a1, a2);
2147 
}
2148 
template <typename R, typename F, typename A1, typename A2, typename A3>
2149 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) {
2150 
  return f(a1, a2, a3);
2151 
}
2152 
template <typename R, typename F, typename A1, typename A2, typename A3,
2153 
    typename A4>
2154 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) {
2155 
  return f(a1, a2, a3, a4);
2156 
}
2157 
template <typename R, typename F, typename A1, typename A2, typename A3,
2158 
    typename A4, typename A5>
2159 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
2160 
  return f(a1, a2, a3, a4, a5);
2161 
}
2162 
template <typename R, typename F, typename A1, typename A2, typename A3,
2163 
    typename A4, typename A5, typename A6>
2164 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
2165 
  return f(a1, a2, a3, a4, a5, a6);
2166 
}
2167 
template <typename R, typename F, typename A1, typename A2, typename A3,
2168 
    typename A4, typename A5, typename A6, typename A7>
2169 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2170 
    A7 a7) {
2171 
  return f(a1, a2, a3, a4, a5, a6, a7);
2172 
}
2173 
template <typename R, typename F, typename A1, typename A2, typename A3,
2174 
    typename A4, typename A5, typename A6, typename A7, typename A8>
2175 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2176 
    A7 a7, A8 a8) {
2177 
  return f(a1, a2, a3, a4, a5, a6, a7, a8);
2178 
}
2179 
template <typename R, typename F, typename A1, typename A2, typename A3,
2180 
    typename A4, typename A5, typename A6, typename A7, typename A8,
2181 
    typename A9>
2182 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2183 
    A7 a7, A8 a8, A9 a9) {
2184 
  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2185 
}
2186 
template <typename R, typename F, typename A1, typename A2, typename A3,
2187 
    typename A4, typename A5, typename A6, typename A7, typename A8,
2188 
    typename A9, typename A10>
2189 
R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6,
2190 
    A7 a7, A8 a8, A9 a9, A10 a10) {
2191 
  return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2192 
}
2193 
}  // namespace invoke_argument
2194 
}  // namespace internal
2195 
 
2196 
ACTION_TEMPLATE(InvokeArgument,
2197 
                HAS_1_TEMPLATE_PARAMS(int, k),
2198 
                AND_0_VALUE_PARAMS()) {
2199 
  using internal::invoke_argument::InvokeArgumentAdl;
2200 
  return InvokeArgumentAdl<return_type>(
2201 
      internal::invoke_argument::AdlTag(),
2202 
      ::testing::get<k>(args));
2203 
}
2204 
 
2205 
ACTION_TEMPLATE(InvokeArgument,
2206 
                HAS_1_TEMPLATE_PARAMS(int, k),
2207 
                AND_1_VALUE_PARAMS(p0)) {
2208 
  using internal::invoke_argument::InvokeArgumentAdl;
2209 
  return InvokeArgumentAdl<return_type>(
2210 
      internal::invoke_argument::AdlTag(),
2211 
      ::testing::get<k>(args), p0);
2212 
}
2213 
 
2214 
ACTION_TEMPLATE(InvokeArgument,
2215 
                HAS_1_TEMPLATE_PARAMS(int, k),
2216 
                AND_2_VALUE_PARAMS(p0, p1)) {
2217 
  using internal::invoke_argument::InvokeArgumentAdl;
2218 
  return InvokeArgumentAdl<return_type>(
2219 
      internal::invoke_argument::AdlTag(),
2220 
      ::testing::get<k>(args), p0, p1);
2221 
}
2222 
 
2223 
ACTION_TEMPLATE(InvokeArgument,
2224 
                HAS_1_TEMPLATE_PARAMS(int, k),
2225 
                AND_3_VALUE_PARAMS(p0, p1, p2)) {
2226 
  using internal::invoke_argument::InvokeArgumentAdl;
2227 
  return InvokeArgumentAdl<return_type>(
2228 
      internal::invoke_argument::AdlTag(),
2229 
      ::testing::get<k>(args), p0, p1, p2);
2230 
}
2231 
 
2232 
ACTION_TEMPLATE(InvokeArgument,
2233 
                HAS_1_TEMPLATE_PARAMS(int, k),
2234 
                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2235 
  using internal::invoke_argument::InvokeArgumentAdl;
2236 
  return InvokeArgumentAdl<return_type>(
2237 
      internal::invoke_argument::AdlTag(),
2238 
      ::testing::get<k>(args), p0, p1, p2, p3);
2239 
}
2240 
 
2241 
ACTION_TEMPLATE(InvokeArgument,
2242 
                HAS_1_TEMPLATE_PARAMS(int, k),
2243 
                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2244 
  using internal::invoke_argument::InvokeArgumentAdl;
2245 
  return InvokeArgumentAdl<return_type>(
2246 
      internal::invoke_argument::AdlTag(),
2247 
      ::testing::get<k>(args), p0, p1, p2, p3, p4);
2248 
}
2249 
 
2250 
ACTION_TEMPLATE(InvokeArgument,
2251 
                HAS_1_TEMPLATE_PARAMS(int, k),
2252 
                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2253 
  using internal::invoke_argument::InvokeArgumentAdl;
2254 
  return InvokeArgumentAdl<return_type>(
2255 
      internal::invoke_argument::AdlTag(),
2256 
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5);
2257 
}
2258 
 
2259 
ACTION_TEMPLATE(InvokeArgument,
2260 
                HAS_1_TEMPLATE_PARAMS(int, k),
2261 
                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2262 
  using internal::invoke_argument::InvokeArgumentAdl;
2263 
  return InvokeArgumentAdl<return_type>(
2264 
      internal::invoke_argument::AdlTag(),
2265 
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6);
2266 
}
2267 
 
2268 
ACTION_TEMPLATE(InvokeArgument,
2269 
                HAS_1_TEMPLATE_PARAMS(int, k),
2270 
                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2271 
  using internal::invoke_argument::InvokeArgumentAdl;
2272 
  return InvokeArgumentAdl<return_type>(
2273 
      internal::invoke_argument::AdlTag(),
2274 
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7);
2275 
}
2276 
 
2277 
ACTION_TEMPLATE(InvokeArgument,
2278 
                HAS_1_TEMPLATE_PARAMS(int, k),
2279 
                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2280 
  using internal::invoke_argument::InvokeArgumentAdl;
2281 
  return InvokeArgumentAdl<return_type>(
2282 
      internal::invoke_argument::AdlTag(),
2283 
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8);
2284 
}
2285 
 
2286 
ACTION_TEMPLATE(InvokeArgument,
2287 
                HAS_1_TEMPLATE_PARAMS(int, k),
2288 
                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2289 
  using internal::invoke_argument::InvokeArgumentAdl;
2290 
  return InvokeArgumentAdl<return_type>(
2291 
      internal::invoke_argument::AdlTag(),
2292 
      ::testing::get<k>(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2293 
}
2294 
 
2295 
// Various overloads for ReturnNew<T>().
2296 
//
2297 
// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
2298 
// instance of type T, constructed on the heap with constructor arguments
2299 
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
2300 
ACTION_TEMPLATE(ReturnNew,
2301 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2302 
                AND_0_VALUE_PARAMS()) {
2303 
  return new T();
2304 
}
2305 
 
2306 
ACTION_TEMPLATE(ReturnNew,
2307 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2308 
                AND_1_VALUE_PARAMS(p0)) {
2309 
  return new T(p0);
2310 
}
2311 
 
2312 
ACTION_TEMPLATE(ReturnNew,
2313 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2314 
                AND_2_VALUE_PARAMS(p0, p1)) {
2315 
  return new T(p0, p1);
2316 
}
2317 
 
2318 
ACTION_TEMPLATE(ReturnNew,
2319 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2320 
                AND_3_VALUE_PARAMS(p0, p1, p2)) {
2321 
  return new T(p0, p1, p2);
2322 
}
2323 
 
2324 
ACTION_TEMPLATE(ReturnNew,
2325 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2326 
                AND_4_VALUE_PARAMS(p0, p1, p2, p3)) {
2327 
  return new T(p0, p1, p2, p3);
2328 
}
2329 
 
2330 
ACTION_TEMPLATE(ReturnNew,
2331 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2332 
                AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) {
2333 
  return new T(p0, p1, p2, p3, p4);
2334 
}
2335 
 
2336 
ACTION_TEMPLATE(ReturnNew,
2337 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2338 
                AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) {
2339 
  return new T(p0, p1, p2, p3, p4, p5);
2340 
}
2341 
 
2342 
ACTION_TEMPLATE(ReturnNew,
2343 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2344 
                AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) {
2345 
  return new T(p0, p1, p2, p3, p4, p5, p6);
2346 
}
2347 
 
2348 
ACTION_TEMPLATE(ReturnNew,
2349 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2350 
                AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) {
2351 
  return new T(p0, p1, p2, p3, p4, p5, p6, p7);
2352 
}
2353 
 
2354 
ACTION_TEMPLATE(ReturnNew,
2355 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2356 
                AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) {
2357 
  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8);
2358 
}
2359 
 
2360 
ACTION_TEMPLATE(ReturnNew,
2361 
                HAS_1_TEMPLATE_PARAMS(typename, T),
2362 
                AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) {
2363 
  return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
2364 
}
2365 
 
2366 
#ifdef _MSC_VER
2367 
# pragma warning(pop)
2368 
#endif
2369 
 
2370 
}  // namespace testing
2371 
 
2372 
// Include any custom actions added by the local installation.
2373 
// We must include this header at the end to make sure it can use the
2374 
// declarations from this file.
2375 
#include "gmock/internal/custom/gmock-generated-actions.h"
2376 
 
2377 
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.