Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  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_
  2568.