Sacado Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Namespaces | Macros | Typedefs | Functions
gmock-actions.h File Reference
#include <errno.h>
#include <algorithm>
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
#include "gmock/internal/gmock-pp.h"
Include dependency graph for gmock-actions.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  testing::internal::BuiltInDefaultValueGetter< T, kDefaultConstructible >
 
struct  testing::internal::BuiltInDefaultValueGetter< T, false >
 
class  testing::internal::BuiltInDefaultValue< T >
 
class  testing::internal::BuiltInDefaultValue< const T >
 
class  testing::internal::BuiltInDefaultValue< T * >
 
struct  testing::internal::negation< P >
 
struct  testing::internal::conjunction<>
 
struct  testing::internal::conjunction< P1 >
 
struct  testing::internal::conjunction< P1, Ps...>
 
struct  testing::internal::disjunction<>
 
struct  testing::internal::disjunction< P1 >
 
struct  testing::internal::disjunction< P1, Ps...>
 
struct  testing::internal::is_implicitly_convertible< From, To >
 
struct  testing::internal::is_callable_r_impl< Void, R, F, Args >
 
struct  testing::internal::is_callable_r_impl< void_t< call_result_t< F, Args...> >, R, F, Args...>
 
class  testing::OnceAction< F >
 
class  testing::OnceAction< Result(Args...)>
 
class  testing::OnceAction< Result(Args...)>::StdFunctionAdaptor< Callable >
 
struct  testing::OnceAction< Result(Args...)>::StdFunctionAdaptor< Callable >::CallableTag
 
struct  testing::OnceAction< Result(Args...)>::IgnoreIncomingArguments< Callable >
 
class  testing::DefaultValue< T >
 
class  testing::DefaultValue< T >::ValueProducer
 
class  testing::DefaultValue< T >::FixedValueProducer
 
class  testing::DefaultValue< T >::FactoryValueProducer
 
class  testing::DefaultValue< T & >
 
class  testing::DefaultValue< void >
 
class  testing::ActionInterface< F >
 
class  testing::Action< F >
 
class  testing::Action< R(Args...)>
 
struct  testing::Action< R(Args...)>::ActionAdapter
 
struct  testing::Action< R(Args...)>::IgnoreArgs< FunctionImpl >
 
class  testing::PolymorphicAction< Impl >
 
class  testing::PolymorphicAction< Impl >::MonomorphicImpl< F >
 
struct  testing::internal::ByMoveWrapper< T >
 
class  testing::internal::ReturnAction< R >
 
class  testing::internal::ReturnAction< R >::Impl< U >
 
struct  testing::internal::ReturnAction< R >::Impl< U >::State
 
class  testing::internal::ReturnAction< ByMoveWrapper< T > >
 
struct  testing::internal::ReturnAction< ByMoveWrapper< T > >::State
 
class  testing::internal::ReturnNullAction
 
class  testing::internal::ReturnVoidAction
 
class  testing::internal::ReturnRefAction< T >
 
class  testing::internal::ReturnRefAction< T >::Impl< F >
 
class  testing::internal::ReturnRefOfCopyAction< T >
 
class  testing::internal::ReturnRefOfCopyAction< T >::Impl< F >
 
class  testing::internal::ReturnRoundRobinAction< T >
 
struct  testing::internal::ReturnRoundRobinAction< T >::State
 
class  testing::internal::DoDefaultAction
 
class  testing::internal::AssignAction< T1, T2 >
 
class  testing::internal::SetErrnoAndReturnAction< T >
 
struct  testing::internal::SetArgumentPointeeAction< N, A, typename >
 
struct  testing::internal::InvokeMethodAction< Class, MethodPtr >
 
struct  testing::internal::InvokeWithoutArgsAction< FunctionImpl >
 
struct  testing::internal::InvokeMethodWithoutArgsAction< Class, MethodPtr >
 
class  testing::internal::IgnoreResultAction< A >
 
class  testing::internal::IgnoreResultAction< A >::Impl< F >
 
struct  testing::internal::WithArgsAction< InnerAction, I >
 
class  testing::internal::DoAllAction< Actions >
 
class  testing::internal::DoAllAction< FinalAction >
 
struct  testing::internal::DoAllAction< FinalAction >::UserConstructorTag
 
class  testing::internal::DoAllAction< InitialAction, OtherActions...>
 
struct  testing::internal::DoAllAction< InitialAction, OtherActions...>::UserConstructorTag
 
struct  testing::internal::ReturnNewAction< T, Params >
 
