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"
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() { return ::std::is_default_constructible<T>::value; }
203 T, ::std::is_default_constructible<T>::value>::Get();
221 static bool Exists() {
return true; }
222 static T* Get() {
return nullptr; }
227#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
229 class BuiltInDefaultValue<type> { \
231 static bool Exists() { return true; } \
232 static type Get() { return value; } \
235GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
void, );
236GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string,
"");
237GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
bool,
false);
238GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned char,
'\0');
239GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed char,
'\0');
240GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
char,
'\0');
248#if GMOCK_WCHAR_T_IS_NATIVE_
249GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
wchar_t, 0U);
252GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned short, 0U);
253GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed short, 0);
254GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned int, 0U);
255GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed int, 0);
256GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned long, 0UL);
257GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed long, 0L);
258GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
unsigned long long, 0);
259GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
signed long long, 0);
260GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
float, 0);
261GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(
double, 0);
263#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
271 : std::integral_constant<bool, bool(!P::value)> {};
274template <
typename...>
278template <
typename P1>
283template <
typename P1,
typename... Ps>
285 : std::conditional<bool(P1::value), conjunction<Ps...>, P1>::type {};
287template <
typename...>
290template <
typename P1>
293template <
typename P1,
typename... Ps>
296 : std::conditional<!bool(P1::value), disjunction<Ps...>, P1>::type {};
298template <
typename...>
323template <
typename From,
typename To>
328 template <
typename T>
329 static void Accept(T);
332 template <
typename T>
336 template <typename T, typename = decltype(Accept<To>(Make<T>()))>
337 static std::true_type TestImplicitConversion(
int);
340 template <
typename T>
341 static std::false_type TestImplicitConversion(...);
344 using type =
decltype(TestImplicitConversion<From>(0));
345 static constexpr bool value = type::value;
351template <
typename F,
typename... Args>
352using call_result_t =
decltype(std::declval<F>()(std::declval<Args>()...));
354template <
typename Void,
typename R,
typename F,
typename... Args>
360template <
typename R,
typename F,
typename... Args>
363 std::is_void<R>::value,
365 is_implicitly_convertible<call_result_t<F, Args...>, R>>::type {};
369template <
typename R,
typename F,
typename... Args>
374typename std::add_const<T>::type& as_const(T& t) {
419template <
typename Result,
typename... Args>
424 template <
typename Callable>
427 std::is_constructible<typename std::decay<Callable>::type, Callable>,
434 template <
typename Callable>
437 std::is_constructible<typename std::decay<Callable>::type, Callable>,
446 template <
typename Callable,
447 typename std::enable_if<
454 OnceAction,
typename std::decay<Callable>::type>>,
459 : function_(StdFunctionAdaptor<
typename std::decay<Callable>::type>(
460 {}, std::forward<Callable>(callable))) {}
463 template <
typename Callable,
464 typename std::enable_if<
471 OnceAction,
typename std::decay<Callable>::type>>,
480 :
OnceAction(IgnoreIncomingArguments<
typename std::decay<Callable>::type>{
481 std::forward<Callable>(callable)}) {}
491 Result Call(Args... args) && {
492 return function_(std::forward<Args>(args)...);
503 template <
typename Callable>
504 class StdFunctionAdaptor final {
511 template <
typename F>
512 explicit StdFunctionAdaptor(
CallableTag, F&& callable)
513 : callable_(std::make_shared<Callable>(std::forward<F>(callable))) {}
533 template <
typename... ArgRefs>
534 internal::call_result_t<Callable, ArgRefs...> operator()(
535 ArgRefs&&... args)
const {
536 return std::move(*callable_)(std::forward<ArgRefs>(args)...);
542 std::shared_ptr<Callable> callable_;
547 template <
typename Callable>
548 struct IgnoreIncomingArguments {
549 internal::call_result_t<Callable> operator()(Args&&...) {
550 return std::move(callable)();
556 std::function<Result(Args...)> function_;
577 static void Set(T x) {
579 producer_ =
new FixedValueProducer(x);
585 typedef T (*FactoryFunction)();
586 static void SetFactory(FactoryFunction factory) {
588 producer_ =
new FactoryValueProducer(factory);
592 static void Clear() {
598 static bool IsSet() {
return producer_ !=
nullptr; }
602 static bool Exists() {
611 : producer_->Produce();
615 class ValueProducer {
617 virtual ~ValueProducer() {}
618 virtual T Produce() = 0;
621 class FixedValueProducer :
public ValueProducer {
623 explicit FixedValueProducer(T value) : value_(value) {}
624 T Produce()
override {
return value_; }
628 FixedValueProducer(
const FixedValueProducer&) =
delete;
629 FixedValueProducer& operator=(
const FixedValueProducer&) =
delete;
632 class FactoryValueProducer :
public ValueProducer {
634 explicit FactoryValueProducer(FactoryFunction factory)
635 : factory_(factory) {}
636 T Produce()
override {
return factory_(); }
639 const FactoryFunction factory_;
640 FactoryValueProducer(
const FactoryValueProducer&) =
delete;
641 FactoryValueProducer& operator=(
const FactoryValueProducer&) =
delete;
644 static ValueProducer* producer_;
653 static void Set(T& x) {
658 static void Clear() { address_ =
nullptr; }
661 static bool IsSet() {
return address_ !=
nullptr; }
665 static bool Exists() {
686 static bool Exists() {
return true; }
712 virtual Result Perform(
const ArgumentTuple& args) = 0;
728template <
typename R,
typename... Args>
731 using F = R(Args...);
735 struct ActionAdapter {
737 ::std::shared_ptr<ActionInterface<F>> impl_;
739 template <
typename... InArgs>
741 return impl_->Perform(
742 ::std::forward_as_tuple(::std::forward<InArgs>(args)...));
746 template <
typename G>
747 using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
763 IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
766 Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
771 : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
776 template <
typename Func>
778 : fun_(action.fun_) {}
781 bool IsDoDefault()
const {
return fun_ ==
nullptr; }
789 Result Perform(ArgumentTuple args)
const {
791 internal::IllegalDoDefault(__FILE__, __LINE__);
793 return internal::Apply(fun_, ::std::move(args));
805 R operator()(Args... args) && {
806 return action.Perform(
807 std::forward_as_tuple(std::forward<Args>(args)...));
815 template <
typename G>
818 template <
typename G>
819 void Init(G&& g, ::std::true_type) {
820 fun_ = ::std::forward<G>(g);
823 template <
typename G>
824 void Init(G&& g, ::std::false_type) {
825 fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
828 template <
typename FunctionImpl>
830 template <
typename... InArgs>
831 Result operator()(
const InArgs&...)
const {
832 return function_impl();
835 FunctionImpl function_impl;
839 ::std::function<F> fun_;
863template <
typename Impl>
868 template <
typename F>
870 return Action<F>(
new MonomorphicImpl<F>(impl_));
874 template <
typename F>
880 explicit MonomorphicImpl(
const Impl& impl) : impl_(impl) {}
882 Result Perform(
const ArgumentTuple& args)
override {
883 return impl_.template Perform<Result>(args);
907template <
typename Impl>
908inline PolymorphicAction<Impl> MakePolymorphicAction(
const Impl& impl) {
909 return PolymorphicAction<Impl>(impl);
918 explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
926 explicit ReturnAction(R value) : value_(std::move(value)) {}
928 template <
typename U,
typename... Args,
933 std::is_convertible<R, U>,
934 std::is_move_constructible<U>>::value>::type>
936 return Impl<U>(std::move(value_));
939 template <
typename U,
typename... Args,
944 std::is_convertible<const R&, U>,
945 std::is_copy_constructible<U>>::value>::type>
946 operator Action<U(Args...)>()
const {
947 return Impl<U>(value_);
952 template <
typename U>
957 explicit Impl(R&& input_value)
958 : state_(
new State(std::move(input_value))) {}
962 explicit Impl(
const R& input_value) : state_(
new State(input_value)) {}
964 U operator()() && {
return std::move(state_->value); }
965 U operator()()
const& {
return state_->value; }
980 explicit State(
const R& input_value_in)
981 : input_value(input_value_in),
990 value(ImplicitCast_<U>(internal::as_const(input_value))) {}
994 explicit State(R&& input_value_in)
995 : input_value(std::move(input_value_in)),
1002 value(ImplicitCast_<U>(std::move(input_value))) {}
1078 const std::shared_ptr<State> state_;
1089template <
typename T>
1093 : state_(
new State(std::move(wrapper.payload))) {}
1095 T operator()()
const {
1096 GTEST_CHECK_(!state_->called)
1097 <<
"A ByMove() action must be performed at most once.";
1099 state_->called =
true;
1100 return std::move(state_->value);
1107 explicit State(T&& value_in) : value(std::move(value_in)) {}
1110 bool called =
false;
1113 const std::shared_ptr<State> state_;
1122 template <
typename Result,
typename ArgumentTuple>
1123 static Result Perform(
const ArgumentTuple&) {
1132 template <
typename Result,
typename ArgumentTuple>
1133 static void Perform(
const ArgumentTuple&) {
1134 static_assert(std::is_void<Result>::value,
"Result should be void.");
1141template <
typename T>
1149 template <
typename F>
1155 static_assert(std::is_reference<Result>::value,
1156 "use Return instead of ReturnRef to return a value");
1162 template <
typename F>
1168 explicit Impl(T& ref) : ref_(ref) {}
1170 Result Perform(
const ArgumentTuple&)
override {
return ref_; }
1182template <
typename T>
1191 template <
typename F>
1197 static_assert(std::is_reference<Result>::value,
1198 "use Return instead of ReturnRefOfCopy to return a value");
1204 template <
typename F>
1210 explicit Impl(
const T& value) : value_(value) {}
1212 Result Perform(
const ArgumentTuple&)
override {
return value_; }
1223template <
typename T>
1227 GTEST_CHECK_(!values.empty())
1228 <<
"ReturnRoundRobin requires at least one element.";
1229 state_->values = std::move(values);
1232 template <
typename... Args>
1233 T operator()(Args&&...)
const {
1234 return state_->Next();
1240 T ret_val = values[i++];
1241 if (i == values.size()) i = 0;
1245 std::vector<T> values;
1248 std::shared_ptr<State> state_ = std::make_shared<State>();
1256 template <
typename F>
1264template <
typename T1,
typename T2>
1267 AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
1269 template <
typename Result,
typename ArgumentTuple>
1270 void Perform(
const ArgumentTuple& )
const {
1279#if !GTEST_OS_WINDOWS_MOBILE
1283template <
typename T>
1287 : errno_(errno_value), result_(result) {}
1288 template <
typename Result,
typename ArgumentTuple>
1289 Result Perform(
const ArgumentTuple& )
const {
1303template <
size_t N,
typename A,
typename =
void>
1307 template <
typename... Args>
1308 void operator()(
const Args&... args)
const {
1309 *::std::get<N>(std::tie(args...)) = value;
1314template <
class Class,
typename MethodPtr>
1316 Class*
const obj_ptr;
1317 const MethodPtr method_ptr;
1319 template <
typename... Args>
1320 auto operator()(Args&&... args)
const
1321 ->
decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
1322 return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
1330template <
typename FunctionImpl>
1332 FunctionImpl function_impl;
1336 template <
typename... Args>
1337 auto operator()(
const Args&...) ->
decltype(function_impl()) {
1338 return function_impl();
1343template <
class Class,
typename MethodPtr>
1345 Class*
const obj_ptr;
1346 const MethodPtr method_ptr;
1349 decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
1351 template <
typename... Args>
1352 ReturnType operator()(
const Args&...)
const {
1353 return (obj_ptr->*method_ptr)();
1358template <
typename A>
1363 template <
typename F>
1376 static_assert(std::is_void<Result>::value,
"Result type should be void.");
1382 template <
typename F>
1388 explicit Impl(
const A& action) : action_(action) {}
1390 void Perform(
const ArgumentTuple& args)
override {
1392 action_.Perform(args);
1407template <
typename InnerAction,
size_t... I>
1409 InnerAction inner_action;
1413 template <
typename R,
typename... Args>
1414 using InnerSignature =
1415 R(
typename std::tuple_element<I, std::tuple<Args...>>::type...);
1423 template <
typename R,
typename... Args,
1424 typename std::enable_if<
1425 std::is_convertible<
1434 I, std::tuple<Args...>>...)>>::value,
1438 OnceAction<InnerSignature<R, Args...>> inner_action;
1440 R operator()(Args&&... args) && {
1441 return std::move(inner_action)
1443 std::forward_as_tuple(std::forward<Args>(args)...))...);
1447 return OA{std::move(inner_action)};
1450 template <
typename R,
typename... Args,
1451 typename std::enable_if<
1452 std::is_convertible<
1460 Action<R(internal::TupleElement<
1461 I, std::tuple<Args...>>...)>>::value,
1463 operator Action<R(Args...)>()
const {
1464 Action<InnerSignature<R, Args...>> converted(inner_action);
1466 return [converted](Args&&... args) -> R {
1467 return converted.Perform(std::forward_as_tuple(
1468 std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
1473template <
typename... Actions>
1477template <
typename FinalAction>
1482 template <
typename T>
1484 : final_action_(std::forward<T>(action)) {}
1492 template <
typename R,
typename... Args,
1493 typename std::enable_if<
1494 std::is_convertible<FinalAction,
OnceAction<R(Args...)>>::value,
1497 return std::move(final_action_);
1501 typename R,
typename... Args,
1502 typename std::enable_if<
1503 std::is_convertible<
const FinalAction&,
Action<R(Args...)>>::value,
1505 operator Action<R(Args...)>()
const {
1506 return final_action_;
1510 FinalAction final_action_;
1515template <
typename InitialAction,
typename... OtherActions>
1566 template <
typename T>
1567 using InitialActionArgType =
1568 typename std::conditional<std::is_scalar<T>::value, T,
const T&>::type;
1573 template <
typename T,
typename... U>
1575 U&&... other_actions)
1576 :
Base({}, std::forward<U>(other_actions)...),
1577 initial_action_(std::forward<T>(initial_action)) {}
1579 template <
typename R,
typename... Args,
1580 typename std::enable_if<
1584 std::is_convertible<
1586 OnceAction<void(InitialActionArgType<Args>...)>>,
1587 std::is_convertible<Base,
OnceAction<R(Args...)>>>::value,
1594 OnceAction<void(InitialActionArgType<Args>...)> initial_action;
1597 R operator()(Args... args) && {
1598 std::move(initial_action)
1599 .Call(
static_cast<InitialActionArgType<Args>
>(args)...);
1601 return std::move(remaining_actions).Call(std::forward<Args>(args)...);
1606 std::move(initial_action_),
1607 std::move(
static_cast<Base&
>(*
this)),
1612 typename R,
typename... Args,
1613 typename std::enable_if<
1617 std::is_convertible<
const InitialAction&,
1618 Action<void(InitialActionArgType<Args>...)>>,
1619 std::is_convertible<
const Base&, Action<R(Args...)>>>::value,
1621 operator Action<R(Args...)>()
const {
1626 Action<void(InitialActionArgType<Args>...)> initial_action;
1627 Action<R(Args...)> remaining_actions;
1629 R operator()(Args... args)
const {
1630 initial_action.Perform(std::forward_as_tuple(
1631 static_cast<InitialActionArgType<Args>
>(args)...));
1633 return remaining_actions.Perform(
1634 std::forward_as_tuple(std::forward<Args>(args)...));
1640 static_cast<const Base&
>(*this),
1645 InitialAction initial_action_;
1648template <
typename T,
typename... Params>
1650 T* operator()()
const {
1651 return internal::Apply(
1652 [](
const Params&... unpacked_params) {
1653 return new T(unpacked_params...);
1657 std::tuple<Params...> params;
1662 template <
typename... Args,
1663 typename =
typename std::enable_if<(k <
sizeof...(Args))>::type>
1664 auto operator()(Args&&... args)
const ->
decltype(std::get<k>(
1665 std::forward_as_tuple(std::forward<Args>(args)...))) {
1666 return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
1670template <
size_t k,
typename Ptr>
1674 template <
typename... Args>
1675 void operator()(
const Args&... args)
const {
1676 *pointer = std::get<k>(std::tie(args...));
1680template <
size_t k,
typename Ptr>
1684 template <
typename... Args>
1685 void operator()(
const Args&... args)
const {
1686 *pointer = *std::get<k>(std::tie(args...));
1690template <
size_t k,
typename T>
1694 template <
typename... Args>
1695 void operator()(Args&&... args)
const {
1697 typename ::std::tuple_element<k, std::tuple<Args...>>::type;
1698 static_assert(std::is_lvalue_reference<argk_type>::value,
1699 "Argument must be a reference type.");
1700 std::get<k>(std::tie(args...)) = value;
1704template <
size_t k,
typename I1,
typename I2>
1709 template <
typename... Args>
1710 void operator()(
const Args&... args)
const {
1711 auto value = std::get<k>(std::tie(args...));
1712 for (
auto it = first; it != last; ++it, (void)++value) {
1720 template <
typename... Args>
1721 void operator()(
const Args&... args)
const {
1722 delete std::get<k>(std::tie(args...));
1726template <
typename Ptr>
1729 template <
typename... Args>
1730 auto operator()(
const Args&...)
const ->
decltype(*pointer) {
1735#if GTEST_HAS_EXCEPTIONS
1736template <
typename T>
1740 template <
typename R,
typename... Args>
1741 operator Action<R(Args...)>()
const {
1743 return [copy](Args...) -> R {
throw copy; };
1780typedef internal::IgnoredValue Unused;
1785template <
typename... Action>
1786internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
1787 Action&&... action) {
1788 return internal::DoAllAction<typename std::decay<Action>::type...>(
1789 {}, std::forward<Action>(action)...);
1797template <
size_t k,
typename InnerAction>
1798internal::WithArgsAction<typename std::decay<InnerAction>::type, k> WithArg(
1799 InnerAction&& action) {
1800 return {std::forward<InnerAction>(action)};
1807template <
size_t k,
size_t... ks,
typename InnerAction>
1808internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
1809WithArgs(InnerAction&& action) {
1810 return {std::forward<InnerAction>(action)};
1817template <
typename InnerAction>
1818internal::WithArgsAction<typename std::decay<InnerAction>::type> WithoutArgs(
1819 InnerAction&& action) {
1820 return {std::forward<InnerAction>(action)};
1847template <
typename R>
1848internal::ReturnAction<R> Return(R value) {
1849 return internal::ReturnAction<R>(std::move(value));
1853inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
1854 return MakePolymorphicAction(internal::ReturnNullAction());
1858inline PolymorphicAction<internal::ReturnVoidAction> Return() {
1859 return MakePolymorphicAction(internal::ReturnVoidAction());
1863template <
typename R>
1864inline internal::ReturnRefAction<R> ReturnRef(R& x) {
1865 return internal::ReturnRefAction<R>(x);
1869template <
typename R, R* =
nullptr>
1870internal::ReturnRefAction<R> ReturnRef(R&&) =
delete;
1875template <
typename R>
1876inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(
const R& x) {
1877 return internal::ReturnRefOfCopyAction<R>(x);
1886template <
typename R>
1887internal::ByMoveWrapper<R> ByMove(R x) {
1888 return internal::ByMoveWrapper<R>(std::move(x));
1894template <
typename T>
1895internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
1896 return internal::ReturnRoundRobinAction<T>(std::move(vals));
1902template <
typename T>
1903internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
1904 std::initializer_list<T> vals) {
1905 return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
1909inline internal::DoDefaultAction DoDefault() {
1910 return internal::DoDefaultAction();
1915template <
size_t N,
typename T>
1916internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
1917 return {std::move(value)};
1921template <
size_t N,
typename T>
1922internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
1923 return {std::move(value)};
1927template <
typename T1,
typename T2>
1928PolymorphicAction<internal::AssignAction<T1, T2>> Assign(T1* ptr, T2 val) {
1929 return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
1932#if !GTEST_OS_WINDOWS_MOBILE
1935template <
typename T>
1936PolymorphicAction<internal::SetErrnoAndReturnAction<T>> SetErrnoAndReturn(
1937 int errval, T result) {
1938 return MakePolymorphicAction(
1939 internal::SetErrnoAndReturnAction<T>(errval, result));
1950template <
typename FunctionImpl>
1951typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
1952 return std::forward<FunctionImpl>(function_impl);
1957template <
class Class,
typename MethodPtr>
1958internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
1959 MethodPtr method_ptr) {
1960 return {obj_ptr, method_ptr};
1964template <
typename FunctionImpl>
1965internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
1966InvokeWithoutArgs(FunctionImpl function_impl) {
1967 return {std::move(function_impl)};
1972template <
class Class,
typename MethodPtr>
1973internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
1974 Class* obj_ptr, MethodPtr method_ptr) {
1975 return {obj_ptr, method_ptr};
1981template <
typename A>
1982inline internal::IgnoreResultAction<A> IgnoreResult(
const A& an_action) {
1983 return internal::IgnoreResultAction<A>(an_action);
1996template <
typename T>
1997inline ::std::reference_wrapper<T> ByRef(T& l_value) {
1998 return ::std::reference_wrapper<T>(l_value);
2004template <
typename T,
typename... Params>
2005internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
2006 Params&&... params) {
2007 return {std::forward_as_tuple(std::forward<Params>(params)...)};
2012internal::ReturnArgAction<k> ReturnArg() {
2018template <
size_t k,
typename Ptr>
2019internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
2025template <
size_t k,
typename Ptr>
2026internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
2032template <
size_t k,
typename T>
2033internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
2035 return {std::forward<T>(value)};
2043template <
size_t k,
typename I1,
typename I2>
2044internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
2046 return {first, last};
2052internal::DeleteArgAction<k> DeleteArg() {
2057template <
typename Ptr>
2058internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
2064#if GTEST_HAS_EXCEPTIONS
2065template <
typename T>
2066internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
2067 return {std::forward<T>(exception)};
2091template <
typename F,
typename Impl>
2094template <
typename Impl>
2098 explicit operator const Impl&()
const {
return *ptr; }
2099 std::shared_ptr<Impl> ptr;
2101 using type =
typename std::conditional<std::is_constructible<Impl>::value,
2105template <
typename R,
typename... Args,
typename Impl>
2107 using Base =
typename ImplBase<Impl>::type;
2108 using function_type = R(Args...);
2109 using args_type = std::tuple<Args...>;
2112 explicit ActionImpl(std::shared_ptr<Impl> impl) :
Base{std::move(impl)} {}
2114 R operator()(Args&&... arg)
const {
2115 static constexpr size_t kMaxArgs =
2116 sizeof...(Args) <= 10 ?
sizeof...(Args) : 10;
2117 return Apply(MakeIndexSequence<kMaxArgs>{},
2118 MakeIndexSequence<10 - kMaxArgs>{},
2119 args_type{std::forward<Args>(arg)...});
2122 template <std::size_t... arg_id, std::size_t... excess_id>
2124 const args_type& args)
const {
2131 return static_cast<const Impl&
>(*this)
2132 .template gmock_PerformImpl<
2136 typename std::tuple_element<arg_id, args_type>::type...>(
2137 args, std::get<arg_id>(args)...,
2138 ((void)excess_id, kExcessArg)...);
2144template <
typename F,
typename Impl>
2150template <
typename F,
typename Impl>
2152 return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
2155#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
2156 , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
2157#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \
2158 const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
2159 GMOCK_INTERNAL_ARG_UNUSED, , 10)
2161#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
2162#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
2163 const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
2165#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
2166#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
2167 GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
2169#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
2170#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
2171 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
2173#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
2174#define GMOCK_ACTION_TYPE_PARAMS_(params) \
2175 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
2177#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
2178 , param##_type gmock_p##i
2179#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
2180 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
2182#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
2183 , std::forward<param##_type>(gmock_p##i)
2184#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
2185 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
2187#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
2188 , param(::std::forward<param##_type>(gmock_p##i))
2189#define GMOCK_ACTION_INIT_PARAMS_(params) \
2190 GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
2192#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
2193#define GMOCK_ACTION_FIELD_PARAMS_(params) \
2194 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
2196#define GMOCK_INTERNAL_ACTION(name, full_name, params) \
2197 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
2200 explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \
2201 : impl_(std::make_shared<gmock_Impl>( \
2202 GMOCK_ACTION_GVALUE_PARAMS_(params))) {} \
2203 full_name(const full_name&) = default; \
2204 full_name(full_name&&) noexcept = default; \
2205 template <typename F> \
2206 operator ::testing::Action<F>() const { \
2207 return ::testing::internal::MakeAction<F>(impl_); \
2211 class gmock_Impl { \
2213 explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \
2214 : GMOCK_ACTION_INIT_PARAMS_(params) {} \
2215 template <typename function_type, typename return_type, \
2216 typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
2217 return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
2218 GMOCK_ACTION_FIELD_PARAMS_(params) \
2220 std::shared_ptr<const gmock_Impl> impl_; \
2222 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
2223 inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
2224 GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_; \
2225 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
2226 inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
2227 GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \
2228 return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>( \
2229 GMOCK_ACTION_GVALUE_PARAMS_(params)); \
2231 template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
2232 template <typename function_type, typename return_type, typename args_type, \
2233 GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
2235 full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::gmock_PerformImpl( \
2236 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
2241#define ACTION(name) \
2242 class name##Action { \
2244 explicit name##Action() noexcept {} \
2245 name##Action(const name##Action&) noexcept {} \
2246 template <typename F> \
2247 operator ::testing::Action<F>() const { \
2248 return ::testing::internal::MakeAction<F, gmock_Impl>(); \
2252 class gmock_Impl { \
2254 template <typename function_type, typename return_type, \
2255 typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
2256 return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
2259 inline name##Action name() GTEST_MUST_USE_RESULT_; \
2260 inline name##Action name() { return name##Action(); } \
2261 template <typename function_type, typename return_type, typename args_type, \
2262 GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
2263 return_type name##Action::gmock_Impl::gmock_PerformImpl( \
2264 GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
2266#define ACTION_P(name, ...) \
2267 GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
2269#define ACTION_P2(name, ...) \
2270 GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
2272#define ACTION_P3(name, ...) \
2273 GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
2275#define ACTION_P4(name, ...) \
2276 GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
2278#define ACTION_P5(name, ...) \
2279 GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
2281#define ACTION_P6(name, ...) \
2282 GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
2284#define ACTION_P7(name, ...) \
2285 GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
2287#define ACTION_P8(name, ...) \
2288 GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
2290#define ACTION_P9(name, ...) \
2291 GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
2293#define ACTION_P10(name, ...) \
2294 GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
Definition gtest_unittest.cc:5101
Definition gmock-actions.h:720
Definition gmock-actions.h:700
Definition gmock-actions.h:573
Definition gmock-actions.h:382
Definition gmock-actions.h:864
Definition gmock-actions.h:1265
Definition gmock-actions.h:195
Definition gmock-actions.h:1474
Definition gmock-actions.h:1252
Definition gmock-actions.h:1359
Definition gmock-actions.h:924
Definition gmock-actions.h:1117
Definition gmock-actions.h:1142
Definition gmock-actions.h:1183
Definition gmock-actions.h:1224
Definition gmock-actions.h:1129
Definition gmock-actions.h:1284
Definition gmock-actions.h:509
Definition gmock-actions.h:2092
Definition gmock-actions.h:173
Definition gmock-actions.h:917
Definition gmock-actions.h:1719
Definition gmock-actions.h:1480
Definition gmock-actions.h:1571
Definition gmock-actions.h:2087
Definition gmock-internal-utils.h:439
Definition gmock-actions.h:2096
Definition gmock-actions.h:2095
Definition gtest-internal.h:1159
Definition gmock-actions.h:1315
Definition gmock-actions.h:1344
Definition gmock-actions.h:1331
Definition gmock-actions.h:1661
Definition gmock-actions.h:1649
Definition gmock-actions.h:1727
Definition gmock-actions.h:1671
Definition gmock-actions.h:1681
Definition gmock-actions.h:1691
Definition gmock-actions.h:1304
Definition gmock-actions.h:1705
Definition gmock-actions.h:1408
Definition gmock-actions.h:275
Definition gmock-actions.h:288
Definition gmock-actions.h:355
Definition gmock-actions.h:324
Definition gmock-actions.h:271