130#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
131#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
142#include <type_traits>
145#include "gmock/internal/gmock-internal-utils.h"
146#include "gmock/internal/gmock-port.h"
147#include "gmock/internal/gmock-pp.h"
150# pragma warning(push)
151# pragma warning(disable:4100)
172template <
typename T,
bool kDefaultConstructible>
174 static T Get() {
return T(); }
179 Assert(
false, __FILE__, __LINE__,
180 "Default action undefined for the function return type.");
181 return internal::Invalid<T>();
199 static bool Exists() {
200 return ::std::is_default_constructible<T>::value;
205 T, ::std::is_default_constructible<T>::value>::Get();
223 static bool Exists() {
return true; }
224 static T* Get() {
return nullptr; }
229#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
231 class BuiltInDefaultValue<type> { \
233 static bool Exists() { return true; } \
234 static type Get() { return value; } \
237GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
void, );
238GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string,
"");
239GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
bool,
false);
240GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned char,
'\0');
241GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed char,
'\0');
242GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
char,
'\0');
250#if GMOCK_WCHAR_T_IS_NATIVE_
251GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
wchar_t, 0U);
254GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned short, 0U);
255GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed short, 0);
256GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned int, 0U);
257GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed int, 0);
258GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned long, 0UL);
259GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed long, 0L);
260GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned long long, 0);
261GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed long long, 0);
262GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
float, 0);
263GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
double, 0);
265#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
268template <
typename P,
typename Q>
269using disjunction = typename ::std::conditional<P::value, P, Q>::type;
291 static void Set(T x) {
293 producer_ =
new FixedValueProducer(x);
299 typedef T (*FactoryFunction)();
300 static void SetFactory(FactoryFunction factory) {
302 producer_ =
new FactoryValueProducer(factory);
306 static void Clear() {
312 static bool IsSet() {
return producer_ !=
nullptr; }
316 static bool Exists() {
325 : producer_->Produce();
329 class ValueProducer {
331 virtual ~ValueProducer() {}
332 virtual T Produce() = 0;
335 class FixedValueProducer :
public ValueProducer {
337 explicit FixedValueProducer(T value) : value_(value) {}
338 T Produce()
override {
return value_; }
342 GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
345 class FactoryValueProducer :
public ValueProducer {
347 explicit FactoryValueProducer(FactoryFunction factory)
348 : factory_(factory) {}
349 T Produce()
override {
return factory_(); }
352 const FactoryFunction factory_;
353 GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
356 static ValueProducer* producer_;
365 static void Set(T& x) {
370 static void Clear() { address_ =
nullptr; }
373 static bool IsSet() {
return address_ !=
nullptr; }
377 static bool Exists() {
398 static bool Exists() {
return true; }
424 virtual Result Perform(
const ArgumentTuple& args) = 0;
441 struct ActionAdapter {
443 ::std::shared_ptr<ActionInterface<F>> impl_;
445 template <
typename... Args>
447 return impl_->Perform(
448 ::std::forward_as_tuple(::std::forward<Args>(args)...));
452 template <
typename G>
453 using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
468 typename =
typename std::enable_if<internal::disjunction<
469 IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
472 Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
477 : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
482 template <
typename Func>
486 bool IsDoDefault()
const {
return fun_ ==
nullptr; }
494 Result Perform(ArgumentTuple args)
const {
496 internal::IllegalDoDefault(__FILE__, __LINE__);
498 return internal::Apply(fun_, ::std::move(args));
502 template <
typename G>
505 template <
typename G>
506 void Init(G&& g, ::std::true_type) {
507 fun_ = ::std::forward<G>(g);
510 template <
typename G>
511 void Init(G&& g, ::std::false_type) {
512 fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
515 template <
typename FunctionImpl>
517 template <
typename... Args>
518 Result operator()(
const Args&...)
const {
519 return function_impl();
522 FunctionImpl function_impl;
526 ::std::function<F> fun_;
550template <
typename Impl>
555 template <
typename F>
557 return Action<F>(
new MonomorphicImpl<F>(impl_));
561 template <
typename F>
567 explicit MonomorphicImpl(
const Impl& impl) : impl_(impl) {}
569 Result Perform(
const ArgumentTuple& args)
override {
570 return impl_.template Perform<Result>(args);
594template <
typename Impl>
595inline PolymorphicAction<Impl> MakePolymorphicAction(
const Impl& impl) {
596 return PolymorphicAction<Impl>(impl);
605 explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
642 explicit ReturnAction(R value) : value_(
new R(std::move(value))) {}
646 template <
typename F>
657 GTEST_COMPILE_ASSERT_(
658 !std::is_reference<Result>::value,
659 use_ReturnRef_instead_of_Return_to_return_a_reference);
660 static_assert(!std::is_void<Result>::value,
661 "Can't use Return() on an action expected to return `void`.");
662 return Action<F>(
new Impl<R, F>(value_));
667 template <
typename R_,
typename F>
680 explicit Impl(
const std::shared_ptr<R>& value)
681 : value_before_cast_(*value),
682 value_(ImplicitCast_<Result>(value_before_cast_)) {}
684 Result Perform(
const ArgumentTuple&)
override {
return value_; }
687 GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
688 Result_cannot_be_a_reference_type);
691 R value_before_cast_;
694 GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
699 template <
typename R_,
typename F>
705 explicit Impl(
const std::shared_ptr<R>& wrapper)
706 : performed_(
false), wrapper_(wrapper) {}
708 Result Perform(
const ArgumentTuple&)
override {
709 GTEST_CHECK_(!performed_)
710 <<
"A ByMove() action should only be performed once.";
712 return std::move(wrapper_->payload);
717 const std::shared_ptr<R> wrapper_;
720 const std::shared_ptr<R> value_;
729 template <
typename Result,
typename ArgumentTuple>
730 static Result Perform(
const ArgumentTuple&) {
739 template <
typename Result,
typename ArgumentTuple>
740 static void Perform(
const ArgumentTuple&) {
741 static_assert(std::is_void<Result>::value,
"Result should be void.");
756 template <
typename F>
762 GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
763 use_Return_instead_of_ReturnRef_to_return_a_value);
769 template <
typename F>
775 explicit Impl(T& ref) : ref_(ref) {}
777 Result Perform(
const ArgumentTuple&)
override {
return ref_; }
798 template <
typename F>
804 GTEST_COMPILE_ASSERT_(
805 std::is_reference<Result>::value,
806 use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
812 template <
typename F>
818 explicit Impl(
const T& value) : value_(value) {}
820 Result Perform(
const ArgumentTuple&)
override {
return value_; }
835 GTEST_CHECK_(!values.empty())
836 <<
"ReturnRoundRobin requires at least one element.";
837 state_->values = std::move(values);
840 template <
typename... Args>
841 T operator()(Args&&...)
const {
842 return state_->Next();
848 T ret_val = values[i++];
849 if (i == values.size()) i = 0;
853 std::vector<T> values;
856 std::shared_ptr<State> state_ = std::make_shared<State>();
864 template <
typename F>
870template <
typename T1,
typename T2>
873 AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
875 template <
typename Result,
typename ArgumentTuple>
876 void Perform(
const ArgumentTuple& )
const {
885#if !GTEST_OS_WINDOWS_MOBILE
893 : errno_(errno_value),
895 template <
typename Result,
typename ArgumentTuple>
896 Result Perform(
const ArgumentTuple& )
const {
910template <
size_t N,
typename A,
typename =
void>
914 template <
typename... Args>
915 void operator()(
const Args&... args)
const {
916 *::std::get<N>(std::tie(args...)) = value;
921template <
class Class,
typename MethodPtr>
923 Class*
const obj_ptr;
924 const MethodPtr method_ptr;
926 template <
typename... Args>
927 auto operator()(Args&&... args)
const
928 ->
decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
929 return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
937template <
typename FunctionImpl>
939 FunctionImpl function_impl;
943 template <
typename... Args>
944 auto operator()(
const Args&...) ->
decltype(function_impl()) {
945 return function_impl();
950template <
class Class,
typename MethodPtr>
952 Class*
const obj_ptr;
953 const MethodPtr method_ptr;
956 decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
958 template <
typename... Args>
959 ReturnType operator()(
const Args&...)
const {
960 return (obj_ptr->*method_ptr)();
970 template <
typename F>
983 static_assert(std::is_void<Result>::value,
"Result type should be void.");
989 template <
typename F>
995 explicit Impl(
const A& action) : action_(action) {}
997 void Perform(
const ArgumentTuple& args)
override {
999 action_.Perform(args);
1014template <
typename InnerAction,
size_t... I>
1020 template <
typename R,
typename... Args>
1021 operator Action<R(Args...)>()
const {
1022 using TupleType = std::tuple<Args...>;
1023 Action<R(
typename std::tuple_element<I, TupleType>::type...)>
1026 return [converted](Args... args) -> R {
1027 return converted.Perform(std::forward_as_tuple(
1028 std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
1033template <
typename... Actions>
1036 template <
typename T>
1037 using NonFinalType =
1038 typename std::conditional<std::is_scalar<T>::value, T,
const T&>::type;
1040 template <
typename ActionT,
size_t... I>
1042 return {ActionT(std::get<I>(actions))...};
1046 std::tuple<Actions...> actions;
1048 template <
typename R,
typename... Args>
1049 operator Action<R(Args...)>()
const {
1051 std::vector<
Action<void(NonFinalType<Args>...)>> converted;
1053 R operator()(Args... args)
const {
1054 auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
1055 for (
auto& a : converted) {
1056 a.Perform(tuple_args);
1058 return last.Perform(std::move(tuple_args));
1061 return Op{Convert<
Action<void(NonFinalType<Args>...)>>(
1062 MakeIndexSequence<
sizeof...(Actions) - 1>()),
1063 std::get<
sizeof...(Actions) - 1>(actions)};
1067template <
typename T,
typename... Params>
1069 T* operator()()
const {
1070 return internal::Apply(
1071 [](
const Params&... unpacked_params) {
1072 return new T(unpacked_params...);
1076 std::tuple<Params...> params;
1081 template <
typename... Args>
1082 auto operator()(
const Args&... args)
const ->
1083 typename std::tuple_element<k, std::tuple<Args...>>::type {
1084 return std::get<k>(std::tie(args...));
1088template <
size_t k,
typename Ptr>
1092 template <
typename... Args>
1093 void operator()(
const Args&... args)
const {
1094 *pointer = std::get<k>(std::tie(args...));
1098template <
size_t k,
typename Ptr>
1102 template <
typename... Args>
1103 void operator()(
const Args&... args)
const {
1104 *pointer = *std::get<k>(std::tie(args...));
1108template <
size_t k,
typename T>
1112 template <
typename... Args>
1113 void operator()(Args&&... args)
const {
1115 typename ::std::tuple_element<k, std::tuple<Args...>>::type;
1116 static_assert(std::is_lvalue_reference<argk_type>::value,
1117 "Argument must be a reference type.");
1118 std::get<k>(std::tie(args...)) = value;
1122template <
size_t k,
typename I1,
typename I2>
1127 template <
typename... Args>
1128 void operator()(
const Args&... args)
const {
1129 auto value = std::get<k>(std::tie(args...));
1130 for (
auto it = first; it != last; ++it, (void)++value) {
1138 template <
typename... Args>
1139 void operator()(
const Args&... args)
const {
1140 delete std::get<k>(std::tie(args...));
1144template <
typename Ptr>
1147 template <
typename... Args>
1148 auto operator()(
const Args&...)
const ->
decltype(*pointer) {
1153#if GTEST_HAS_EXCEPTIONS
1154template <
typename T>
1158 template <
typename R,
typename... Args>
1159 operator Action<R(Args...)>()
const {
1161 return [copy](Args...) -> R {
throw copy; };
1198typedef internal::IgnoredValue Unused;
1203template <
typename... Action>
1204internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
1205 Action&&... action) {
1206 return {std::forward_as_tuple(std::forward<Action>(action)...)};
1214template <
size_t k,
typename InnerAction>
1215internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
1216WithArg(InnerAction&& action) {
1217 return {std::forward<InnerAction>(action)};
1224template <
size_t k,
size_t... ks,
typename InnerAction>
1225internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
1226WithArgs(InnerAction&& action) {
1227 return {std::forward<InnerAction>(action)};
1234template <
typename InnerAction>
1235internal::WithArgsAction<typename std::decay<InnerAction>::type>
1236WithoutArgs(InnerAction&& action) {
1237 return {std::forward<InnerAction>(action)};
1243template <
typename R>
1244internal::ReturnAction<R> Return(R value) {
1245 return internal::ReturnAction<R>(std::move(value));
1249inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
1250 return MakePolymorphicAction(internal::ReturnNullAction());
1254inline PolymorphicAction<internal::ReturnVoidAction> Return() {
1255 return MakePolymorphicAction(internal::ReturnVoidAction());
1259template <
typename R>
1260inline internal::ReturnRefAction<R> ReturnRef(R& x) {
1261 return internal::ReturnRefAction<R>(x);
1265template <
typename R, R* =
nullptr>
1266internal::ReturnRefAction<R> ReturnRef(R&&) =
delete;
1271template <
typename R>
1272inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(
const R& x) {
1273 return internal::ReturnRefOfCopyAction<R>(x);
1280template <
typename R>
1281internal::ByMoveWrapper<R> ByMove(R x) {
1282 return internal::ByMoveWrapper<R>(std::move(x));
1288template <
typename T>
1289internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
1290 return internal::ReturnRoundRobinAction<T>(std::move(vals));
1296template <
typename T>
1297internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
1298 std::initializer_list<T> vals) {
1299 return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
1303inline internal::DoDefaultAction DoDefault() {
1304 return internal::DoDefaultAction();
1309template <
size_t N,
typename T>
1310internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
1311 return {std::move(value)};
1315template <
size_t N,
typename T>
1316internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
1317 return {std::move(value)};
1321template <
typename T1,
typename T2>
1322PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
1323 return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
1326#if !GTEST_OS_WINDOWS_MOBILE
1329template <
typename T>
1330PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
1331SetErrnoAndReturn(
int errval, T result) {
1332 return MakePolymorphicAction(
1333 internal::SetErrnoAndReturnAction<T>(errval, result));
1344template <
typename FunctionImpl>
1345typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
1346 return std::forward<FunctionImpl>(function_impl);
1351template <
class Class,
typename MethodPtr>
1352internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
1353 MethodPtr method_ptr) {
1354 return {obj_ptr, method_ptr};
1358template <
typename FunctionImpl>
1359internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
1360InvokeWithoutArgs(FunctionImpl function_impl) {
1361 return {std::move(function_impl)};
1366template <
class Class,
typename MethodPtr>
1367internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
1368 Class* obj_ptr, MethodPtr method_ptr) {
1369 return {obj_ptr, method_ptr};
1375template <
typename A>
1376inline internal::IgnoreResultAction<A> IgnoreResult(
const A& an_action) {
1377 return internal::IgnoreResultAction<A>(an_action);
1390template <
typename T>
1391inline ::std::reference_wrapper<T> ByRef(T& l_value) {
1392 return ::std::reference_wrapper<T>(l_value);
1398template <
typename T,
typename... Params>
1399internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
1400 Params&&... params) {
1401 return {std::forward_as_tuple(std::forward<Params>(params)...)};
1406internal::ReturnArgAction<k> ReturnArg() {
1412template <
size_t k,
typename Ptr>
1413internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
1419template <
size_t k,
typename Ptr>
1420internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
1426template <
size_t k,
typename T>
1427internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
1429 return {std::forward<T>(value)};
1437template <
size_t k,
typename I1,
typename I2>
1438internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
1440 return {first, last};
1446internal::DeleteArgAction<k> DeleteArg() {
1451template <
typename Ptr>
1452internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
1458#if GTEST_HAS_EXCEPTIONS
1459template <
typename T>
1460internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
1461 return {std::forward<T>(exception)};
1487template <
typename Impl>
1491 explicit operator const Impl&()
const {
return *ptr; }
1492 std::shared_ptr<Impl> ptr;
1494 using type =
typename std::conditional<std::is_constructible<Impl>::value,
1498template <
typename R,
typename... Args,
typename Impl>
1500 using Base =
typename ImplBase<Impl>::type;
1501 using function_type = R(Args...);
1502 using args_type = std::tuple<Args...>;
1505 explicit ActionImpl(std::shared_ptr<Impl> impl) :
Base{std::move(impl)} { }
1507 R operator()(Args&&... arg)
const {
1508 static constexpr size_t kMaxArgs =
1509 sizeof...(Args) <= 10 ?
sizeof...(Args) : 10;
1510 return Apply(MakeIndexSequence<kMaxArgs>{},
1511 MakeIndexSequence<10 - kMaxArgs>{},
1512 args_type{std::forward<Args>(arg)...});
1515 template <std::size_t... arg_id, std::size_t... excess_id>
1517 const args_type& args)
const {
1524 return static_cast<const Impl&
>(*this).template gmock_PerformImpl<
1527 typename std::tuple_element<arg_id, args_type>::type...>(
1528 args, std::get<arg_id>(args)...,
1529 ((void)excess_id, kExcessArg)...);
1535template <
typename F,
typename Impl>
1541template <
typename F,
typename Impl>
1543 return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
1546#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
1547 , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
1548#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \
1549 const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
1550 GMOCK_INTERNAL_ARG_UNUSED, , 10)
1552#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
1553#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
1554 const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
1556#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
1557#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
1558 GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
1560#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
1561#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
1562 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
1564#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
1565#define GMOCK_ACTION_TYPE_PARAMS_(params) \
1566 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
1568#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
1569 , param##_type gmock_p##i
1570#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
1571 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
1573#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
1574 , std::forward<param##_type>(gmock_p##i)
1575#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
1576 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
1578#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
1579 , param(::std::forward<param##_type>(gmock_p##i))
1580#define GMOCK_ACTION_INIT_PARAMS_(params) \
1581 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
1583#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
1584#define GMOCK_ACTION_FIELD_PARAMS_(params) \
1585 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
1587#define GMOCK_INTERNAL_ACTION(name, full_name, params) \
1588 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
1591 explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \
1592 : impl_(std::make_shared<gmock_Impl>( \
1593 GMOCK_ACTION_GVALUE_PARAMS_(params))) { } \
1594 full_name(const full_name&) = default; \
1595 full_name(full_name&&) noexcept = default; \
1596 template <typename F> \
1597 operator ::testing::Action<F>() const { \
1598 return ::testing::internal::MakeAction<F>(impl_); \
1601 class gmock_Impl { \
1603 explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \
1604 : GMOCK_ACTION_INIT_PARAMS_(params) {} \
1605 template <typename function_type, typename return_type, \
1606 typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
1607 return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
1608 GMOCK_ACTION_FIELD_PARAMS_(params) \
1610 std::shared_ptr<const gmock_Impl> impl_; \
1612 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
1613 inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
1614 GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \
1615 return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>( \
1616 GMOCK_ACTION_GVALUE_PARAMS_(params)); \
1618 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
1619 template <typename function_type, typename return_type, typename args_type, \
1620 GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
1621 return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl:: \
1622 gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1627#define ACTION(name) \
1628 class name##Action { \
1630 explicit name##Action() noexcept {} \
1631 name##Action(const name##Action&) noexcept {} \
1632 template <typename F> \
1633 operator ::testing::Action<F>() const { \
1634 return ::testing::internal::MakeAction<F, gmock_Impl>(); \
1637 class gmock_Impl { \
1639 template <typename function_type, typename return_type, \
1640 typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
1641 return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
1644 inline name##Action name() GTEST_MUST_USE_RESULT_; \
1645 inline name##Action name() { return name##Action(); } \
1646 template <typename function_type, typename return_type, typename args_type, \
1647 GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
1648 return_type name##Action::gmock_Impl::gmock_PerformImpl( \
1649 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
1651#define ACTION_P(name, ...) \
1652 GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
1654#define ACTION_P2(name, ...) \
1655 GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
1657#define ACTION_P3(name, ...) \
1658 GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
1660#define ACTION_P4(name, ...) \
1661 GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
1663#define ACTION_P5(name, ...) \
1664 GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
1666#define ACTION_P6(name, ...) \
1667 GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
1669#define ACTION_P7(name, ...) \
1670 GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
1672#define ACTION_P8(name, ...) \
1673 GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
1675#define ACTION_P9(name, ...) \
1676 GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
1678#define ACTION_P10(name, ...) \
1679 GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
1684# pragma warning(pop)
Definition gtest_unittest.cc:5205
Definition gmock-actions.h:438
Definition gmock-actions.h:412
Definition gmock-actions.h:287
Definition gmock-actions.h:551
Definition gmock-actions.h:871
Definition gmock-actions.h:195
Definition gmock-actions.h:860
Definition gmock-actions.h:966
Definition gmock-actions.h:637
Definition gmock-actions.h:724
Definition gmock-actions.h:749
Definition gmock-actions.h:790
Definition gmock-actions.h:832
Definition gmock-actions.h:736
Definition gmock-actions.h:890
Definition gmock-actions.h:1485
Definition gmock-actions.h:173
Definition gmock-actions.h:604
Definition gmock-actions.h:1137
Definition gmock-actions.h:1034
Definition gmock-actions.h:1481
Definition gmock-internal-utils.h:435
Definition gmock-actions.h:1489
Definition gmock-actions.h:1488
Definition gtest-internal.h:1158
Definition gmock-actions.h:922
Definition gmock-actions.h:951
Definition gmock-actions.h:938
Definition gmock-actions.h:1080
Definition gmock-actions.h:1068
Definition gmock-actions.h:1145
Definition gmock-actions.h:1089
Definition gmock-actions.h:1099
Definition gmock-actions.h:1109
Definition gmock-actions.h:911
Definition gmock-actions.h:1123
Definition gmock-actions.h:1015