struct  testing::internal::ReturnArgAction< k >
 
struct  testing::internal::SaveArgAction< k, Ptr >
 
struct  testing::internal::SaveArgPointeeAction< k, Ptr >
 
struct  testing::internal::SetArgRefereeAction< k, T >
 
struct  testing::internal::SetArrayArgumentAction< k, I1, I2 >
 
struct  testing::internal::DeleteArgAction< k >
 
struct  testing::internal::ReturnPointeeAction< Ptr >
 
struct  testing::internal::ExcessiveArg
 
struct  testing::internal::ActionImpl< F, Impl >
 
struct  testing::internal::ImplBase< Impl >
 
struct  testing::internal::ImplBase< Impl >::Holder
 
struct  testing::internal::ActionImpl< R(Args...), Impl >
 

Namespaces

 testing
 
 testing::internal
 

Macros

#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value)
 
#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el)   , GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED const arg##i##_type& arg##i
 
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_
 
#define GMOCK_INTERNAL_ARG(i, data, el)   , const arg##i##_type& arg##i
 
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_   const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
 
#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el)   , typename arg##i##_type
 
#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_   GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
 
#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param)   , typename param##_type
 
#define GMOCK_ACTION_TYPENAME_PARAMS_(params)   GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
 
#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param)   , param##_type
 
#define GMOCK_ACTION_TYPE_PARAMS_(params)   GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
 
#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param)   , param##_type gmock_p##i
 
#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)   GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
 
#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param)   , std::forward<param##_type>(gmock_p##i)
 
#define GMOCK_ACTION_GVALUE_PARAMS_(params)   GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
 
#define GMOCK_INTERNAL_INIT_PARAM(i, data, param)   , param(::std::forward<param##_type>(gmock_p##i))
 
#define GMOCK_ACTION_INIT_PARAMS_(params)   GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
 
#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param)   param##_type param;
 
#define GMOCK_ACTION_FIELD_PARAMS_(params)   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
 
#define GMOCK_INTERNAL_ACTION(name, full_name, params)
 
#define ACTION(name)
 
#define ACTION_P(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
 
#define ACTION_P2(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
 
#define ACTION_P3(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
 
#define ACTION_P4(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
 
#define ACTION_P5(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
 
#define ACTION_P6(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
 
#define ACTION_P7(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
 
#define ACTION_P8(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
 
#define ACTION_P9(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
 
#define ACTION_P10(name,...)   GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
 

Typedefs

template<typename... >
using testing::internal::void_t = void
 
template<typename F , typename... Args>
using testing::internal::call_result_t = decltype(std::declval< F >()(std::declval< Args >()...))
 
template<typename R , typename F , typename... Args>
using testing::internal::is_callable_r = is_callable_r_impl< void, R, F, Args...>
 
typedef internal::IgnoredValue testing::Unused
 

Functions

 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (::std::string,"")
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long long, 0)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long long, 0)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)
 
 testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)
 
template<typename T >
std::add_const< T >::type & testing::internal::as_const (T &t)
 
template<typename F >
Action< F > testing::MakeAction (ActionInterface< F > *impl)
 
template<typename Impl >
PolymorphicAction< Impl > testing::MakePolymorphicAction (const Impl &impl)
 
template<typename... Action>
internal::DoAllAction
< typename std::decay< Action >
::type...> 		testing::DoAll (Action &&...action)
 
template<size_t k, typename InnerAction >
internal::WithArgsAction
< typename std::decay
< InnerAction >::type, k > 		testing::WithArg (InnerAction &&action)
 
template<size_t k, size_t... ks, typename InnerAction >
internal::WithArgsAction
< typename std::decay
< InnerAction >::type, k,
ks...> 		testing::WithArgs (InnerAction &&action)
 
template<typename InnerAction >
internal::WithArgsAction
< typename std::decay
< InnerAction >::type > 		testing::WithoutArgs (InnerAction &&action)
 
template<typename R >
internal::ReturnAction< R > testing::Return (R value)
 
PolymorphicAction
< internal::ReturnNullAction > 		testing::ReturnNull ()
 
PolymorphicAction
< internal::ReturnVoidAction > 		testing::Return ()
 
template<typename R >
internal::ReturnRefAction< R > testing::ReturnRef (R &x)
 
template<typename R , R * = nullptr>
internal::ReturnRefAction< R > testing::ReturnRef (R &&)=delete
 
template<typename R >
internal::ReturnRefOfCopyAction
< R > 		testing::ReturnRefOfCopy (const R &x)
 
