113481Sgiacomo.travaglini@arm.com$$ -*- mode: c++; -*- 213481Sgiacomo.travaglini@arm.com$$ This is a Pump source file. Please use Pump to convert it to 313481Sgiacomo.travaglini@arm.com$$ gmock-generated-actions.h. 413481Sgiacomo.travaglini@arm.com$$ 513481Sgiacomo.travaglini@arm.com$var n = 10 $$ The maximum arity we support. 613481Sgiacomo.travaglini@arm.com$$}} This meta comment fixes auto-indentation in editors. 713481Sgiacomo.travaglini@arm.com// Copyright 2007, Google Inc. 813481Sgiacomo.travaglini@arm.com// All rights reserved. 913481Sgiacomo.travaglini@arm.com// 1013481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 1113481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 1213481Sgiacomo.travaglini@arm.com// met: 1313481Sgiacomo.travaglini@arm.com// 1413481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 1513481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1613481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1713481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1813481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1913481Sgiacomo.travaglini@arm.com// distribution. 2013481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 2113481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 2213481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 2313481Sgiacomo.travaglini@arm.com// 2413481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2513481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2613481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2713481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2813481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2913481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 3013481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 3113481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 3213481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 3313481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 3413481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 3513481Sgiacomo.travaglini@arm.com// 3613481Sgiacomo.travaglini@arm.com// Author: wan@google.com (Zhanyong Wan) 3713481Sgiacomo.travaglini@arm.com 3813481Sgiacomo.travaglini@arm.com// Google Mock - a framework for writing C++ mock classes. 3913481Sgiacomo.travaglini@arm.com// 4013481Sgiacomo.travaglini@arm.com// This file implements some commonly used variadic actions. 4113481Sgiacomo.travaglini@arm.com 4213481Sgiacomo.travaglini@arm.com#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 4313481Sgiacomo.travaglini@arm.com#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 4413481Sgiacomo.travaglini@arm.com 4513481Sgiacomo.travaglini@arm.com#include "gmock/gmock-actions.h" 4613481Sgiacomo.travaglini@arm.com#include "gmock/internal/gmock-port.h" 4713481Sgiacomo.travaglini@arm.com 4813481Sgiacomo.travaglini@arm.comnamespace testing { 4913481Sgiacomo.travaglini@arm.comnamespace internal { 5013481Sgiacomo.travaglini@arm.com 5113481Sgiacomo.travaglini@arm.com// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary 5213481Sgiacomo.travaglini@arm.com// function or method with the unpacked values, where F is a function 5313481Sgiacomo.travaglini@arm.com// type that takes N arguments. 5413481Sgiacomo.travaglini@arm.comtemplate <typename Result, typename ArgumentTuple> 5513481Sgiacomo.travaglini@arm.comclass InvokeHelper; 5613481Sgiacomo.travaglini@arm.com 5713481Sgiacomo.travaglini@arm.com 5813481Sgiacomo.travaglini@arm.com$range i 0..n 5913481Sgiacomo.travaglini@arm.com$for i [[ 6013481Sgiacomo.travaglini@arm.com$range j 1..i 6113481Sgiacomo.travaglini@arm.com$var types = [[$for j [[, typename A$j]]]] 6213481Sgiacomo.travaglini@arm.com$var as = [[$for j, [[A$j]]]] 6313481Sgiacomo.travaglini@arm.com$var args = [[$if i==0 [[]] $else [[ args]]]] 6413481Sgiacomo.travaglini@arm.com$var gets = [[$for j, [[get<$(j - 1)>(args)]]]] 6513481Sgiacomo.travaglini@arm.comtemplate <typename R$types> 6613481Sgiacomo.travaglini@arm.comclass InvokeHelper<R, ::testing::tuple<$as> > { 6713481Sgiacomo.travaglini@arm.com public: 6813481Sgiacomo.travaglini@arm.com template <typename Function> 6913481Sgiacomo.travaglini@arm.com static R Invoke(Function function, const ::testing::tuple<$as>&$args) { 7013481Sgiacomo.travaglini@arm.com return function($gets); 7113481Sgiacomo.travaglini@arm.com } 7213481Sgiacomo.travaglini@arm.com 7313481Sgiacomo.travaglini@arm.com template <class Class, typename MethodPtr> 7413481Sgiacomo.travaglini@arm.com static R InvokeMethod(Class* obj_ptr, 7513481Sgiacomo.travaglini@arm.com MethodPtr method_ptr, 7613481Sgiacomo.travaglini@arm.com const ::testing::tuple<$as>&$args) { 7713481Sgiacomo.travaglini@arm.com return (obj_ptr->*method_ptr)($gets); 7813481Sgiacomo.travaglini@arm.com } 7913481Sgiacomo.travaglini@arm.com}; 8013481Sgiacomo.travaglini@arm.com 8113481Sgiacomo.travaglini@arm.com 8213481Sgiacomo.travaglini@arm.com]] 8313481Sgiacomo.travaglini@arm.com// An INTERNAL macro for extracting the type of a tuple field. It's 8413481Sgiacomo.travaglini@arm.com// subject to change without notice - DO NOT USE IN USER CODE! 8513481Sgiacomo.travaglini@arm.com#define GMOCK_FIELD_(Tuple, N) \ 8613481Sgiacomo.travaglini@arm.com typename ::testing::tuple_element<N, Tuple>::type 8713481Sgiacomo.travaglini@arm.com 8813481Sgiacomo.travaglini@arm.com$range i 1..n 8913481Sgiacomo.travaglini@arm.com 9013481Sgiacomo.travaglini@arm.com// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the 9113481Sgiacomo.travaglini@arm.com// type of an n-ary function whose i-th (1-based) argument type is the 9213481Sgiacomo.travaglini@arm.com// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple 9313481Sgiacomo.travaglini@arm.com// type, and whose return type is Result. For example, 9413481Sgiacomo.travaglini@arm.com// SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type 9513481Sgiacomo.travaglini@arm.com// is int(bool, long). 9613481Sgiacomo.travaglini@arm.com// 9713481Sgiacomo.travaglini@arm.com// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args) 9813481Sgiacomo.travaglini@arm.com// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. 9913481Sgiacomo.travaglini@arm.com// For example, 10013481Sgiacomo.travaglini@arm.com// SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select( 10113481Sgiacomo.travaglini@arm.com// ::testing::make_tuple(true, 'a', 2.5)) 10213481Sgiacomo.travaglini@arm.com// returns tuple (2.5, true). 10313481Sgiacomo.travaglini@arm.com// 10413481Sgiacomo.travaglini@arm.com// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be 10513481Sgiacomo.travaglini@arm.com// in the range [0, $n]. Duplicates are allowed and they don't have 10613481Sgiacomo.travaglini@arm.com// to be in an ascending or descending order. 10713481Sgiacomo.travaglini@arm.com 10813481Sgiacomo.travaglini@arm.comtemplate <typename Result, typename ArgumentTuple, $for i, [[int k$i]]> 10913481Sgiacomo.travaglini@arm.comclass SelectArgs { 11013481Sgiacomo.travaglini@arm.com public: 11113481Sgiacomo.travaglini@arm.com typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]); 11213481Sgiacomo.travaglini@arm.com typedef typename Function<type>::ArgumentTuple SelectedArgs; 11313481Sgiacomo.travaglini@arm.com static SelectedArgs Select(const ArgumentTuple& args) { 11413481Sgiacomo.travaglini@arm.com return SelectedArgs($for i, [[get<k$i>(args)]]); 11513481Sgiacomo.travaglini@arm.com } 11613481Sgiacomo.travaglini@arm.com}; 11713481Sgiacomo.travaglini@arm.com 11813481Sgiacomo.travaglini@arm.com 11913481Sgiacomo.travaglini@arm.com$for i [[ 12013481Sgiacomo.travaglini@arm.com$range j 1..n 12113481Sgiacomo.travaglini@arm.com$range j1 1..i-1 12213481Sgiacomo.travaglini@arm.comtemplate <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]> 12313481Sgiacomo.travaglini@arm.comclass SelectArgs<Result, ArgumentTuple, 12413481Sgiacomo.travaglini@arm.com $for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> { 12513481Sgiacomo.travaglini@arm.com public: 12613481Sgiacomo.travaglini@arm.com typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]); 12713481Sgiacomo.travaglini@arm.com typedef typename Function<type>::ArgumentTuple SelectedArgs; 12813481Sgiacomo.travaglini@arm.com static SelectedArgs Select(const ArgumentTuple& [[]] 12913481Sgiacomo.travaglini@arm.com$if i == 1 [[/* args */]] $else [[args]]) { 13013481Sgiacomo.travaglini@arm.com return SelectedArgs($for j1, [[get<k$j1>(args)]]); 13113481Sgiacomo.travaglini@arm.com } 13213481Sgiacomo.travaglini@arm.com}; 13313481Sgiacomo.travaglini@arm.com 13413481Sgiacomo.travaglini@arm.com 13513481Sgiacomo.travaglini@arm.com]] 13613481Sgiacomo.travaglini@arm.com#undef GMOCK_FIELD_ 13713481Sgiacomo.travaglini@arm.com 13813481Sgiacomo.travaglini@arm.com$var ks = [[$for i, [[k$i]]]] 13913481Sgiacomo.travaglini@arm.com 14013481Sgiacomo.travaglini@arm.com// Implements the WithArgs action. 14113481Sgiacomo.travaglini@arm.comtemplate <typename InnerAction, $for i, [[int k$i = -1]]> 14213481Sgiacomo.travaglini@arm.comclass WithArgsAction { 14313481Sgiacomo.travaglini@arm.com public: 14413481Sgiacomo.travaglini@arm.com explicit WithArgsAction(const InnerAction& action) : action_(action) {} 14513481Sgiacomo.travaglini@arm.com 14613481Sgiacomo.travaglini@arm.com template <typename F> 14713481Sgiacomo.travaglini@arm.com operator Action<F>() const { return MakeAction(new Impl<F>(action_)); } 14813481Sgiacomo.travaglini@arm.com 14913481Sgiacomo.travaglini@arm.com private: 15013481Sgiacomo.travaglini@arm.com template <typename F> 15113481Sgiacomo.travaglini@arm.com class Impl : public ActionInterface<F> { 15213481Sgiacomo.travaglini@arm.com public: 15313481Sgiacomo.travaglini@arm.com typedef typename Function<F>::Result Result; 15413481Sgiacomo.travaglini@arm.com typedef typename Function<F>::ArgumentTuple ArgumentTuple; 15513481Sgiacomo.travaglini@arm.com 15613481Sgiacomo.travaglini@arm.com explicit Impl(const InnerAction& action) : action_(action) {} 15713481Sgiacomo.travaglini@arm.com 15813481Sgiacomo.travaglini@arm.com virtual Result Perform(const ArgumentTuple& args) { 15913481Sgiacomo.travaglini@arm.com return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args)); 16013481Sgiacomo.travaglini@arm.com } 16113481Sgiacomo.travaglini@arm.com 16213481Sgiacomo.travaglini@arm.com private: 16313481Sgiacomo.travaglini@arm.com typedef typename SelectArgs<Result, ArgumentTuple, 16413481Sgiacomo.travaglini@arm.com $ks>::type InnerFunctionType; 16513481Sgiacomo.travaglini@arm.com 16613481Sgiacomo.travaglini@arm.com Action<InnerFunctionType> action_; 16713481Sgiacomo.travaglini@arm.com }; 16813481Sgiacomo.travaglini@arm.com 16913481Sgiacomo.travaglini@arm.com const InnerAction action_; 17013481Sgiacomo.travaglini@arm.com 17113481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(WithArgsAction); 17213481Sgiacomo.travaglini@arm.com}; 17313481Sgiacomo.travaglini@arm.com 17413481Sgiacomo.travaglini@arm.com// A macro from the ACTION* family (defined later in this file) 17513481Sgiacomo.travaglini@arm.com// defines an action that can be used in a mock function. Typically, 17613481Sgiacomo.travaglini@arm.com// these actions only care about a subset of the arguments of the mock 17713481Sgiacomo.travaglini@arm.com// function. For example, if such an action only uses the second 17813481Sgiacomo.travaglini@arm.com// argument, it can be used in any mock function that takes >= 2 17913481Sgiacomo.travaglini@arm.com// arguments where the type of the second argument is compatible. 18013481Sgiacomo.travaglini@arm.com// 18113481Sgiacomo.travaglini@arm.com// Therefore, the action implementation must be prepared to take more 18213481Sgiacomo.travaglini@arm.com// arguments than it needs. The ExcessiveArg type is used to 18313481Sgiacomo.travaglini@arm.com// represent those excessive arguments. In order to keep the compiler 18413481Sgiacomo.travaglini@arm.com// error messages tractable, we define it in the testing namespace 18513481Sgiacomo.travaglini@arm.com// instead of testing::internal. However, this is an INTERNAL TYPE 18613481Sgiacomo.travaglini@arm.com// and subject to change without notice, so a user MUST NOT USE THIS 18713481Sgiacomo.travaglini@arm.com// TYPE DIRECTLY. 18813481Sgiacomo.travaglini@arm.comstruct ExcessiveArg {}; 18913481Sgiacomo.travaglini@arm.com 19013481Sgiacomo.travaglini@arm.com// A helper class needed for implementing the ACTION* macros. 19113481Sgiacomo.travaglini@arm.comtemplate <typename Result, class Impl> 19213481Sgiacomo.travaglini@arm.comclass ActionHelper { 19313481Sgiacomo.travaglini@arm.com public: 19413481Sgiacomo.travaglini@arm.com$range i 0..n 19513481Sgiacomo.travaglini@arm.com$for i 19613481Sgiacomo.travaglini@arm.com 19713481Sgiacomo.travaglini@arm.com[[ 19813481Sgiacomo.travaglini@arm.com$var template = [[$if i==0 [[]] $else [[ 19913481Sgiacomo.travaglini@arm.com$range j 0..i-1 20013481Sgiacomo.travaglini@arm.com template <$for j, [[typename A$j]]> 20113481Sgiacomo.travaglini@arm.com]]]] 20213481Sgiacomo.travaglini@arm.com$range j 0..i-1 20313481Sgiacomo.travaglini@arm.com$var As = [[$for j, [[A$j]]]] 20413481Sgiacomo.travaglini@arm.com$var as = [[$for j, [[get<$j>(args)]]]] 20513481Sgiacomo.travaglini@arm.com$range k 1..n-i 20613481Sgiacomo.travaglini@arm.com$var eas = [[$for k, [[ExcessiveArg()]]]] 20713481Sgiacomo.travaglini@arm.com$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]] 20813481Sgiacomo.travaglini@arm.com$template 20913481Sgiacomo.travaglini@arm.com static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) { 21013481Sgiacomo.travaglini@arm.com return impl->template gmock_PerformImpl<$As>(args, $arg_list); 21113481Sgiacomo.travaglini@arm.com } 21213481Sgiacomo.travaglini@arm.com 21313481Sgiacomo.travaglini@arm.com]] 21413481Sgiacomo.travaglini@arm.com}; 21513481Sgiacomo.travaglini@arm.com 21613481Sgiacomo.travaglini@arm.com} // namespace internal 21713481Sgiacomo.travaglini@arm.com 21813481Sgiacomo.travaglini@arm.com// Various overloads for Invoke(). 21913481Sgiacomo.travaglini@arm.com 22013481Sgiacomo.travaglini@arm.com// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes 22113481Sgiacomo.travaglini@arm.com// the selected arguments of the mock function to an_action and 22213481Sgiacomo.travaglini@arm.com// performs it. It serves as an adaptor between actions with 22313481Sgiacomo.travaglini@arm.com// different argument lists. C++ doesn't support default arguments for 22413481Sgiacomo.travaglini@arm.com// function templates, so we have to overload it. 22513481Sgiacomo.travaglini@arm.com 22613481Sgiacomo.travaglini@arm.com$range i 1..n 22713481Sgiacomo.travaglini@arm.com$for i [[ 22813481Sgiacomo.travaglini@arm.com$range j 1..i 22913481Sgiacomo.travaglini@arm.comtemplate <$for j [[int k$j, ]]typename InnerAction> 23013481Sgiacomo.travaglini@arm.cominline internal::WithArgsAction<InnerAction$for j [[, k$j]]> 23113481Sgiacomo.travaglini@arm.comWithArgs(const InnerAction& action) { 23213481Sgiacomo.travaglini@arm.com return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action); 23313481Sgiacomo.travaglini@arm.com} 23413481Sgiacomo.travaglini@arm.com 23513481Sgiacomo.travaglini@arm.com 23613481Sgiacomo.travaglini@arm.com]] 23713481Sgiacomo.travaglini@arm.com// Creates an action that does actions a1, a2, ..., sequentially in 23813481Sgiacomo.travaglini@arm.com// each invocation. 23913481Sgiacomo.travaglini@arm.com$range i 2..n 24013481Sgiacomo.travaglini@arm.com$for i [[ 24113481Sgiacomo.travaglini@arm.com$range j 2..i 24213481Sgiacomo.travaglini@arm.com$var types = [[$for j, [[typename Action$j]]]] 24313481Sgiacomo.travaglini@arm.com$var Aas = [[$for j [[, Action$j a$j]]]] 24413481Sgiacomo.travaglini@arm.com 24513481Sgiacomo.travaglini@arm.comtemplate <typename Action1, $types> 24613481Sgiacomo.travaglini@arm.com$range k 1..i-1 24713481Sgiacomo.travaglini@arm.com 24813481Sgiacomo.travaglini@arm.cominline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k [[>]] 24913481Sgiacomo.travaglini@arm.com 25013481Sgiacomo.travaglini@arm.comDoAll(Action1 a1$Aas) { 25113481Sgiacomo.travaglini@arm.com$if i==2 [[ 25213481Sgiacomo.travaglini@arm.com 25313481Sgiacomo.travaglini@arm.com return internal::DoBothAction<Action1, Action2>(a1, a2); 25413481Sgiacomo.travaglini@arm.com]] $else [[ 25513481Sgiacomo.travaglini@arm.com$range j2 2..i 25613481Sgiacomo.travaglini@arm.com 25713481Sgiacomo.travaglini@arm.com return DoAll(a1, DoAll($for j2, [[a$j2]])); 25813481Sgiacomo.travaglini@arm.com]] 25913481Sgiacomo.travaglini@arm.com 26013481Sgiacomo.travaglini@arm.com} 26113481Sgiacomo.travaglini@arm.com 26213481Sgiacomo.travaglini@arm.com]] 26313481Sgiacomo.travaglini@arm.com 26413481Sgiacomo.travaglini@arm.com} // namespace testing 26513481Sgiacomo.travaglini@arm.com 26613481Sgiacomo.travaglini@arm.com// The ACTION* family of macros can be used in a namespace scope to 26713481Sgiacomo.travaglini@arm.com// define custom actions easily. The syntax: 26813481Sgiacomo.travaglini@arm.com// 26913481Sgiacomo.travaglini@arm.com// ACTION(name) { statements; } 27013481Sgiacomo.travaglini@arm.com// 27113481Sgiacomo.travaglini@arm.com// will define an action with the given name that executes the 27213481Sgiacomo.travaglini@arm.com// statements. The value returned by the statements will be used as 27313481Sgiacomo.travaglini@arm.com// the return value of the action. Inside the statements, you can 27413481Sgiacomo.travaglini@arm.com// refer to the K-th (0-based) argument of the mock function by 27513481Sgiacomo.travaglini@arm.com// 'argK', and refer to its type by 'argK_type'. For example: 27613481Sgiacomo.travaglini@arm.com// 27713481Sgiacomo.travaglini@arm.com// ACTION(IncrementArg1) { 27813481Sgiacomo.travaglini@arm.com// arg1_type temp = arg1; 27913481Sgiacomo.travaglini@arm.com// return ++(*temp); 28013481Sgiacomo.travaglini@arm.com// } 28113481Sgiacomo.travaglini@arm.com// 28213481Sgiacomo.travaglini@arm.com// allows you to write 28313481Sgiacomo.travaglini@arm.com// 28413481Sgiacomo.travaglini@arm.com// ...WillOnce(IncrementArg1()); 28513481Sgiacomo.travaglini@arm.com// 28613481Sgiacomo.travaglini@arm.com// You can also refer to the entire argument tuple and its type by 28713481Sgiacomo.travaglini@arm.com// 'args' and 'args_type', and refer to the mock function type and its 28813481Sgiacomo.travaglini@arm.com// return type by 'function_type' and 'return_type'. 28913481Sgiacomo.travaglini@arm.com// 29013481Sgiacomo.travaglini@arm.com// Note that you don't need to specify the types of the mock function 29113481Sgiacomo.travaglini@arm.com// arguments. However rest assured that your code is still type-safe: 29213481Sgiacomo.travaglini@arm.com// you'll get a compiler error if *arg1 doesn't support the ++ 29313481Sgiacomo.travaglini@arm.com// operator, or if the type of ++(*arg1) isn't compatible with the 29413481Sgiacomo.travaglini@arm.com// mock function's return type, for example. 29513481Sgiacomo.travaglini@arm.com// 29613481Sgiacomo.travaglini@arm.com// Sometimes you'll want to parameterize the action. For that you can use 29713481Sgiacomo.travaglini@arm.com// another macro: 29813481Sgiacomo.travaglini@arm.com// 29913481Sgiacomo.travaglini@arm.com// ACTION_P(name, param_name) { statements; } 30013481Sgiacomo.travaglini@arm.com// 30113481Sgiacomo.travaglini@arm.com// For example: 30213481Sgiacomo.travaglini@arm.com// 30313481Sgiacomo.travaglini@arm.com// ACTION_P(Add, n) { return arg0 + n; } 30413481Sgiacomo.travaglini@arm.com// 30513481Sgiacomo.travaglini@arm.com// will allow you to write: 30613481Sgiacomo.travaglini@arm.com// 30713481Sgiacomo.travaglini@arm.com// ...WillOnce(Add(5)); 30813481Sgiacomo.travaglini@arm.com// 30913481Sgiacomo.travaglini@arm.com// Note that you don't need to provide the type of the parameter 31013481Sgiacomo.travaglini@arm.com// either. If you need to reference the type of a parameter named 31113481Sgiacomo.travaglini@arm.com// 'foo', you can write 'foo_type'. For example, in the body of 31213481Sgiacomo.travaglini@arm.com// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type 31313481Sgiacomo.travaglini@arm.com// of 'n'. 31413481Sgiacomo.travaglini@arm.com// 31513481Sgiacomo.travaglini@arm.com// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support 31613481Sgiacomo.travaglini@arm.com// multi-parameter actions. 31713481Sgiacomo.travaglini@arm.com// 31813481Sgiacomo.travaglini@arm.com// For the purpose of typing, you can view 31913481Sgiacomo.travaglini@arm.com// 32013481Sgiacomo.travaglini@arm.com// ACTION_Pk(Foo, p1, ..., pk) { ... } 32113481Sgiacomo.travaglini@arm.com// 32213481Sgiacomo.travaglini@arm.com// as shorthand for 32313481Sgiacomo.travaglini@arm.com// 32413481Sgiacomo.travaglini@arm.com// template <typename p1_type, ..., typename pk_type> 32513481Sgiacomo.travaglini@arm.com// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } 32613481Sgiacomo.travaglini@arm.com// 32713481Sgiacomo.travaglini@arm.com// In particular, you can provide the template type arguments 32813481Sgiacomo.travaglini@arm.com// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); 32913481Sgiacomo.travaglini@arm.com// although usually you can rely on the compiler to infer the types 33013481Sgiacomo.travaglini@arm.com// for you automatically. You can assign the result of expression 33113481Sgiacomo.travaglini@arm.com// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., 33213481Sgiacomo.travaglini@arm.com// pk_type>. This can be useful when composing actions. 33313481Sgiacomo.travaglini@arm.com// 33413481Sgiacomo.travaglini@arm.com// You can also overload actions with different numbers of parameters: 33513481Sgiacomo.travaglini@arm.com// 33613481Sgiacomo.travaglini@arm.com// ACTION_P(Plus, a) { ... } 33713481Sgiacomo.travaglini@arm.com// ACTION_P2(Plus, a, b) { ... } 33813481Sgiacomo.travaglini@arm.com// 33913481Sgiacomo.travaglini@arm.com// While it's tempting to always use the ACTION* macros when defining 34013481Sgiacomo.travaglini@arm.com// a new action, you should also consider implementing ActionInterface 34113481Sgiacomo.travaglini@arm.com// or using MakePolymorphicAction() instead, especially if you need to 34213481Sgiacomo.travaglini@arm.com// use the action a lot. While these approaches require more work, 34313481Sgiacomo.travaglini@arm.com// they give you more control on the types of the mock function 34413481Sgiacomo.travaglini@arm.com// arguments and the action parameters, which in general leads to 34513481Sgiacomo.travaglini@arm.com// better compiler error messages that pay off in the long run. They 34613481Sgiacomo.travaglini@arm.com// also allow overloading actions based on parameter types (as opposed 34713481Sgiacomo.travaglini@arm.com// to just based on the number of parameters). 34813481Sgiacomo.travaglini@arm.com// 34913481Sgiacomo.travaglini@arm.com// CAVEAT: 35013481Sgiacomo.travaglini@arm.com// 35113481Sgiacomo.travaglini@arm.com// ACTION*() can only be used in a namespace scope. The reason is 35213481Sgiacomo.travaglini@arm.com// that C++ doesn't yet allow function-local types to be used to 35313481Sgiacomo.travaglini@arm.com// instantiate templates. The up-coming C++0x standard will fix this. 35413481Sgiacomo.travaglini@arm.com// Once that's done, we'll consider supporting using ACTION*() inside 35513481Sgiacomo.travaglini@arm.com// a function. 35613481Sgiacomo.travaglini@arm.com// 35713481Sgiacomo.travaglini@arm.com// MORE INFORMATION: 35813481Sgiacomo.travaglini@arm.com// 35913481Sgiacomo.travaglini@arm.com// To learn more about using these macros, please search for 'ACTION' 36013481Sgiacomo.travaglini@arm.com// on http://code.google.com/p/googlemock/wiki/CookBook. 36113481Sgiacomo.travaglini@arm.com 36213481Sgiacomo.travaglini@arm.com$range i 0..n 36313481Sgiacomo.travaglini@arm.com$range k 0..n-1 36413481Sgiacomo.travaglini@arm.com 36513481Sgiacomo.travaglini@arm.com// An internal macro needed for implementing ACTION*(). 36613481Sgiacomo.travaglini@arm.com#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ 36713481Sgiacomo.travaglini@arm.com const args_type& args GTEST_ATTRIBUTE_UNUSED_ 36813481Sgiacomo.travaglini@arm.com$for k [[, \ 36913481Sgiacomo.travaglini@arm.com arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]] 37013481Sgiacomo.travaglini@arm.com 37113481Sgiacomo.travaglini@arm.com 37213481Sgiacomo.travaglini@arm.com// Sometimes you want to give an action explicit template parameters 37313481Sgiacomo.travaglini@arm.com// that cannot be inferred from its value parameters. ACTION() and 37413481Sgiacomo.travaglini@arm.com// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that 37513481Sgiacomo.travaglini@arm.com// and can be viewed as an extension to ACTION() and ACTION_P*(). 37613481Sgiacomo.travaglini@arm.com// 37713481Sgiacomo.travaglini@arm.com// The syntax: 37813481Sgiacomo.travaglini@arm.com// 37913481Sgiacomo.travaglini@arm.com// ACTION_TEMPLATE(ActionName, 38013481Sgiacomo.travaglini@arm.com// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), 38113481Sgiacomo.travaglini@arm.com// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } 38213481Sgiacomo.travaglini@arm.com// 38313481Sgiacomo.travaglini@arm.com// defines an action template that takes m explicit template 38413481Sgiacomo.travaglini@arm.com// parameters and n value parameters. name_i is the name of the i-th 38513481Sgiacomo.travaglini@arm.com// template parameter, and kind_i specifies whether it's a typename, 38613481Sgiacomo.travaglini@arm.com// an integral constant, or a template. p_i is the name of the i-th 38713481Sgiacomo.travaglini@arm.com// value parameter. 38813481Sgiacomo.travaglini@arm.com// 38913481Sgiacomo.travaglini@arm.com// Example: 39013481Sgiacomo.travaglini@arm.com// 39113481Sgiacomo.travaglini@arm.com// // DuplicateArg<k, T>(output) converts the k-th argument of the mock 39213481Sgiacomo.travaglini@arm.com// // function to type T and copies it to *output. 39313481Sgiacomo.travaglini@arm.com// ACTION_TEMPLATE(DuplicateArg, 39413481Sgiacomo.travaglini@arm.com// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), 39513481Sgiacomo.travaglini@arm.com// AND_1_VALUE_PARAMS(output)) { 39613481Sgiacomo.travaglini@arm.com// *output = T(::testing::get<k>(args)); 39713481Sgiacomo.travaglini@arm.com// } 39813481Sgiacomo.travaglini@arm.com// ... 39913481Sgiacomo.travaglini@arm.com// int n; 40013481Sgiacomo.travaglini@arm.com// EXPECT_CALL(mock, Foo(_, _)) 40113481Sgiacomo.travaglini@arm.com// .WillOnce(DuplicateArg<1, unsigned char>(&n)); 40213481Sgiacomo.travaglini@arm.com// 40313481Sgiacomo.travaglini@arm.com// To create an instance of an action template, write: 40413481Sgiacomo.travaglini@arm.com// 40513481Sgiacomo.travaglini@arm.com// ActionName<t1, ..., t_m>(v1, ..., v_n) 40613481Sgiacomo.travaglini@arm.com// 40713481Sgiacomo.travaglini@arm.com// where the ts are the template arguments and the vs are the value 40813481Sgiacomo.travaglini@arm.com// arguments. The value argument types are inferred by the compiler. 40913481Sgiacomo.travaglini@arm.com// If you want to explicitly specify the value argument types, you can 41013481Sgiacomo.travaglini@arm.com// provide additional template arguments: 41113481Sgiacomo.travaglini@arm.com// 41213481Sgiacomo.travaglini@arm.com// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) 41313481Sgiacomo.travaglini@arm.com// 41413481Sgiacomo.travaglini@arm.com// where u_i is the desired type of v_i. 41513481Sgiacomo.travaglini@arm.com// 41613481Sgiacomo.travaglini@arm.com// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the 41713481Sgiacomo.travaglini@arm.com// number of value parameters, but not on the number of template 41813481Sgiacomo.travaglini@arm.com// parameters. Without the restriction, the meaning of the following 41913481Sgiacomo.travaglini@arm.com// is unclear: 42013481Sgiacomo.travaglini@arm.com// 42113481Sgiacomo.travaglini@arm.com// OverloadedAction<int, bool>(x); 42213481Sgiacomo.travaglini@arm.com// 42313481Sgiacomo.travaglini@arm.com// Are we using a single-template-parameter action where 'bool' refers 42413481Sgiacomo.travaglini@arm.com// to the type of x, or are we using a two-template-parameter action 42513481Sgiacomo.travaglini@arm.com// where the compiler is asked to infer the type of x? 42613481Sgiacomo.travaglini@arm.com// 42713481Sgiacomo.travaglini@arm.com// Implementation notes: 42813481Sgiacomo.travaglini@arm.com// 42913481Sgiacomo.travaglini@arm.com// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and 43013481Sgiacomo.travaglini@arm.com// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for 43113481Sgiacomo.travaglini@arm.com// implementing ACTION_TEMPLATE. The main trick we use is to create 43213481Sgiacomo.travaglini@arm.com// new macro invocations when expanding a macro. For example, we have 43313481Sgiacomo.travaglini@arm.com// 43413481Sgiacomo.travaglini@arm.com// #define ACTION_TEMPLATE(name, template_params, value_params) 43513481Sgiacomo.travaglini@arm.com// ... GMOCK_INTERNAL_DECL_##template_params ... 43613481Sgiacomo.travaglini@arm.com// 43713481Sgiacomo.travaglini@arm.com// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) 43813481Sgiacomo.travaglini@arm.com// to expand to 43913481Sgiacomo.travaglini@arm.com// 44013481Sgiacomo.travaglini@arm.com// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... 44113481Sgiacomo.travaglini@arm.com// 44213481Sgiacomo.travaglini@arm.com// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the 44313481Sgiacomo.travaglini@arm.com// preprocessor will continue to expand it to 44413481Sgiacomo.travaglini@arm.com// 44513481Sgiacomo.travaglini@arm.com// ... typename T ... 44613481Sgiacomo.travaglini@arm.com// 44713481Sgiacomo.travaglini@arm.com// This technique conforms to the C++ standard and is portable. It 44813481Sgiacomo.travaglini@arm.com// allows us to implement action templates using O(N) code, where N is 44913481Sgiacomo.travaglini@arm.com// the maximum number of template/value parameters supported. Without 45013481Sgiacomo.travaglini@arm.com// using it, we'd have to devote O(N^2) amount of code to implement all 45113481Sgiacomo.travaglini@arm.com// combinations of m and n. 45213481Sgiacomo.travaglini@arm.com 45313481Sgiacomo.travaglini@arm.com// Declares the template parameters. 45413481Sgiacomo.travaglini@arm.com 45513481Sgiacomo.travaglini@arm.com$range j 1..n 45613481Sgiacomo.travaglini@arm.com$for j [[ 45713481Sgiacomo.travaglini@arm.com$range m 0..j-1 45813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_DECL_HAS_$j[[]] 45913481Sgiacomo.travaglini@arm.com_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]] 46013481Sgiacomo.travaglini@arm.com 46113481Sgiacomo.travaglini@arm.com 46213481Sgiacomo.travaglini@arm.com]] 46313481Sgiacomo.travaglini@arm.com 46413481Sgiacomo.travaglini@arm.com// Lists the template parameters. 46513481Sgiacomo.travaglini@arm.com 46613481Sgiacomo.travaglini@arm.com$for j [[ 46713481Sgiacomo.travaglini@arm.com$range m 0..j-1 46813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_LIST_HAS_$j[[]] 46913481Sgiacomo.travaglini@arm.com_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]] 47013481Sgiacomo.travaglini@arm.com 47113481Sgiacomo.travaglini@arm.com 47213481Sgiacomo.travaglini@arm.com]] 47313481Sgiacomo.travaglini@arm.com 47413481Sgiacomo.travaglini@arm.com// Declares the types of value parameters. 47513481Sgiacomo.travaglini@arm.com 47613481Sgiacomo.travaglini@arm.com$for i [[ 47713481Sgiacomo.travaglini@arm.com$range j 0..i-1 47813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]] 47913481Sgiacomo.travaglini@arm.com_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]] 48013481Sgiacomo.travaglini@arm.com 48113481Sgiacomo.travaglini@arm.com 48213481Sgiacomo.travaglini@arm.com]] 48313481Sgiacomo.travaglini@arm.com 48413481Sgiacomo.travaglini@arm.com// Initializes the value parameters. 48513481Sgiacomo.travaglini@arm.com 48613481Sgiacomo.travaglini@arm.com$for i [[ 48713481Sgiacomo.travaglini@arm.com$range j 0..i-1 48813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\ 48913481Sgiacomo.travaglini@arm.com ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(gmock_p$j)]] 49013481Sgiacomo.travaglini@arm.com 49113481Sgiacomo.travaglini@arm.com 49213481Sgiacomo.travaglini@arm.com]] 49313481Sgiacomo.travaglini@arm.com 49413481Sgiacomo.travaglini@arm.com// Declares the fields for storing the value parameters. 49513481Sgiacomo.travaglini@arm.com 49613481Sgiacomo.travaglini@arm.com$for i [[ 49713481Sgiacomo.travaglini@arm.com$range j 0..i-1 49813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_DEFN_AND_$i[[]] 49913481Sgiacomo.travaglini@arm.com_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]] 50013481Sgiacomo.travaglini@arm.com 50113481Sgiacomo.travaglini@arm.com 50213481Sgiacomo.travaglini@arm.com]] 50313481Sgiacomo.travaglini@arm.com 50413481Sgiacomo.travaglini@arm.com// Lists the value parameters. 50513481Sgiacomo.travaglini@arm.com 50613481Sgiacomo.travaglini@arm.com$for i [[ 50713481Sgiacomo.travaglini@arm.com$range j 0..i-1 50813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_LIST_AND_$i[[]] 50913481Sgiacomo.travaglini@arm.com_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]] 51013481Sgiacomo.travaglini@arm.com 51113481Sgiacomo.travaglini@arm.com 51213481Sgiacomo.travaglini@arm.com]] 51313481Sgiacomo.travaglini@arm.com 51413481Sgiacomo.travaglini@arm.com// Lists the value parameter types. 51513481Sgiacomo.travaglini@arm.com 51613481Sgiacomo.travaglini@arm.com$for i [[ 51713481Sgiacomo.travaglini@arm.com$range j 0..i-1 51813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]] 51913481Sgiacomo.travaglini@arm.com_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]] 52013481Sgiacomo.travaglini@arm.com 52113481Sgiacomo.travaglini@arm.com 52213481Sgiacomo.travaglini@arm.com]] 52313481Sgiacomo.travaglini@arm.com 52413481Sgiacomo.travaglini@arm.com// Declares the value parameters. 52513481Sgiacomo.travaglini@arm.com 52613481Sgiacomo.travaglini@arm.com$for i [[ 52713481Sgiacomo.travaglini@arm.com$range j 0..i-1 52813481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 52913481Sgiacomo.travaglini@arm.com$for j, [[p$j##_type p$j]] 53013481Sgiacomo.travaglini@arm.com 53113481Sgiacomo.travaglini@arm.com 53213481Sgiacomo.travaglini@arm.com]] 53313481Sgiacomo.travaglini@arm.com 53413481Sgiacomo.travaglini@arm.com// The suffix of the class template implementing the action template. 53513481Sgiacomo.travaglini@arm.com$for i [[ 53613481Sgiacomo.travaglini@arm.com 53713481Sgiacomo.travaglini@arm.com 53813481Sgiacomo.travaglini@arm.com$range j 0..i-1 53913481Sgiacomo.travaglini@arm.com#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] 54013481Sgiacomo.travaglini@arm.com$if i==1 [[P]] $elif i>=2 [[P$i]] 54113481Sgiacomo.travaglini@arm.com]] 54213481Sgiacomo.travaglini@arm.com 54313481Sgiacomo.travaglini@arm.com 54413481Sgiacomo.travaglini@arm.com// The name of the class template implementing the action template. 54513481Sgiacomo.travaglini@arm.com#define GMOCK_ACTION_CLASS_(name, value_params)\ 54613481Sgiacomo.travaglini@arm.com GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) 54713481Sgiacomo.travaglini@arm.com 54813481Sgiacomo.travaglini@arm.com$range k 0..n-1 54913481Sgiacomo.travaglini@arm.com 55013481Sgiacomo.travaglini@arm.com#define ACTION_TEMPLATE(name, template_params, value_params)\ 55113481Sgiacomo.travaglini@arm.com template <GMOCK_INTERNAL_DECL_##template_params\ 55213481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 55313481Sgiacomo.travaglini@arm.com class GMOCK_ACTION_CLASS_(name, value_params) {\ 55413481Sgiacomo.travaglini@arm.com public:\ 55513481Sgiacomo.travaglini@arm.com explicit GMOCK_ACTION_CLASS_(name, value_params)\ 55613481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_INIT_##value_params {}\ 55713481Sgiacomo.travaglini@arm.com template <typename F>\ 55813481Sgiacomo.travaglini@arm.com class gmock_Impl : public ::testing::ActionInterface<F> {\ 55913481Sgiacomo.travaglini@arm.com public:\ 56013481Sgiacomo.travaglini@arm.com typedef F function_type;\ 56113481Sgiacomo.travaglini@arm.com typedef typename ::testing::internal::Function<F>::Result return_type;\ 56213481Sgiacomo.travaglini@arm.com typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 56313481Sgiacomo.travaglini@arm.com args_type;\ 56413481Sgiacomo.travaglini@arm.com explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ 56513481Sgiacomo.travaglini@arm.com virtual return_type Perform(const args_type& args) {\ 56613481Sgiacomo.travaglini@arm.com return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 56713481Sgiacomo.travaglini@arm.com Perform(this, args);\ 56813481Sgiacomo.travaglini@arm.com }\ 56913481Sgiacomo.travaglini@arm.com template <$for k, [[typename arg$k[[]]_type]]>\ 57013481Sgiacomo.travaglini@arm.com return_type gmock_PerformImpl(const args_type& args[[]] 57113481Sgiacomo.travaglini@arm.com$for k [[, arg$k[[]]_type arg$k]]) const;\ 57213481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DEFN_##value_params\ 57313481Sgiacomo.travaglini@arm.com private:\ 57413481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 57513481Sgiacomo.travaglini@arm.com };\ 57613481Sgiacomo.travaglini@arm.com template <typename F> operator ::testing::Action<F>() const {\ 57713481Sgiacomo.travaglini@arm.com return ::testing::Action<F>(\ 57813481Sgiacomo.travaglini@arm.com new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\ 57913481Sgiacomo.travaglini@arm.com }\ 58013481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DEFN_##value_params\ 58113481Sgiacomo.travaglini@arm.com private:\ 58213481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ 58313481Sgiacomo.travaglini@arm.com };\ 58413481Sgiacomo.travaglini@arm.com template <GMOCK_INTERNAL_DECL_##template_params\ 58513481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 58613481Sgiacomo.travaglini@arm.com inline GMOCK_ACTION_CLASS_(name, value_params)<\ 58713481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_##template_params\ 58813481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ 58913481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DECL_##value_params) {\ 59013481Sgiacomo.travaglini@arm.com return GMOCK_ACTION_CLASS_(name, value_params)<\ 59113481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_##template_params\ 59213481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ 59313481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_##value_params);\ 59413481Sgiacomo.travaglini@arm.com }\ 59513481Sgiacomo.travaglini@arm.com template <GMOCK_INTERNAL_DECL_##template_params\ 59613481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_DECL_TYPE_##value_params>\ 59713481Sgiacomo.travaglini@arm.com template <typename F>\ 59813481Sgiacomo.travaglini@arm.com template <typename arg0_type, typename arg1_type, typename arg2_type, \ 59913481Sgiacomo.travaglini@arm.com typename arg3_type, typename arg4_type, typename arg5_type, \ 60013481Sgiacomo.travaglini@arm.com typename arg6_type, typename arg7_type, typename arg8_type, \ 60113481Sgiacomo.travaglini@arm.com typename arg9_type>\ 60213481Sgiacomo.travaglini@arm.com typename ::testing::internal::Function<F>::Result\ 60313481Sgiacomo.travaglini@arm.com GMOCK_ACTION_CLASS_(name, value_params)<\ 60413481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_##template_params\ 60513481Sgiacomo.travaglini@arm.com GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\ 60613481Sgiacomo.travaglini@arm.com gmock_PerformImpl(\ 60713481Sgiacomo.travaglini@arm.com GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 60813481Sgiacomo.travaglini@arm.com 60913481Sgiacomo.travaglini@arm.com$for i 61013481Sgiacomo.travaglini@arm.com 61113481Sgiacomo.travaglini@arm.com[[ 61213481Sgiacomo.travaglini@arm.com$var template = [[$if i==0 [[]] $else [[ 61313481Sgiacomo.travaglini@arm.com$range j 0..i-1 61413481Sgiacomo.travaglini@arm.com 61513481Sgiacomo.travaglini@arm.com template <$for j, [[typename p$j##_type]]>\ 61613481Sgiacomo.travaglini@arm.com]]]] 61713481Sgiacomo.travaglini@arm.com$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]] 61813481Sgiacomo.travaglini@arm.com $else [[P$i]]]]]] 61913481Sgiacomo.travaglini@arm.com$range j 0..i-1 62013481Sgiacomo.travaglini@arm.com$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] 62113481Sgiacomo.travaglini@arm.com$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] 62213481Sgiacomo.travaglini@arm.com$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(gmock_p$j)]]]]]] 62313481Sgiacomo.travaglini@arm.com$var param_field_decls = [[$for j 62413481Sgiacomo.travaglini@arm.com[[ 62513481Sgiacomo.travaglini@arm.com 62613481Sgiacomo.travaglini@arm.com p$j##_type p$j;\ 62713481Sgiacomo.travaglini@arm.com]]]] 62813481Sgiacomo.travaglini@arm.com$var param_field_decls2 = [[$for j 62913481Sgiacomo.travaglini@arm.com[[ 63013481Sgiacomo.travaglini@arm.com 63113481Sgiacomo.travaglini@arm.com p$j##_type p$j;\ 63213481Sgiacomo.travaglini@arm.com]]]] 63313481Sgiacomo.travaglini@arm.com$var params = [[$for j, [[p$j]]]] 63413481Sgiacomo.travaglini@arm.com$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] 63513481Sgiacomo.travaglini@arm.com$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]] 63613481Sgiacomo.travaglini@arm.com$var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]] 63713481Sgiacomo.travaglini@arm.com$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]] 63813481Sgiacomo.travaglini@arm.com $else [[ACTION_P$i]]]] 63913481Sgiacomo.travaglini@arm.com 64013481Sgiacomo.travaglini@arm.com#define $macro_name(name$for j [[, p$j]])\$template 64113481Sgiacomo.travaglini@arm.com class $class_name {\ 64213481Sgiacomo.travaglini@arm.com public:\ 64313481Sgiacomo.travaglini@arm.com [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ 64413481Sgiacomo.travaglini@arm.com template <typename F>\ 64513481Sgiacomo.travaglini@arm.com class gmock_Impl : public ::testing::ActionInterface<F> {\ 64613481Sgiacomo.travaglini@arm.com public:\ 64713481Sgiacomo.travaglini@arm.com typedef F function_type;\ 64813481Sgiacomo.travaglini@arm.com typedef typename ::testing::internal::Function<F>::Result return_type;\ 64913481Sgiacomo.travaglini@arm.com typedef typename ::testing::internal::Function<F>::ArgumentTuple\ 65013481Sgiacomo.travaglini@arm.com args_type;\ 65113481Sgiacomo.travaglini@arm.com [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\ 65213481Sgiacomo.travaglini@arm.com virtual return_type Perform(const args_type& args) {\ 65313481Sgiacomo.travaglini@arm.com return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ 65413481Sgiacomo.travaglini@arm.com Perform(this, args);\ 65513481Sgiacomo.travaglini@arm.com }\ 65613481Sgiacomo.travaglini@arm.com template <$typename_arg_types>\ 65713481Sgiacomo.travaglini@arm.com return_type gmock_PerformImpl(const args_type& args, [[]] 65813481Sgiacomo.travaglini@arm.com$arg_types_and_names) const;\$param_field_decls 65913481Sgiacomo.travaglini@arm.com private:\ 66013481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ 66113481Sgiacomo.travaglini@arm.com };\ 66213481Sgiacomo.travaglini@arm.com template <typename F> operator ::testing::Action<F>() const {\ 66313481Sgiacomo.travaglini@arm.com return ::testing::Action<F>(new gmock_Impl<F>($params));\ 66413481Sgiacomo.travaglini@arm.com }\$param_field_decls2 66513481Sgiacomo.travaglini@arm.com private:\ 66613481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_ASSIGN_($class_name);\ 66713481Sgiacomo.travaglini@arm.com };\$template 66813481Sgiacomo.travaglini@arm.com inline $class_name$param_types name($param_types_and_names) {\ 66913481Sgiacomo.travaglini@arm.com return $class_name$param_types($params);\ 67013481Sgiacomo.travaglini@arm.com }\$template 67113481Sgiacomo.travaglini@arm.com template <typename F>\ 67213481Sgiacomo.travaglini@arm.com template <$typename_arg_types>\ 67313481Sgiacomo.travaglini@arm.com typename ::testing::internal::Function<F>::Result\ 67413481Sgiacomo.travaglini@arm.com $class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\ 67513481Sgiacomo.travaglini@arm.com GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 67613481Sgiacomo.travaglini@arm.com]] 67713481Sgiacomo.travaglini@arm.com$$ } // This meta comment fixes auto-indentation in Emacs. It won't 67813481Sgiacomo.travaglini@arm.com$$ // show up in the generated code. 67913481Sgiacomo.travaglini@arm.com 68013481Sgiacomo.travaglini@arm.com 68113481Sgiacomo.travaglini@arm.comnamespace testing { 68213481Sgiacomo.travaglini@arm.com 68313481Sgiacomo.travaglini@arm.com 68413481Sgiacomo.travaglini@arm.com// The ACTION*() macros trigger warning C4100 (unreferenced formal 68513481Sgiacomo.travaglini@arm.com// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in 68613481Sgiacomo.travaglini@arm.com// the macro definition, as the warnings are generated when the macro 68713481Sgiacomo.travaglini@arm.com// is expanded and macro expansion cannot contain #pragma. Therefore 68813481Sgiacomo.travaglini@arm.com// we suppress them here. 68913481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER 69013481Sgiacomo.travaglini@arm.com# pragma warning(push) 69113481Sgiacomo.travaglini@arm.com# pragma warning(disable:4100) 69213481Sgiacomo.travaglini@arm.com#endif 69313481Sgiacomo.travaglini@arm.com 69413481Sgiacomo.travaglini@arm.com// Various overloads for InvokeArgument<N>(). 69513481Sgiacomo.travaglini@arm.com// 69613481Sgiacomo.travaglini@arm.com// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th 69713481Sgiacomo.travaglini@arm.com// (0-based) argument, which must be a k-ary callable, of the mock 69813481Sgiacomo.travaglini@arm.com// function, with arguments a1, a2, ..., a_k. 69913481Sgiacomo.travaglini@arm.com// 70013481Sgiacomo.travaglini@arm.com// Notes: 70113481Sgiacomo.travaglini@arm.com// 70213481Sgiacomo.travaglini@arm.com// 1. The arguments are passed by value by default. If you need to 70313481Sgiacomo.travaglini@arm.com// pass an argument by reference, wrap it inside ByRef(). For 70413481Sgiacomo.travaglini@arm.com// example, 70513481Sgiacomo.travaglini@arm.com// 70613481Sgiacomo.travaglini@arm.com// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) 70713481Sgiacomo.travaglini@arm.com// 70813481Sgiacomo.travaglini@arm.com// passes 5 and string("Hello") by value, and passes foo by 70913481Sgiacomo.travaglini@arm.com// reference. 71013481Sgiacomo.travaglini@arm.com// 71113481Sgiacomo.travaglini@arm.com// 2. If the callable takes an argument by reference but ByRef() is 71213481Sgiacomo.travaglini@arm.com// not used, it will receive the reference to a copy of the value, 71313481Sgiacomo.travaglini@arm.com// instead of the original value. For example, when the 0-th 71413481Sgiacomo.travaglini@arm.com// argument of the mock function takes a const string&, the action 71513481Sgiacomo.travaglini@arm.com// 71613481Sgiacomo.travaglini@arm.com// InvokeArgument<0>(string("Hello")) 71713481Sgiacomo.travaglini@arm.com// 71813481Sgiacomo.travaglini@arm.com// makes a copy of the temporary string("Hello") object and passes a 71913481Sgiacomo.travaglini@arm.com// reference of the copy, instead of the original temporary object, 72013481Sgiacomo.travaglini@arm.com// to the callable. This makes it easy for a user to define an 72113481Sgiacomo.travaglini@arm.com// InvokeArgument action from temporary values and have it performed 72213481Sgiacomo.travaglini@arm.com// later. 72313481Sgiacomo.travaglini@arm.com 72413481Sgiacomo.travaglini@arm.comnamespace internal { 72513481Sgiacomo.travaglini@arm.comnamespace invoke_argument { 72613481Sgiacomo.travaglini@arm.com 72713481Sgiacomo.travaglini@arm.com// Appears in InvokeArgumentAdl's argument list to help avoid 72813481Sgiacomo.travaglini@arm.com// accidental calls to user functions of the same name. 72913481Sgiacomo.travaglini@arm.comstruct AdlTag {}; 73013481Sgiacomo.travaglini@arm.com 73113481Sgiacomo.travaglini@arm.com// InvokeArgumentAdl - a helper for InvokeArgument. 73213481Sgiacomo.travaglini@arm.com// The basic overloads are provided here for generic functors. 73313481Sgiacomo.travaglini@arm.com// Overloads for other custom-callables are provided in the 73413481Sgiacomo.travaglini@arm.com// internal/custom/callback-actions.h header. 73513481Sgiacomo.travaglini@arm.com 73613481Sgiacomo.travaglini@arm.com$range i 0..n 73713481Sgiacomo.travaglini@arm.com$for i 73813481Sgiacomo.travaglini@arm.com[[ 73913481Sgiacomo.travaglini@arm.com$range j 1..i 74013481Sgiacomo.travaglini@arm.com 74113481Sgiacomo.travaglini@arm.comtemplate <typename R, typename F[[$for j [[, typename A$j]]]]> 74213481Sgiacomo.travaglini@arm.comR InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) { 74313481Sgiacomo.travaglini@arm.com return f([[$for j, [[a$j]]]]); 74413481Sgiacomo.travaglini@arm.com} 74513481Sgiacomo.travaglini@arm.com]] 74613481Sgiacomo.travaglini@arm.com 74713481Sgiacomo.travaglini@arm.com} // namespace invoke_argument 74813481Sgiacomo.travaglini@arm.com} // namespace internal 74913481Sgiacomo.travaglini@arm.com 75013481Sgiacomo.travaglini@arm.com$range i 0..n 75113481Sgiacomo.travaglini@arm.com$for i [[ 75213481Sgiacomo.travaglini@arm.com$range j 0..i-1 75313481Sgiacomo.travaglini@arm.com 75413481Sgiacomo.travaglini@arm.comACTION_TEMPLATE(InvokeArgument, 75513481Sgiacomo.travaglini@arm.com HAS_1_TEMPLATE_PARAMS(int, k), 75613481Sgiacomo.travaglini@arm.com AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) { 75713481Sgiacomo.travaglini@arm.com using internal::invoke_argument::InvokeArgumentAdl; 75813481Sgiacomo.travaglini@arm.com return InvokeArgumentAdl<return_type>( 75913481Sgiacomo.travaglini@arm.com internal::invoke_argument::AdlTag(), 76013481Sgiacomo.travaglini@arm.com ::testing::get<k>(args)$for j [[, p$j]]); 76113481Sgiacomo.travaglini@arm.com} 76213481Sgiacomo.travaglini@arm.com 76313481Sgiacomo.travaglini@arm.com]] 76413481Sgiacomo.travaglini@arm.com 76513481Sgiacomo.travaglini@arm.com// Various overloads for ReturnNew<T>(). 76613481Sgiacomo.travaglini@arm.com// 76713481Sgiacomo.travaglini@arm.com// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new 76813481Sgiacomo.travaglini@arm.com// instance of type T, constructed on the heap with constructor arguments 76913481Sgiacomo.travaglini@arm.com// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. 77013481Sgiacomo.travaglini@arm.com$range i 0..n 77113481Sgiacomo.travaglini@arm.com$for i [[ 77213481Sgiacomo.travaglini@arm.com$range j 0..i-1 77313481Sgiacomo.travaglini@arm.com$var ps = [[$for j, [[p$j]]]] 77413481Sgiacomo.travaglini@arm.com 77513481Sgiacomo.travaglini@arm.comACTION_TEMPLATE(ReturnNew, 77613481Sgiacomo.travaglini@arm.com HAS_1_TEMPLATE_PARAMS(typename, T), 77713481Sgiacomo.travaglini@arm.com AND_$i[[]]_VALUE_PARAMS($ps)) { 77813481Sgiacomo.travaglini@arm.com return new T($ps); 77913481Sgiacomo.travaglini@arm.com} 78013481Sgiacomo.travaglini@arm.com 78113481Sgiacomo.travaglini@arm.com]] 78213481Sgiacomo.travaglini@arm.com 78313481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER 78413481Sgiacomo.travaglini@arm.com# pragma warning(pop) 78513481Sgiacomo.travaglini@arm.com#endif 78613481Sgiacomo.travaglini@arm.com 78713481Sgiacomo.travaglini@arm.com} // namespace testing 78813481Sgiacomo.travaglini@arm.com 78913481Sgiacomo.travaglini@arm.com// Include any custom callback actions added by the local installation. 79013481Sgiacomo.travaglini@arm.com// We must include this header at the end to make sure it can use the 79113481Sgiacomo.travaglini@arm.com// declarations from this file. 79213481Sgiacomo.travaglini@arm.com#include "gmock/internal/custom/gmock-generated-actions.h" 79313481Sgiacomo.travaglini@arm.com 79413481Sgiacomo.travaglini@arm.com#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ 795