Differential D18622 Diff 52199 google/googletest/dist/googlemock/include/gmock/gmock-generated-actions.h.pump
Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googlemock/include/gmock/gmock-generated-actions.h.pump
- This file was added.
$$ -*- mode: c++; -*- | |||||
$$ This is a Pump source file. Please use Pump to convert it to | |||||
$$ gmock-generated-actions.h. | |||||
$$ | |||||
$var n = 10 $$ The maximum arity we support. | |||||
$$}} This meta comment fixes auto-indentation in editors. | |||||
// Copyright 2007, Google Inc. | |||||
// All rights reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
// Google Mock - a framework for writing C++ mock classes. | |||||
// | |||||
// This file implements some commonly used variadic actions. | |||||
// GOOGLETEST_CM0002 DO NOT DELETE | |||||
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ | |||||
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ | |||||
#include "gmock/gmock-actions.h" | |||||
#include "gmock/internal/gmock-port.h" | |||||
namespace testing { | |||||
namespace internal { | |||||
// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary | |||||
// function, method, or callback with the unpacked values, where F is | |||||
// a function type that takes N arguments. | |||||
template <typename Result, typename ArgumentTuple> | |||||
class InvokeHelper; | |||||
$var max_callback_arity = 5 | |||||
$range i 0..n | |||||
$for i [[ | |||||
$range j 1..i | |||||
$var types = [[$for j [[, typename A$j]]]] | |||||
$var as = [[$for j, [[A$j]]]] | |||||
$var args = [[$if i==0 [[]] $else [[ args]]]] | |||||
$var gets = [[$for j, [[get<$(j - 1)>(args)]]]] | |||||
template <typename R$types> | |||||
class InvokeHelper<R, ::testing::tuple<$as> > { | |||||
public: | |||||
template <typename Function> | |||||
static R Invoke(Function function, const ::testing::tuple<$as>&$args) { | |||||
return function($gets); | |||||
} | |||||
template <class Class, typename MethodPtr> | |||||
static R InvokeMethod(Class* obj_ptr, | |||||
MethodPtr method_ptr, | |||||
const ::testing::tuple<$as>&$args) { | |||||
return (obj_ptr->*method_ptr)($gets); | |||||
} | |||||
$if i <= max_callback_arity [[ | |||||
template <typename CallbackType> | |||||
static R InvokeCallback(CallbackType* callback, | |||||
const ::testing::tuple<$as>&$args) { | |||||
return callback->Run($gets); | |||||
} | |||||
]] $else [[ | |||||
// There is no InvokeCallback() for $i-tuples | |||||
]] | |||||
}; | |||||
]] | |||||
// Implements the Invoke(callback) action. | |||||
template <typename CallbackType> | |||||
class InvokeCallbackAction { | |||||
public: | |||||
// The c'tor takes ownership of the callback. | |||||
explicit InvokeCallbackAction(CallbackType* callback) | |||||
: callback_(callback) { | |||||
callback->CheckIsRepeatable(); // Makes sure the callback is permanent. | |||||
} | |||||
// This type conversion operator template allows Invoke(callback) to | |||||
// be used wherever the callback's type is compatible with that of | |||||
// the mock function, i.e. if the mock function's arguments can be | |||||
// implicitly converted to the callback's arguments and the | |||||
// callback's result can be implicitly converted to the mock | |||||
// function's result. | |||||
template <typename Result, typename ArgumentTuple> | |||||
Result Perform(const ArgumentTuple& args) const { | |||||
return InvokeHelper<Result, ArgumentTuple>::InvokeCallback( | |||||
callback_.get(), args); | |||||
} | |||||
private: | |||||
const linked_ptr<CallbackType> callback_; | |||||
}; | |||||
// An INTERNAL macro for extracting the type of a tuple field. It's | |||||
// subject to change without notice - DO NOT USE IN USER CODE! | |||||
#define GMOCK_FIELD_(Tuple, N) \ | |||||
typename ::testing::tuple_element<N, Tuple>::type | |||||
$range i 1..n | |||||
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the | |||||
// type of an n-ary function whose i-th (1-based) argument type is the | |||||
// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple | |||||
// type, and whose return type is Result. For example, | |||||
// SelectArgs<int, ::testing::tuple<bool, char, double, long>, 0, 3>::type | |||||
// is int(bool, long). | |||||
// | |||||
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args) | |||||
// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. | |||||
// For example, | |||||
// SelectArgs<int, tuple<bool, char, double>, 2, 0>::Select( | |||||
// ::testing::make_tuple(true, 'a', 2.5)) | |||||
// returns tuple (2.5, true). | |||||
// | |||||
// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be | |||||
// in the range [0, $n]. Duplicates are allowed and they don't have | |||||
// to be in an ascending or descending order. | |||||
template <typename Result, typename ArgumentTuple, $for i, [[int k$i]]> | |||||
class SelectArgs { | |||||
public: | |||||
typedef Result type($for i, [[GMOCK_FIELD_(ArgumentTuple, k$i)]]); | |||||
typedef typename Function<type>::ArgumentTuple SelectedArgs; | |||||
static SelectedArgs Select(const ArgumentTuple& args) { | |||||
return SelectedArgs($for i, [[get<k$i>(args)]]); | |||||
} | |||||
}; | |||||
$for i [[ | |||||
$range j 1..n | |||||
$range j1 1..i-1 | |||||
template <typename Result, typename ArgumentTuple$for j1[[, int k$j1]]> | |||||
class SelectArgs<Result, ArgumentTuple, | |||||
$for j, [[$if j <= i-1 [[k$j]] $else [[-1]]]]> { | |||||
public: | |||||
typedef Result type($for j1, [[GMOCK_FIELD_(ArgumentTuple, k$j1)]]); | |||||
typedef typename Function<type>::ArgumentTuple SelectedArgs; | |||||
static SelectedArgs Select(const ArgumentTuple& [[]] | |||||
$if i == 1 [[/* args */]] $else [[args]]) { | |||||
return SelectedArgs($for j1, [[get<k$j1>(args)]]); | |||||
} | |||||
}; | |||||
]] | |||||
#undef GMOCK_FIELD_ | |||||
$var ks = [[$for i, [[k$i]]]] | |||||
// Implements the WithArgs action. | |||||
template <typename InnerAction, $for i, [[int k$i = -1]]> | |||||
class WithArgsAction { | |||||
public: | |||||
explicit WithArgsAction(const InnerAction& action) : action_(action) {} | |||||
template <typename F> | |||||
operator Action<F>() const { return MakeAction(new Impl<F>(action_)); } | |||||
private: | |||||
template <typename F> | |||||
class Impl : public ActionInterface<F> { | |||||
public: | |||||
typedef typename Function<F>::Result Result; | |||||
typedef typename Function<F>::ArgumentTuple ArgumentTuple; | |||||
explicit Impl(const InnerAction& action) : action_(action) {} | |||||
virtual Result Perform(const ArgumentTuple& args) { | |||||
return action_.Perform(SelectArgs<Result, ArgumentTuple, $ks>::Select(args)); | |||||
} | |||||
private: | |||||
typedef typename SelectArgs<Result, ArgumentTuple, | |||||
$ks>::type InnerFunctionType; | |||||
Action<InnerFunctionType> action_; | |||||
}; | |||||
const InnerAction action_; | |||||
GTEST_DISALLOW_ASSIGN_(WithArgsAction); | |||||
}; | |||||
// A macro from the ACTION* family (defined later in this file) | |||||
// defines an action that can be used in a mock function. Typically, | |||||
// these actions only care about a subset of the arguments of the mock | |||||
// function. For example, if such an action only uses the second | |||||
// argument, it can be used in any mock function that takes >= 2 | |||||
// arguments where the type of the second argument is compatible. | |||||
// | |||||
// Therefore, the action implementation must be prepared to take more | |||||
// arguments than it needs. The ExcessiveArg type is used to | |||||
// represent those excessive arguments. In order to keep the compiler | |||||
// error messages tractable, we define it in the testing namespace | |||||
// instead of testing::internal. However, this is an INTERNAL TYPE | |||||
// and subject to change without notice, so a user MUST NOT USE THIS | |||||
// TYPE DIRECTLY. | |||||
struct ExcessiveArg {}; | |||||
// A helper class needed for implementing the ACTION* macros. | |||||
template <typename Result, class Impl> | |||||
class ActionHelper { | |||||
public: | |||||
$range i 0..n | |||||
$for i | |||||
[[ | |||||
$var template = [[$if i==0 [[]] $else [[ | |||||
$range j 0..i-1 | |||||
template <$for j, [[typename A$j]]> | |||||
]]]] | |||||
$range j 0..i-1 | |||||
$var As = [[$for j, [[A$j]]]] | |||||
$var as = [[$for j, [[get<$j>(args)]]]] | |||||
$range k 1..n-i | |||||
$var eas = [[$for k, [[ExcessiveArg()]]]] | |||||
$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]] | |||||
$template | |||||
static Result Perform(Impl* impl, const ::testing::tuple<$As>& args) { | |||||
return impl->template gmock_PerformImpl<$As>(args, $arg_list); | |||||
} | |||||
]] | |||||
}; | |||||
} // namespace internal | |||||
// Various overloads for Invoke(). | |||||
// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes | |||||
// the selected arguments of the mock function to an_action and | |||||
// performs it. It serves as an adaptor between actions with | |||||
// different argument lists. C++ doesn't support default arguments for | |||||
// function templates, so we have to overload it. | |||||
$range i 1..n | |||||
$for i [[ | |||||
$range j 1..i | |||||
template <$for j [[int k$j, ]]typename InnerAction> | |||||
inline internal::WithArgsAction<InnerAction$for j [[, k$j]]> | |||||
WithArgs(const InnerAction& action) { | |||||
return internal::WithArgsAction<InnerAction$for j [[, k$j]]>(action); | |||||
} | |||||
]] | |||||
// Creates an action that does actions a1, a2, ..., sequentially in | |||||
// each invocation. | |||||
$range i 2..n | |||||
$for i [[ | |||||
$range j 2..i | |||||
$var types = [[$for j, [[typename Action$j]]]] | |||||
$var Aas = [[$for j [[, Action$j a$j]]]] | |||||
template <typename Action1, $types> | |||||
$range k 1..i-1 | |||||
inline $for k [[internal::DoBothAction<Action$k, ]]Action$i$for k [[>]] | |||||
DoAll(Action1 a1$Aas) { | |||||
$if i==2 [[ | |||||
return internal::DoBothAction<Action1, Action2>(a1, a2); | |||||
]] $else [[ | |||||
$range j2 2..i | |||||
return DoAll(a1, DoAll($for j2, [[a$j2]])); | |||||
]] | |||||
} | |||||
]] | |||||
} // namespace testing | |||||
// The ACTION* family of macros can be used in a namespace scope to | |||||
// define custom actions easily. The syntax: | |||||
// | |||||
// ACTION(name) { statements; } | |||||
// | |||||
// will define an action with the given name that executes the | |||||
// statements. The value returned by the statements will be used as | |||||
// the return value of the action. Inside the statements, you can | |||||
// refer to the K-th (0-based) argument of the mock function by | |||||
// 'argK', and refer to its type by 'argK_type'. For example: | |||||
// | |||||
// ACTION(IncrementArg1) { | |||||
// arg1_type temp = arg1; | |||||
// return ++(*temp); | |||||
// } | |||||
// | |||||
// allows you to write | |||||
// | |||||
// ...WillOnce(IncrementArg1()); | |||||
// | |||||
// You can also refer to the entire argument tuple and its type by | |||||
// 'args' and 'args_type', and refer to the mock function type and its | |||||
// return type by 'function_type' and 'return_type'. | |||||
// | |||||
// Note that you don't need to specify the types of the mock function | |||||
// arguments. However rest assured that your code is still type-safe: | |||||
// you'll get a compiler error if *arg1 doesn't support the ++ | |||||
// operator, or if the type of ++(*arg1) isn't compatible with the | |||||
// mock function's return type, for example. | |||||
// | |||||
// Sometimes you'll want to parameterize the action. For that you can use | |||||
// another macro: | |||||
// | |||||
// ACTION_P(name, param_name) { statements; } | |||||
// | |||||
// For example: | |||||
// | |||||
// ACTION_P(Add, n) { return arg0 + n; } | |||||
// | |||||
// will allow you to write: | |||||
// | |||||
// ...WillOnce(Add(5)); | |||||
// | |||||
// Note that you don't need to provide the type of the parameter | |||||
// either. If you need to reference the type of a parameter named | |||||
// 'foo', you can write 'foo_type'. For example, in the body of | |||||
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type | |||||
// of 'n'. | |||||
// | |||||
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support | |||||
// multi-parameter actions. | |||||
// | |||||
// For the purpose of typing, you can view | |||||
// | |||||
// ACTION_Pk(Foo, p1, ..., pk) { ... } | |||||
// | |||||
// as shorthand for | |||||
// | |||||
// template <typename p1_type, ..., typename pk_type> | |||||
// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } | |||||
// | |||||
// In particular, you can provide the template type arguments | |||||
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); | |||||
// although usually you can rely on the compiler to infer the types | |||||
// for you automatically. You can assign the result of expression | |||||
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., | |||||
// pk_type>. This can be useful when composing actions. | |||||
// | |||||
// You can also overload actions with different numbers of parameters: | |||||
// | |||||
// ACTION_P(Plus, a) { ... } | |||||
// ACTION_P2(Plus, a, b) { ... } | |||||
// | |||||
// While it's tempting to always use the ACTION* macros when defining | |||||
// a new action, you should also consider implementing ActionInterface | |||||
// or using MakePolymorphicAction() instead, especially if you need to | |||||
// use the action a lot. While these approaches require more work, | |||||
// they give you more control on the types of the mock function | |||||
// arguments and the action parameters, which in general leads to | |||||
// better compiler error messages that pay off in the long run. They | |||||
// also allow overloading actions based on parameter types (as opposed | |||||
// to just based on the number of parameters). | |||||
// | |||||
// CAVEAT: | |||||
// | |||||
// ACTION*() can only be used in a namespace scope. The reason is | |||||
// that C++ doesn't yet allow function-local types to be used to | |||||
// instantiate templates. The up-coming C++0x standard will fix this. | |||||
// Once that's done, we'll consider supporting using ACTION*() inside | |||||
// a function. | |||||
// | |||||
// MORE INFORMATION: | |||||
// | |||||
// To learn more about using these macros, please search for 'ACTION' | |||||
// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md | |||||
$range i 0..n | |||||
$range k 0..n-1 | |||||
// An internal macro needed for implementing ACTION*(). | |||||
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ | |||||
const args_type& args GTEST_ATTRIBUTE_UNUSED_ | |||||
$for k [[, \ | |||||
arg$k[[]]_type arg$k GTEST_ATTRIBUTE_UNUSED_]] | |||||
// Sometimes you want to give an action explicit template parameters | |||||
// that cannot be inferred from its value parameters. ACTION() and | |||||
// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that | |||||
// and can be viewed as an extension to ACTION() and ACTION_P*(). | |||||
// | |||||
// The syntax: | |||||
// | |||||
// ACTION_TEMPLATE(ActionName, | |||||
// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), | |||||
// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } | |||||
// | |||||
// defines an action template that takes m explicit template | |||||
// parameters and n value parameters. name_i is the name of the i-th | |||||
// template parameter, and kind_i specifies whether it's a typename, | |||||
// an integral constant, or a template. p_i is the name of the i-th | |||||
// value parameter. | |||||
// | |||||
// Example: | |||||
// | |||||
// // DuplicateArg<k, T>(output) converts the k-th argument of the mock | |||||
// // function to type T and copies it to *output. | |||||
// ACTION_TEMPLATE(DuplicateArg, | |||||
// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), | |||||
// AND_1_VALUE_PARAMS(output)) { | |||||
// *output = T(::testing::get<k>(args)); | |||||
// } | |||||
// ... | |||||
// int n; | |||||
// EXPECT_CALL(mock, Foo(_, _)) | |||||
// .WillOnce(DuplicateArg<1, unsigned char>(&n)); | |||||
// | |||||
// To create an instance of an action template, write: | |||||
// | |||||
// ActionName<t1, ..., t_m>(v1, ..., v_n) | |||||
// | |||||
// where the ts are the template arguments and the vs are the value | |||||
// arguments. The value argument types are inferred by the compiler. | |||||
// If you want to explicitly specify the value argument types, you can | |||||
// provide additional template arguments: | |||||
// | |||||
// ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) | |||||
// | |||||
// where u_i is the desired type of v_i. | |||||
// | |||||
// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the | |||||
// number of value parameters, but not on the number of template | |||||
// parameters. Without the restriction, the meaning of the following | |||||
// is unclear: | |||||
// | |||||
// OverloadedAction<int, bool>(x); | |||||
// | |||||
// Are we using a single-template-parameter action where 'bool' refers | |||||
// to the type of x, or are we using a two-template-parameter action | |||||
// where the compiler is asked to infer the type of x? | |||||
// | |||||
// Implementation notes: | |||||
// | |||||
// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and | |||||
// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for | |||||
// implementing ACTION_TEMPLATE. The main trick we use is to create | |||||
// new macro invocations when expanding a macro. For example, we have | |||||
// | |||||
// #define ACTION_TEMPLATE(name, template_params, value_params) | |||||
// ... GMOCK_INTERNAL_DECL_##template_params ... | |||||
// | |||||
// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) | |||||
// to expand to | |||||
// | |||||
// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... | |||||
// | |||||
// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the | |||||
// preprocessor will continue to expand it to | |||||
// | |||||
// ... typename T ... | |||||
// | |||||
// This technique conforms to the C++ standard and is portable. It | |||||
// allows us to implement action templates using O(N) code, where N is | |||||
// the maximum number of template/value parameters supported. Without | |||||
// using it, we'd have to devote O(N^2) amount of code to implement all | |||||
// combinations of m and n. | |||||
// Declares the template parameters. | |||||
$range j 1..n | |||||
$for j [[ | |||||
$range m 0..j-1 | |||||
#define GMOCK_INTERNAL_DECL_HAS_$j[[]] | |||||
_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]] | |||||
]] | |||||
// Lists the template parameters. | |||||
$for j [[ | |||||
$range m 0..j-1 | |||||
#define GMOCK_INTERNAL_LIST_HAS_$j[[]] | |||||
_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]] | |||||
]] | |||||
// Declares the types of value parameters. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]] | |||||
_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]] | |||||
]] | |||||
// Initializes the value parameters. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\ | |||||
($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::testing::internal::move(gmock_p$j))]] | |||||
]] | |||||
// Declares the fields for storing the value parameters. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_DEFN_AND_$i[[]] | |||||
_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]] | |||||
]] | |||||
// Lists the value parameters. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_LIST_AND_$i[[]] | |||||
_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]] | |||||
]] | |||||
// Lists the value parameter types. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]] | |||||
_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]] | |||||
]] | |||||
// Declares the value parameters. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] | |||||
$for j, [[p$j##_type p$j]] | |||||
]] | |||||
// The suffix of the class template implementing the action template. | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] | |||||
$if i==1 [[P]] $elif i>=2 [[P$i]] | |||||
]] | |||||
// The name of the class template implementing the action template. | |||||
#define GMOCK_ACTION_CLASS_(name, value_params)\ | |||||
GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) | |||||
$range k 0..n-1 | |||||
#define ACTION_TEMPLATE(name, template_params, value_params)\ | |||||
template <GMOCK_INTERNAL_DECL_##template_params\ | |||||
GMOCK_INTERNAL_DECL_TYPE_##value_params>\ | |||||
class GMOCK_ACTION_CLASS_(name, value_params) {\ | |||||
public:\ | |||||
explicit GMOCK_ACTION_CLASS_(name, value_params)\ | |||||
GMOCK_INTERNAL_INIT_##value_params {}\ | |||||
template <typename F>\ | |||||
class gmock_Impl : public ::testing::ActionInterface<F> {\ | |||||
public:\ | |||||
typedef F function_type;\ | |||||
typedef typename ::testing::internal::Function<F>::Result return_type;\ | |||||
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ | |||||
args_type;\ | |||||
explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ | |||||
virtual return_type Perform(const args_type& args) {\ | |||||
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ | |||||
Perform(this, args);\ | |||||
}\ | |||||
template <$for k, [[typename arg$k[[]]_type]]>\ | |||||
return_type gmock_PerformImpl(const args_type& args[[]] | |||||
$for k [[, arg$k[[]]_type arg$k]]) const;\ | |||||
GMOCK_INTERNAL_DEFN_##value_params\ | |||||
private:\ | |||||
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ | |||||
};\ | |||||
template <typename F> operator ::testing::Action<F>() const {\ | |||||
return ::testing::Action<F>(\ | |||||
new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\ | |||||
}\ | |||||
GMOCK_INTERNAL_DEFN_##value_params\ | |||||
private:\ | |||||
GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ | |||||
};\ | |||||
template <GMOCK_INTERNAL_DECL_##template_params\ | |||||
GMOCK_INTERNAL_DECL_TYPE_##value_params>\ | |||||
inline GMOCK_ACTION_CLASS_(name, value_params)<\ | |||||
GMOCK_INTERNAL_LIST_##template_params\ | |||||
GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ | |||||
GMOCK_INTERNAL_DECL_##value_params) {\ | |||||
return GMOCK_ACTION_CLASS_(name, value_params)<\ | |||||
GMOCK_INTERNAL_LIST_##template_params\ | |||||
GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ | |||||
GMOCK_INTERNAL_LIST_##value_params);\ | |||||
}\ | |||||
template <GMOCK_INTERNAL_DECL_##template_params\ | |||||
GMOCK_INTERNAL_DECL_TYPE_##value_params>\ | |||||
template <typename F>\ | |||||
template <typename arg0_type, typename arg1_type, typename arg2_type, \ | |||||
typename arg3_type, typename arg4_type, typename arg5_type, \ | |||||
typename arg6_type, typename arg7_type, typename arg8_type, \ | |||||
typename arg9_type>\ | |||||
typename ::testing::internal::Function<F>::Result\ | |||||
GMOCK_ACTION_CLASS_(name, value_params)<\ | |||||
GMOCK_INTERNAL_LIST_##template_params\ | |||||
GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl<F>::\ | |||||
gmock_PerformImpl(\ | |||||
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const | |||||
$for i | |||||
[[ | |||||
$var template = [[$if i==0 [[]] $else [[ | |||||
$range j 0..i-1 | |||||
template <$for j, [[typename p$j##_type]]>\ | |||||
]]]] | |||||
$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]] | |||||
$else [[P$i]]]]]] | |||||
$range j 0..i-1 | |||||
$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] | |||||
$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] | |||||
$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::testing::internal::forward<p$j##_type>(gmock_p$j))]]]]]] | |||||
$var param_field_decls = [[$for j | |||||
[[ | |||||
p$j##_type p$j;\ | |||||
]]]] | |||||
$var param_field_decls2 = [[$for j | |||||
[[ | |||||
p$j##_type p$j;\ | |||||
]]]] | |||||
$var params = [[$for j, [[p$j]]]] | |||||
$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] | |||||
$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]] | |||||
$var arg_types_and_names = [[$for k, [[arg$k[[]]_type arg$k]]]] | |||||
$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]] | |||||
$else [[ACTION_P$i]]]] | |||||
#define $macro_name(name$for j [[, p$j]])\$template | |||||
class $class_name {\ | |||||
public:\ | |||||
[[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ | |||||
template <typename F>\ | |||||
class gmock_Impl : public ::testing::ActionInterface<F> {\ | |||||
public:\ | |||||
typedef F function_type;\ | |||||
typedef typename ::testing::internal::Function<F>::Result return_type;\ | |||||
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ | |||||
args_type;\ | |||||
[[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\ | |||||
virtual return_type Perform(const args_type& args) {\ | |||||
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ | |||||
Perform(this, args);\ | |||||
}\ | |||||
template <$typename_arg_types>\ | |||||
return_type gmock_PerformImpl(const args_type& args, [[]] | |||||
$arg_types_and_names) const;\$param_field_decls | |||||
private:\ | |||||
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ | |||||
};\ | |||||
template <typename F> operator ::testing::Action<F>() const {\ | |||||
return ::testing::Action<F>(new gmock_Impl<F>($params));\ | |||||
}\$param_field_decls2 | |||||
private:\ | |||||
GTEST_DISALLOW_ASSIGN_($class_name);\ | |||||
};\$template | |||||
inline $class_name$param_types name($param_types_and_names) {\ | |||||
return $class_name$param_types($params);\ | |||||
}\$template | |||||
template <typename F>\ | |||||
template <$typename_arg_types>\ | |||||
typename ::testing::internal::Function<F>::Result\ | |||||
$class_name$param_types::gmock_Impl<F>::gmock_PerformImpl(\ | |||||
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const | |||||
]] | |||||
$$ } // This meta comment fixes auto-indentation in Emacs. It won't | |||||
$$ // show up in the generated code. | |||||
namespace testing { | |||||
// The ACTION*() macros trigger warning C4100 (unreferenced formal | |||||
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in | |||||
// the macro definition, as the warnings are generated when the macro | |||||
// is expanded and macro expansion cannot contain #pragma. Therefore | |||||
// we suppress them here. | |||||
#ifdef _MSC_VER | |||||
# pragma warning(push) | |||||
# pragma warning(disable:4100) | |||||
#endif | |||||
// Various overloads for InvokeArgument<N>(). | |||||
// | |||||
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th | |||||
// (0-based) argument, which must be a k-ary callable, of the mock | |||||
// function, with arguments a1, a2, ..., a_k. | |||||
// | |||||
// Notes: | |||||
// | |||||
// 1. The arguments are passed by value by default. If you need to | |||||
// pass an argument by reference, wrap it inside ByRef(). For | |||||
// example, | |||||
// | |||||
// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) | |||||
// | |||||
// passes 5 and string("Hello") by value, and passes foo by | |||||
// reference. | |||||
// | |||||
// 2. If the callable takes an argument by reference but ByRef() is | |||||
// not used, it will receive the reference to a copy of the value, | |||||
// instead of the original value. For example, when the 0-th | |||||
// argument of the mock function takes a const string&, the action | |||||
// | |||||
// InvokeArgument<0>(string("Hello")) | |||||
// | |||||
// makes a copy of the temporary string("Hello") object and passes a | |||||
// reference of the copy, instead of the original temporary object, | |||||
// to the callable. This makes it easy for a user to define an | |||||
// InvokeArgument action from temporary values and have it performed | |||||
// later. | |||||
namespace internal { | |||||
namespace invoke_argument { | |||||
// Appears in InvokeArgumentAdl's argument list to help avoid | |||||
// accidental calls to user functions of the same name. | |||||
struct AdlTag {}; | |||||
// InvokeArgumentAdl - a helper for InvokeArgument. | |||||
// The basic overloads are provided here for generic functors. | |||||
// Overloads for other custom-callables are provided in the | |||||
// internal/custom/callback-actions.h header. | |||||
$range i 0..n | |||||
$for i | |||||
[[ | |||||
$range j 1..i | |||||
template <typename R, typename F[[$for j [[, typename A$j]]]]> | |||||
R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) { | |||||
return f([[$for j, [[a$j]]]]); | |||||
} | |||||
]] | |||||
} // namespace invoke_argument | |||||
} // namespace internal | |||||
$range i 0..n | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
ACTION_TEMPLATE(InvokeArgument, | |||||
HAS_1_TEMPLATE_PARAMS(int, k), | |||||
AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) { | |||||
using internal::invoke_argument::InvokeArgumentAdl; | |||||
return InvokeArgumentAdl<return_type>( | |||||
internal::invoke_argument::AdlTag(), | |||||
::testing::get<k>(args)$for j [[, p$j]]); | |||||
} | |||||
]] | |||||
// Various overloads for ReturnNew<T>(). | |||||
// | |||||
// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new | |||||
// instance of type T, constructed on the heap with constructor arguments | |||||
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. | |||||
$range i 0..n | |||||
$for i [[ | |||||
$range j 0..i-1 | |||||
$var ps = [[$for j, [[p$j]]]] | |||||
ACTION_TEMPLATE(ReturnNew, | |||||
HAS_1_TEMPLATE_PARAMS(typename, T), | |||||
AND_$i[[]]_VALUE_PARAMS($ps)) { | |||||
return new T($ps); | |||||
} | |||||
]] | |||||
#ifdef _MSC_VER | |||||
# pragma warning(pop) | |||||
#endif | |||||
} // namespace testing | |||||
// Include any custom callback actions added by the local installation. | |||||
// We must include this header at the end to make sure it can use the | |||||
// declarations from this file. | |||||
#include "gmock/internal/custom/gmock-generated-actions.h" | |||||
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ |