130 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 131 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 138 #include <functional> 142 #include <type_traits> 150 #pragma warning(push) 151 #pragma warning(disable : 4100) 172 template <
typename T,
bool kDefaultConstructible>
174 static T
Get() {
return T(); }
176 template <
typename T>
179 Assert(
false, __FILE__, __LINE__,
180 "Default action undefined for the function return type.");
181 return internal::Invalid<T>();
194 template <
typename T>
199 static bool Exists() { return ::std::is_default_constructible<T>::value; }
203 T, ::std::is_default_constructible<T>::value>
::Get();
209 template <
typename T>
218 template <
typename T>
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; } \ 248 #if GMOCK_WCHAR_T_IS_NATIVE_ 263 #undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ 268 template <
typename P>
271 : std::integral_constant<bool, bool(!P::value)> {};
274 template <
typename...>
278 template <
typename P1>
283 template <
typename P1,
typename... Ps>
285 : std::conditional<bool(P1::value), conjunction<Ps...>, P1>
::type {};
287 template <
typename...>
290 template <
typename P1>
293 template <
typename P1,
typename... Ps>
296 : std::conditional<!bool(P1::value), disjunction<Ps...>, P1>
::type {};
298 template <
typename...>
323 template <
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;
351 template <
typename F,
typename... Args>
354 template <
typename Void,
typename R,
typename F,
typename... Args>
360 template <
typename R,
typename F,
typename... Args>
363 std::is_void<R>::value,
365 is_implicitly_convertible<call_result_t<F, Args...>, R>>
::type {};
369 template <
typename R,
typename F,
typename... Args>
373 template <
typename T>
381 template <
typename F>
419 template <
typename Result,
typename... Args>
424 template <
typename Callable>
434 template <
typename Callable>
437 std::is_constructible<typename std::decay<Callable>::type, Callable>,
440 internal::is_callable_r<Result, typename std::decay<Callable>::type>>;
446 template <
typename Callable,
447 typename std::enable_if<
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)}) {}
485 OnceAction(
const OnceAction&) =
delete;
486 OnceAction& operator=(
const OnceAction&) =
delete;
487 OnceAction(OnceAction&&) =
default;
492 return function_(std::forward<Args>(args)...);
503 template <
typename Callable>
504 class StdFunctionAdaptor final {
509 struct CallableTag 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>
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 {
550 return std::move(callable)();
556 std::function<Result(Args...)> function_;
572 template <
typename T>
579 producer_ =
new FixedValueProducer(x);
585 typedef T (*FactoryFunction)();
588 producer_ =
new FactoryValueProducer(factory);
598 static bool IsSet() {
return producer_ !=
nullptr; }
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_;
649 template <
typename T>
658 static void Clear() { address_ =
nullptr; }
661 static bool IsSet() {
return address_ !=
nullptr; }
691 template <
typename T>
695 template <
typename T>
699 template <
typename F>
712 virtual Result Perform(
const ArgumentTuple& args) = 0;
719 template <
typename F>
728 template <
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_) {}
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) {
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_;
863 template <
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);
895 template <
typename F>
907 template <
typename Impl>
916 template <
typename T>
923 template <
typename R>
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,
942 negation<std::is_same<void, U>>,
943 negation<std::is_reference<U>>,
944 std::is_convertible<const R&, U>,
945 std::is_copy_constructible<U>>::value>
::type>
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),
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_;
1089 template <
typename T>
1093 : state_(new State(
std::move(wrapper.payload))) {}
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>
1132 template <
typename Result,
typename ArgumentTuple>
1134 static_assert(std::is_void<Result>::value,
"Result should be void.");
1141 template <
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_; }
1182 template <
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_; }
1223 template <
typename T>
1228 <<
"ReturnRoundRobin requires at least one element.";
1229 state_->values = std::move(values);
1232 template <
typename... Args>
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>
1264 template <
typename T1,
typename T2>
1269 template <
typename Result,
typename ArgumentTuple>
1279 #if !GTEST_OS_WINDOWS_MOBILE 1283 template <
typename T>
1287 : errno_(errno_value), result_(result) {}
1288 template <
typename Result,
typename ArgumentTuple>
1299 #endif // !GTEST_OS_WINDOWS_MOBILE 1303 template <
size_t N,
typename A,
typename =
void>
1307 template <
typename... Args>
1309 *::std::get<N>(std::tie(args...)) = value;
1314 template <
class Class,
typename MethodPtr>
1319 template <
typename... Args>
1321 -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
1322 return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
1330 template <
typename FunctionImpl>
1336 template <
typename... Args>
1338 return function_impl();
1343 template <
class Class,
typename MethodPtr>
1349 decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
1351 template <
typename... Args>
1353 return (obj_ptr->*method_ptr)();
1358 template <
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);
1407 template <
typename InnerAction,
size_t... I>
1413 template <
typename R,
typename... Args>
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<
1461 I, std::tuple<Args...>>...)>>::value,
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)...))...));
1473 template <
typename... Actions>
1477 template <
typename FinalAction>
1480 struct UserConstructorTag {};
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,
1506 return final_action_;
1510 FinalAction final_action_;
1515 template <
typename InitialAction,
typename... OtherActions>
1566 template <
typename T>
1567 using InitialActionArgType =
1568 typename std::conditional<std::is_scalar<T>::value, T,
const T&>
::type;
1571 struct UserConstructorTag {};
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<
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&,
1619 std::is_convertible<
const Base&,
Action<R(Args...)>>>::value,
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_;
1648 template <
typename T,
typename... Params>
1652 [](
const Params&... unpacked_params) {
1653 return new T(unpacked_params...);
1662 template <
typename... Args,
1663 typename =
typename std::enable_if<(
k <
sizeof...(Args))>
::type>
1665 std::forward_as_tuple(std::forward<Args>(args)...))) {
1666 return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
1670 template <
size_t k,
typename Ptr>
1674 template <
typename... Args>
1676 *pointer = std::get<k>(std::tie(args...));
1680 template <
size_t k,
typename Ptr>
1684 template <
typename... Args>
1686 *pointer = *std::get<k>(std::tie(args...));
1690 template <
size_t k,
typename T>
1694 template <
typename... Args>
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;
1704 template <
size_t k,
typename I1,
typename I2>
1709 template <
typename... Args>
1711 auto value = std::get<k>(std::tie(args...));
1712 for (
auto it = first; it != last; ++it, (void)++value) {
1720 template <
typename... Args>
1722 delete std::get<k>(std::tie(args...));
1726 template <
typename Ptr>
1729 template <
typename... Args>
1735 #if GTEST_HAS_EXCEPTIONS 1736 template <
typename T>
1737 struct ThrowAction {
1740 template <
typename R,
typename... Args>
1741 operator Action<R(Args...)>()
const {
1743 return [copy](Args...) -> R {
throw copy; };
1746 #endif // GTEST_HAS_EXCEPTIONS 1785 template <
typename...
Action>
1789 {}, std::forward<Action>(action)...);
1797 template <
size_t k,
typename InnerAction>
1799 InnerAction&& action) {
1800 return {std::forward<InnerAction>(action)};
1807 template <
size_t k,
size_t... ks,
typename InnerAction>
1810 return {std::forward<InnerAction>(action)};
1817 template <
typename InnerAction>
1818 internal::WithArgsAction<typename std::decay<InnerAction>::type>
WithoutArgs(
1819 InnerAction&& action) {
1820 return {std::forward<InnerAction>(action)};
1847 template <
typename R>
1863 template <
typename R>
1869 template <
typename R, R* =
nullptr>
1875 template <
typename R>
1886 template <
typename R>
1894 template <
typename T>
1902 template <
typename T>
1904 std::initializer_list<T> vals) {
1915 template <
size_t N,
typename T>
1917 return {std::move(value)};
1921 template <
size_t N,
typename T>
1923 return {std::move(value)};
1927 template <
typename T1,
typename T2>
1932 #if !GTEST_OS_WINDOWS_MOBILE 1935 template <
typename T>
1937 int errval, T result) {
1942 #endif // !GTEST_OS_WINDOWS_MOBILE 1950 template <
typename FunctionImpl>
1952 return std::forward<FunctionImpl>(function_impl);
1957 template <
class Class,
typename MethodPtr>
1959 MethodPtr method_ptr) {
1960 return {obj_ptr, method_ptr};
1964 template <
typename FunctionImpl>
1967 return {std::move(function_impl)};
1972 template <
class Class,
typename MethodPtr>
1974 Class* obj_ptr, MethodPtr method_ptr) {
1975 return {obj_ptr, method_ptr};
1981 template <
typename A>
1996 template <
typename T>
1997 inline ::std::reference_wrapper<T>
ByRef(T& l_value) {
1998 return ::std::reference_wrapper<T>(l_value);
2004 template <
typename T,
typename... Params>
2006 Params&&... params) {
2007 return {std::forward_as_tuple(std::forward<Params>(params)...)};
2018 template <
size_t k,
typename Ptr>
2025 template <
size_t k,
typename Ptr>
2032 template <
size_t k,
typename T>
2035 return {std::forward<T>(value)};
2043 template <
size_t k,
typename I1,
typename I2>
2046 return {
first, last};
2057 template <
typename Ptr>
2064 #if GTEST_HAS_EXCEPTIONS 2065 template <
typename T>
2067 return {std::forward<T>(exception)};
2069 #endif // GTEST_HAS_EXCEPTIONS 2071 namespace internal {
2091 template <
typename F,
typename Impl>
2094 template <
typename Impl>
2098 explicit operator const Impl&()
const {
return *ptr; }
2101 using type =
typename std::conditional<std::is_constructible<Impl>::value,
2105 template <
typename R,
typename... Args,
typename Impl>
2115 static constexpr
size_t kMaxArgs =
2116 sizeof...(Args) <= 10 ?
sizeof...(Args) : 10;
2122 template <std::size_t... arg_id, std::size_t... excess_id>
2131 return static_cast<const Impl&
>(*this)
2132 .template gmock_PerformImpl<
2137 args, std::get<arg_id>(args)...,
2138 ((
void)excess_id, kExcessArg)...);
2144 template <
typename F,
typename Impl>
2150 template <
typename F,
typename 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__)) 2299 #pragma warning(pop) 2302 #endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ internal::SetArgRefereeAction< k, typename std::decay< T >::type > SetArgReferee(T &&value)
Result Call(Args... args) &&
R Apply(IndexSequence< arg_id... >, IndexSequence< excess_id... >, const args_type &args) const
auto operator()(const Args &...) const -> decltype(*pointer)
static Result Perform(const ArgumentTuple &)
ReturnAction(ByMoveWrapper< T > wrapper)
PolymorphicAction< internal::ReturnNullAction > ReturnNull()
internal::IgnoredValue Unused
internal::ReturnRoundRobinAction< T > ReturnRoundRobin(std::vector< T > vals)
GTEST_API_ void IllegalDoDefault(const char *file, int line)
static void SetFactory(FactoryFunction factory)
PolymorphicAction< internal::AssignAction< T1, T2 > > Assign(T1 *ptr, T2 val)
DoAllAction(UserConstructorTag, T &&initial_action, U &&... other_actions)
const MethodPtr method_ptr
auto Apply(F &&f, Tuple &&args) -> decltype(ApplyImpl(std::forward< F >(f), std::forward< Tuple >(args), MakeIndexSequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >()))
internal::DoAllAction< typename std::decay< Action >::type... > DoAll(Action &&... action)
AssignAction(T1 *ptr, T2 value)
internal::Function< F >::Result Result
PolymorphicAction(const Impl &impl)
auto operator()(Args &&... args) const -> decltype((obj_ptr-> *method_ptr)(std::forward< Args >(args)...))
IgnoreResultAction(const A &action)
DoAllAction(UserConstructorTag, T &&action)
internal::SaveArgPointeeAction< k, Ptr > SaveArgPointee(Ptr pointer)
Result Perform(const ArgumentTuple &) const
ReturnType operator()(const Args &...) const
internal::InvokeWithoutArgsAction< typename std::decay< FunctionImpl >::type > InvokeWithoutArgs(FunctionImpl function_impl)
R operator()(Args &&... arg) const
internal::WithArgsAction< typename std::decay< InnerAction >::type, k, ks... > WithArgs(InnerAction &&action)
ql0001_ & k(htemp+1),(cvec+1),(atemp+1),(bj+1),(bl+1),(bu+1),(x+1),(clamda+1), &iout, infoqp, &zero,(w+1), &lenw,(iw+1), &leniw, &glob_grd.epsmac
static void Perform(const ArgumentTuple &)
PolymorphicAction< Impl > MakePolymorphicAction(const Impl &impl)
inline ::std::reference_wrapper< T > ByRef(T &l_value)
PolymorphicAction< internal::SetErrnoAndReturnAction< T > > SetErrnoAndReturn(int errval, T result)
std::tuple< Args... > args_type
internal::SaveArgAction< k, Ptr > SaveArg(Ptr pointer)
internal::ReturnNewAction< T, typename std::decay< Params >::type... > ReturnNew(Params &&... params)
typename MakeIndexSequenceImpl< N >::type MakeIndexSequence
internal::ReturnRefAction< R > ReturnRef(R &x)
std::decay< FunctionImpl >::type Invoke(FunctionImpl &&function_impl)
void operator()(const Args &... args) const
const MethodPtr method_ptr
virtual ~ActionInterface()
std::tuple< Params... > params
Action(const Action< Func > &action)
#define GTEST_CHECK_(condition)
Action(ActionInterface< F > *impl)
internal::WithArgsAction< typename std::decay< InnerAction >::type > WithoutArgs(InnerAction &&action)
internal::ReturnRefOfCopyAction< R > ReturnRefOfCopy(const R &x)
SetErrnoAndReturnAction(int errno_value, T result)
FunctionImpl function_impl
OnceAction(Callable &&callable)
internal::DeleteArgAction< k > DeleteArg()
void operator()(const Args &... args) const
auto operator()(Args &&... args) const -> decltype(std::get< k >(std::forward_as_tuple(std::forward< Args >(args)...)))
internal::Function< F >::ArgumentTuple ArgumentTuple
void operator()(const Args &... args) const
typename std::conditional< std::is_constructible< Impl >::value, Impl, Holder >::type type
typename ImplBase< Impl >::type Base
ReturnRefOfCopyAction(const T &value)
R(typename std::tuple_element< I, std::tuple< Args... > >::type...) InnerSignature
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void,)
internal::SetArgumentPointeeAction< N, T > SetArgPointee(T value)
internal::Function< F >::Result Result
decltype(std::declval< F >()(std::declval< Args >()...)) call_result_t
ReturnRoundRobinAction(std::vector< T > values)
void operator()(const Args &... args) const
internal::Function< F >::ArgumentTuple ArgumentTuple
std::add_const< T >::type & as_const(T &t)
auto operator()(const Args &...) -> decltype(function_impl())
internal::ReturnArgAction< k > ReturnArg()
internal::DoDefaultAction DoDefault()
internal::ReturnAction< R > Return(R value)
ActionImpl(std::shared_ptr< Impl > impl)
decltype(TestImplicitConversion< From >(0)) type
void Assert(bool condition, const char *file, int line, const std::string &msg)
internal::SetArgumentPointeeAction< N, T > SetArgumentPointee(T value)
internal::ByMoveWrapper< R > ByMove(R x)
internal::SetArrayArgumentAction< k, I1, I2 > SetArrayArgument(I1 first, I2 last)
void operator()(const Args &... args) const
internal::WithArgsAction< typename std::decay< InnerAction >::type, k > WithArg(InnerAction &&action)
std::shared_ptr< Impl > ptr
void operator()(Args &&... args) const
Result Perform(ArgumentTuple args) const
T operator()(Args &&...) const
internal::ReturnPointeeAction< Ptr > ReturnPointee(Ptr pointer)
internal::IgnoreResultAction< A > IgnoreResult(const A &an_action)
::testing::Action< F > MakeAction()
typename std::tuple_element< I, T >::type TupleElement
void Perform(const ArgumentTuple &) const
decltype((std::declval< Class * >() -> *std::declval< MethodPtr >())()) ReturnType