template<typename R >
internal::ByMoveWrapper< R > testing::ByMove (R x)
 
template<typename T >
internal::ReturnRoundRobinAction
< T > 		testing::ReturnRoundRobin (std::vector< T > vals)
 
template<typename T >
internal::ReturnRoundRobinAction
< T > 		testing::ReturnRoundRobin (std::initializer_list< T > vals)
 
internal::DoDefaultAction testing::DoDefault ()
 
template<size_t N, typename T >
internal::SetArgumentPointeeAction
< N, T > 		testing::SetArgPointee (T value)
 
template<size_t N, typename T >
internal::SetArgumentPointeeAction
< N, T > 		testing::SetArgumentPointee (T value)
 
template<typename T1 , typename T2 >
PolymorphicAction
< internal::AssignAction< T1,
T2 > > 		testing::Assign (T1 *ptr, T2 val)
 
template<typename T >
PolymorphicAction
< internal::SetErrnoAndReturnAction
< T > > 		testing::SetErrnoAndReturn (int errval, T result)
 
template<typename FunctionImpl >
std::decay< FunctionImpl >::type testing::Invoke (FunctionImpl &&function_impl)
 
template<class Class , typename MethodPtr >
internal::InvokeMethodAction
< Class, MethodPtr > 		testing::Invoke (Class *obj_ptr, MethodPtr method_ptr)
 
template<typename FunctionImpl >
internal::InvokeWithoutArgsAction
< typename std::decay
< FunctionImpl >::type > 		testing::InvokeWithoutArgs (FunctionImpl function_impl)
 
template<class Class , typename MethodPtr >
internal::InvokeMethodWithoutArgsAction
< Class, MethodPtr > 		testing::InvokeWithoutArgs (Class *obj_ptr, MethodPtr method_ptr)
 
template<typename A >
internal::IgnoreResultAction< A > testing::IgnoreResult (const A &an_action)
 
template<typename T >
inline::std::reference_wrapper< T > testing::ByRef (T &l_value)
 
template<typename T , typename... Params>
internal::ReturnNewAction< T,
typename std::decay< Params >
::type...> 		testing::ReturnNew (Params &&...params)
 
template<size_t k>
internal::ReturnArgAction< k > testing::ReturnArg ()
 
template<size_t k, typename Ptr >
internal::SaveArgAction< k, Ptr > testing::SaveArg (Ptr pointer)
 
template<size_t k, typename Ptr >
internal::SaveArgPointeeAction
< k, Ptr > 		testing::SaveArgPointee (Ptr pointer)
 
template<size_t k, typename T >
internal::SetArgRefereeAction
< k, typename std::decay< T >
::type > 		testing::SetArgReferee (T &&value)
 
template<size_t k, typename I1 , typename I2 >
internal::SetArrayArgumentAction
< k, I1, I2 > 		testing::SetArrayArgument (I1 first, I2 last)
 
template<size_t k>
internal::DeleteArgAction< k > testing::DeleteArg ()
 
template<typename Ptr >
internal::ReturnPointeeAction
< Ptr > 		testing::ReturnPointee (Ptr pointer)
 
template<typename F , typename Impl >
::testing::Action< F > testing::internal::MakeAction ()
 
template<typename F , typename Impl >
::testing::Action< F > testing::internal::MakeAction (std::shared_ptr< Impl > impl)
 

Macro Definition Documentation

#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (   type,
  value 
)
Value:
template <> \
class BuiltInDefaultValue<type> { \
public: \
static bool Exists() { return true; } \
static type Get() { return value; } \
}
value
int value
Definition: gmock-actions_test.cc:1762

Definition at line 231 of file gmock-actions.h.

#define GMOCK_INTERNAL_ARG_UNUSED (   i,
  data,
  el 
)    , GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED const arg##i##_type& arg##i

Definition at line 2215 of file gmock-actions.h.

#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_
Value:
GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED const args_type& args GMOCK_PP_REPEAT( \
GMOCK_INTERNAL_ARG_UNUSED, , 10)
GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED
#define GTEST_INTERNAL_ATTRIBUTE_MAYBE_UNUSED
Definition: gtest-port.h:791
GMOCK_INTERNAL_ARG_UNUSED
#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el)
Definition: gmock-actions.h:2215
GMOCK_PP_REPEAT
#define GMOCK_PP_REPEAT(_Macro, _Data, _N)
Definition: gmock-pp.h:139

Definition at line 2217 of file gmock-actions.h.

