3rdparty/googletest-1.8.1/googlemock/include/gmock/gmock-generated-actions.h

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