src/external/gmock-1.6.0/include/gmock/gmock-generated-actions.h

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