#define GMOCK_INTERNAL_ARG (   i,
  data,
  el 
)    , const arg##i##_type& arg##i

Definition at line 2221 of file gmock-actions.h.

#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_   const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)

Definition at line 2222 of file gmock-actions.h.

#define GMOCK_INTERNAL_TEMPLATE_ARG (   i,
  data,
  el 
)    , typename arg##i##_type

Definition at line 2225 of file gmock-actions.h.

#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_   GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))

Definition at line 2226 of file gmock-actions.h.

#define GMOCK_INTERNAL_TYPENAME_PARAM (   i,
  data,
  param 
)    , typename param##_type

Definition at line 2229 of file gmock-actions.h.

#define GMOCK_ACTION_TYPENAME_PARAMS_ (   params)    GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))

Definition at line 2230 of file gmock-actions.h.

#define GMOCK_INTERNAL_TYPE_PARAM (   i,
  data,
  param 
)    , param##_type

Definition at line 2233 of file gmock-actions.h.

#define GMOCK_ACTION_TYPE_PARAMS_ (   params)    GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))

Definition at line 2234 of file gmock-actions.h.

#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM (   i,
  data,
  param 
)    , param##_type gmock_p##i

Definition at line 2237 of file gmock-actions.h.

#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_ (   params)    GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))

Definition at line 2239 of file gmock-actions.h.

#define GMOCK_INTERNAL_GVALUE_PARAM (   i,
  data,
  param 
)    , std::forward<param##_type>(gmock_p##i)

Definition at line 2242 of file gmock-actions.h.

#define GMOCK_ACTION_GVALUE_PARAMS_ (   params)    GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))

Definition at line 2244 of file gmock-actions.h.

#define GMOCK_INTERNAL_INIT_PARAM (   i,
  data,
  param 
)    , param(::std::forward<param##_type>(gmock_p##i))

Definition at line 2247 of file gmock-actions.h.

#define GMOCK_ACTION_INIT_PARAMS_ (   params)    GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))

Definition at line 2249 of file gmock-actions.h.

#define GMOCK_INTERNAL_FIELD_PARAM (   i,
  data,
  param 
)    param##_type param;

Definition at line 2252 of file gmock-actions.h.

#define GMOCK_ACTION_FIELD_PARAMS_ (   params)    GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)

Definition at line 2253 of file gmock-actions.h.

#define GMOCK_INTERNAL_ACTION (   name,
  full_name,
  params 
)

Definition at line 2256 of file gmock-actions.h.

#define ACTION (   name)
Value:
class name##Action { \
public: \
explicit name##Action() noexcept {} \
name##Action(const name##Action&) noexcept {} \
template <typename F> \
operator ::testing::Action<F>() const { \
return ::testing::internal::MakeAction<F, gmock_Impl>(); \
} \
\
private: \
class gmock_Impl { \
public: \
template <typename function_type, typename return_type, \
typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
}; \
}; \
inline name##Action name() GTEST_MUST_USE_RESULT_; \
inline name##Action name() { return name##Action(); } \
template <typename function_type, typename return_type, typename args_type, \
GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
return_type name##Action::gmock_Impl::gmock_PerformImpl( \
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
GMOCK_ACTION_TEMPLATE_ARGS_NAMES_
#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_
Definition: gmock-actions.h:2226
GMOCK_ACTION_ARG_TYPES_AND_NAMES_
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_
Definition: gmock-actions.h:2222
GTEST_MUST_USE_RESULT_
#define GTEST_MUST_USE_RESULT_
Definition: gtest-port.h:816

Definition at line 2301 of file gmock-actions.h.

#define ACTION_P (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))

Definition at line 2326 of file gmock-actions.h.

#define ACTION_P2 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))

Definition at line 2329 of file gmock-actions.h.

#define ACTION_P3 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))

Definition at line 2332 of file gmock-actions.h.

#define ACTION_P4 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))

Definition at line 2335 of file gmock-actions.h.

#define ACTION_P5 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))

Definition at line 2338 of file gmock-actions.h.

#define ACTION_P6 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))

Definition at line 2341 of file gmock-actions.h.

#define ACTION_P7 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))

Definition at line 2344 of file gmock-actions.h.

#define ACTION_P8 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))

Definition at line 2347 of file gmock-actions.h.

#define ACTION_P9 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))

Definition at line 2350 of file gmock-actions.h.

#define ACTION_P10 (   name,
  ... 
)    GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))

Definition at line 2353 of file gmock-actions.h.

Generated by   doxygen 1.8.5