cmake-build-debug/googletest-src/googlemock/include/gmock/gmock-actions.h File Reference

#include <errno.h>
#include <algorithm>
#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 cmake-build-debug/googletest-src/googlemock/include/gmock/gmock-actions.h:

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 * >
class	testing::DefaultValue< T >
class	testing::DefaultValue< T & >
class	testing::DefaultValue< void >
class	testing::ActionInterface< F >
class	testing::Action< F >
class	testing::PolymorphicAction< Impl >
struct	testing::internal::ByMoveWrapper< T >
class	testing::internal::ReturnAction< R >
class	testing::internal::ReturnNullAction
class	testing::internal::ReturnVoidAction
class	testing::internal::ReturnRefAction< T >
class	testing::internal::ReturnRefOfCopyAction< T >
class	testing::internal::ReturnRoundRobinAction< T >
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 >
struct	testing::internal::WithArgsAction< InnerAction, I >
struct	testing::internal::DoAllAction< Actions >
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::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)    , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
#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 P , typename Q >
using	testing::internal::disjunction = typename ::std::conditional< P::value, P, Q >::type
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 int, 0U)
	testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed int, 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 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

ACTION

#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

ACTION_P

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

ACTION_P10

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

ACTION_P2

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

ACTION_P3

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

ACTION_P4

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

ACTION_P5

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

ACTION_P6

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

ACTION_P7

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

ACTION_P8

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

ACTION_P9

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

GMOCK_ACTION_ARG_TYPES_AND_NAMES_

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

GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_

#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_

Value:

  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

GMOCK_ACTION_FIELD_PARAMS_

#define GMOCK_ACTION_FIELD_PARAMS_

(

params

)

GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)

GMOCK_ACTION_GVALUE_PARAMS_

#define GMOCK_ACTION_GVALUE_PARAMS_

(

params

)

GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))

GMOCK_ACTION_INIT_PARAMS_

#define GMOCK_ACTION_INIT_PARAMS_

(

params

)

GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))

GMOCK_ACTION_TEMPLATE_ARGS_NAMES_

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

GMOCK_ACTION_TYPE_GVALUE_PARAMS_

#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_

(

params

)

GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))

GMOCK_ACTION_TYPE_PARAMS_

#define GMOCK_ACTION_TYPE_PARAMS_

(

params

)

GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))

GMOCK_ACTION_TYPENAME_PARAMS_

#define GMOCK_ACTION_TYPENAME_PARAMS_

(

params

)

GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_

#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; } \
  }

GMOCK_INTERNAL_ACTION

#define GMOCK_INTERNAL_ACTION	(		name,
			full_name,
			params
	)

GMOCK_INTERNAL_ARG

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

GMOCK_INTERNAL_ARG_UNUSED

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

GMOCK_INTERNAL_FIELD_PARAM

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

GMOCK_INTERNAL_GVALUE_PARAM

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

GMOCK_INTERNAL_INIT_PARAM

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

GMOCK_INTERNAL_TEMPLATE_ARG

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

GMOCK_INTERNAL_TYPE_GVALUE_PARAM

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

GMOCK_INTERNAL_TYPE_PARAM

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

GMOCK_INTERNAL_TYPENAME_PARAM

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