testing Namespace Reference

Namespaces
	gmock_matchers_test
	internal

Classes
class	Action
class	Action< R(Args...)>
class	ActionInterface
class	DefaultValue
class	DefaultValue< T & >
class	DefaultValue< void >
class	EmptyTestEventListener
class	Environment
class	Matcher
class	Message
class	NaggyMock
class	NiceMock
class	OnceAction
class	OnceAction< Result(Args...)>
class	PolymorphicAction
struct	PrintToStringParamName
class	ScopedTrace
class	StrictMock
class	Test
class	TestEventListener
class	TestEventListeners
class	TestInfo
struct	TestParamInfo
class	TestProperty
class	TestResult
class	TestSuite
class	TestWithParam
class	UnitTest
class	WithParamInterface

Typedefs
typedef internal::IgnoredValue	Unused
using	TestCase = TestSuite
typedef internal::TimeInMillis	TimeInMillis
template<typename... Ts>
using	Types = internal::ProxyTypeList< Ts... >

Functions
template<typename F >
Action< F >	MakeAction (ActionInterface< F > *impl)
template<typename Impl >
PolymorphicAction< Impl >	MakePolymorphicAction (const Impl &impl)
template<typename... Action>
internal::DoAllAction< typename std::decay< Action >::type... >	DoAll (Action &&... action)
template<size_t k, typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type, k >	WithArg (InnerAction &&action)
template<size_t k, size_t... ks, typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type, k, ks... >	WithArgs (InnerAction &&action)
template<typename InnerAction >
internal::WithArgsAction< typename std::decay< InnerAction >::type >	WithoutArgs (InnerAction &&action)
template<typename R >
internal::ReturnAction< R >	Return (R value)
PolymorphicAction< internal::ReturnNullAction >	ReturnNull ()
PolymorphicAction< internal::ReturnVoidAction >	Return ()
template<typename R >
internal::ReturnRefAction< R >	ReturnRef (R &x)
template<typename R , R * = nullptr>
internal::ReturnRefAction< R >	ReturnRef (R &&)=delete
template<typename R >
internal::ReturnRefOfCopyAction< R >	ReturnRefOfCopy (const R &x)
template<typename R >
internal::ByMoveWrapper< R >	ByMove (R x)
template<typename T >
internal::ReturnRoundRobinAction< T >	ReturnRoundRobin (std::vector< T > vals)
template<typename T >
internal::ReturnRoundRobinAction< T >	ReturnRoundRobin (std::initializer_list< T > vals)
internal::DoDefaultAction	DoDefault ()
template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgPointee (T value)
template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgumentPointee (T value)
template<typename T1 , typename T2 >
PolymorphicAction< internal::AssignAction< T1, T2 > >	Assign (T1 *ptr, T2 val)
template<typename T >
PolymorphicAction< internal::SetErrnoAndReturnAction< T > >	SetErrnoAndReturn (int errval, T result)
template<typename FunctionImpl >
std::decay< FunctionImpl >::type	Invoke (FunctionImpl &&function_impl)
template<class Class , typename MethodPtr >
internal::InvokeMethodAction< Class, MethodPtr >	Invoke (Class *obj_ptr, MethodPtr method_ptr)
template<typename FunctionImpl >
internal::InvokeWithoutArgsAction< typename std::decay< FunctionImpl >::type >	InvokeWithoutArgs (FunctionImpl function_impl)
template<class Class , typename MethodPtr >
internal::InvokeMethodWithoutArgsAction< Class, MethodPtr >	InvokeWithoutArgs (Class *obj_ptr, MethodPtr method_ptr)
template<typename A >
internal::IgnoreResultAction< A >	IgnoreResult (const A &an_action)
template<typename T >
inline ::std::reference_wrapper< T >	ByRef (T &l_value)
template<typename T , typename... Params>
internal::ReturnNewAction< T, typename std::decay< Params >::type... >	ReturnNew (Params &&... params)
template<size_t k>
internal::ReturnArgAction< k >	ReturnArg ()
template<size_t k, typename Ptr >
internal::SaveArgAction< k, Ptr >	SaveArg (Ptr pointer)
template<size_t k, typename Ptr >
internal::SaveArgPointeeAction< k, Ptr >	SaveArgPointee (Ptr pointer)
template<size_t k, typename T >
internal::SetArgRefereeAction< k, typename std::decay< T >::type >	SetArgReferee (T &&value)
template<size_t k, typename I1 , typename I2 >
internal::SetArrayArgumentAction< k, I1, I2 >	SetArrayArgument (I1 first, I2 last)
template<size_t k>
internal::DeleteArgAction< k >	DeleteArg ()
template<typename Ptr >
internal::ReturnPointeeAction< Ptr >	ReturnPointee (Ptr pointer)
template<std::size_t index, typename... Params>
internal::InvokeArgumentAction< index, typename std::decay< Params >::type... >	InvokeArgument (Params &&... params)
PolymorphicMatcher< internal::IsEmptyMatcher >	IsEmpty ()
	MATCHER (IsTrue, negation ? "is false" :"is true")
	MATCHER (IsFalse, negation ? "is true" :"is false")
GTEST_API_ void	InitGoogleMock (int *argc, char **argv)
GTEST_API_ void	InitGoogleMock (int *argc, wchar_t **argv)
GTEST_API_ void	InitGoogleMock ()
std::ostream &	operator<< (std::ostream &os, const Message &sb)
template<typename T , typename IncrementT >
internal::ParamGenerator< T >	Range (T start, T end, IncrementT step)
template<typename T >
internal::ParamGenerator< T >	Range (T start, T end)
template<typename ForwardIterator >
internal::ParamGenerator< typename std::iterator_traits< ForwardIterator >::value_type >	ValuesIn (ForwardIterator begin, ForwardIterator end)
template<typename T , size_t N>
internal::ParamGenerator< T >	ValuesIn (const T(&array)[N])
template<class Container >
internal::ParamGenerator< typename Container::value_type >	ValuesIn (const Container &container)
template<typename... T>
internal::ValueArray< T... >	Values (T... v)
internal::ParamGenerator< bool >	Bool ()
template<typename... Generator>
internal::CartesianProductHolder< Generator... >	Combine (const Generator &... g)
template<typename T >
internal::ParamConverterGenerator< T >	ConvertGenerator (internal::ParamGenerator< T > gen)
template<typename T >
::std::string	PrintToString (const T &value)
Environment *	AddGlobalTestEnvironment (Environment *env)
GTEST_API_ void	InitGoogleTest (int *argc, char **argv)
GTEST_API_ void	InitGoogleTest (int *argc, wchar_t **argv)
GTEST_API_ void	InitGoogleTest ()
GTEST_API_ AssertionResult	IsSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
GTEST_API_ AssertionResult	IsSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
GTEST_API_ AssertionResult	IsNotSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
GTEST_API_ AssertionResult	IsNotSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
GTEST_API_ AssertionResult	IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
GTEST_API_ AssertionResult	IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
GTEST_API_ AssertionResult	FloatLE (const char *expr1, const char *expr2, float val1, float val2)
GTEST_API_ AssertionResult	DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
template<typename T1 , typename T2 >
constexpr bool	StaticAssertTypeEq () noexcept
GTEST_API_ std::string	TempDir ()
GTEST_API_ std::string	SrcDir ()
template<int &... ExplicitParameterBarrier, typename Factory >
TestInfo *	RegisterTest (const char *test_suite_name, const char *test_name, const char *type_param, const char *value_param, const char *file, int line, Factory factory)
template<typename Pred , typename T1 >
AssertionResult	AssertPred1Helper (const char *pred_text, const char *e1, Pred pred, const T1 &v1)
template<typename Pred , typename T1 , typename T2 >
AssertionResult	AssertPred2Helper (const char *pred_text, const char *e1, const char *e2, Pred pred, const T1 &v1, const T2 &v2)
template<typename Pred , typename T1 , typename T2 , typename T3 >
AssertionResult	AssertPred3Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3)
template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 >
AssertionResult	AssertPred4Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, const char *e4, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
AssertionResult	AssertPred5Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, const char *e4, const char *e5, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)

Variables
const int	kMaxStackTraceDepth = 100

Typedef Documentation

TestCase

using testing::TestCase = typedef TestSuite

Definition at line 219 of file gtest.h.

TimeInMillis

typedef internal::TimeInMillis testing::TimeInMillis

Definition at line 362 of file gtest.h.

Types

template<typename... Ts>

using testing::Types = typedef internal::ProxyTypeList<Ts...>

Definition at line 186 of file gtest-type-util.h.

Unused

typedef internal::IgnoredValue testing::Unused

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

Function Documentation

AddGlobalTestEnvironment()

Environment* testing::AddGlobalTestEnvironment ( Environment *  env )

inline

Definition at line 1325 of file gtest.h.

                                                               {
  return UnitTest::GetInstance()->AddEnvironment(env);
}

AssertPred1Helper()

template<typename Pred , typename T1 >

AssertionResult testing::AssertPred1Helper	(	const char *	pred_text,
		const char *	e1,
		Pred	pred,
		const T1 &	v1
	)

Definition at line 87 of file gtest_pred_impl.h.

                                                           {
  if (pred(v1)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1);
}

AssertPred2Helper()

template<typename Pred , typename T1 , typename T2 >

AssertionResult testing::AssertPred2Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2
	)

Definition at line 118 of file gtest_pred_impl.h.

                                                {
  if (pred(v1, v2)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2);
}

AssertPred3Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 >

AssertionResult testing::AssertPred3Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3
	)

Definition at line 155 of file gtest_pred_impl.h.

                                                                            {
  if (pred(v1, v2, v3)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3);
}

AssertPred4Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 >

AssertionResult testing::AssertPred4Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		const char *	e4,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3,
		const T4 &	v4
	)

Definition at line 194 of file gtest_pred_impl.h.

                                                                            {
  if (pred(v1, v2, v3, v4)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
         << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
         << e4 << " evaluates to " << ::testing::PrintToString(v4);
}

AssertPred5Helper()

template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

AssertionResult testing::AssertPred5Helper	(	const char *	pred_text,
		const char *	e1,
		const char *	e2,
		const char *	e3,
		const char *	e4,
		const char *	e5,
		Pred	pred,
		const T1 &	v1,
		const T2 &	v2,
		const T3 &	v3,
		const T4 &	v4,
		const T5 &	v5
	)

Definition at line 236 of file gtest_pred_impl.h.

                                                              {
  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();

  return AssertionFailure()
         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
         << ", " << e5 << ") evaluates to false, where"
         << "\n"
         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
         << e5 << " evaluates to " << ::testing::PrintToString(v5);
}

Assign()

template<typename T1 , typename T2 >

PolymorphicAction<internal::AssignAction<T1, T2> > testing::Assign	(	T1 *	ptr,
		T2	val
	)

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

                                                                        {
  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
}

Bool()

internal::ParamGenerator<bool> testing::Bool ( )

inline

Definition at line 359 of file gtest-param-test.h.

{ return Values(false, true); }

ByMove()

template<typename R >

internal::ByMoveWrapper<R> testing::ByMove

(

R

x

)

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

                                     {
  return internal::ByMoveWrapper<R>(std::move(x));
}

ByRef()

template<typename T >

inline ::std::reference_wrapper<T> testing::ByRef

(

T &

l_value

)

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

                                                 {  // NOLINT
  return ::std::reference_wrapper<T>(l_value);
}

Combine()

template<typename... Generator>

internal::CartesianProductHolder<Generator...> testing::Combine

(

const Generator &...

g

)

Definition at line 406 of file gtest-param-test.h.

                                                                            {
  return internal::CartesianProductHolder<Generator...>(g...);
}

ConvertGenerator()

template<typename T >

internal::ParamConverterGenerator<T> testing::ConvertGenerator

(

internal::ParamGenerator< T >

gen

)

Definition at line 445 of file gtest-param-test.h.

                                   {
  return internal::ParamConverterGenerator<T>(gen);
}

DeleteArg()

template<size_t k>

internal::DeleteArgAction<k> testing::DeleteArg

(

)

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

                                       {
  return {};
}

DoAll()

template<typename... Action>

internal::DoAllAction<typename std::decay<Action>::type...> testing::DoAll

(

Action &&...

action

)

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

                        {
  return internal::DoAllAction<typename std::decay<Action>::type...>(
      {}, std::forward<Action>(action)...);
}

DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

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

                                           {
  return internal::DoDefaultAction();
}

DoubleLE()

GTEST_API_ AssertionResult testing::DoubleLE	(	const char *	expr1,
		const char *	expr2,
		double	val1,
		double	val2
	)

FloatLE()

GTEST_API_ AssertionResult testing::FloatLE	(	const char *	expr1,
		const char *	expr2,
		float	val1,
		float	val2
	)

IgnoreResult()

template<typename A >

internal::IgnoreResultAction<A> testing::IgnoreResult ( const A &  an_action )

inline

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

                                                                      {
  return internal::IgnoreResultAction<A>(an_action);
}

InitGoogleMock() [1/3]

GTEST_API_ void testing::InitGoogleMock	(	int *	argc,
		char **	argv
	)

InitGoogleMock() [2/3]

GTEST_API_ void testing::InitGoogleMock	(	int *	argc,
		wchar_t **	argv
	)

InitGoogleMock() [3/3]

GTEST_API_ void testing::InitGoogleMock

(

)

InitGoogleTest() [1/3]

GTEST_API_ void testing::InitGoogleTest	(	int *	argc,
		char **	argv
	)

InitGoogleTest() [2/3]

GTEST_API_ void testing::InitGoogleTest	(	int *	argc,
		wchar_t **	argv
	)

InitGoogleTest() [3/3]

GTEST_API_ void testing::InitGoogleTest

(

)

Invoke() [1/2]

template<typename FunctionImpl >

std::decay<FunctionImpl>::type testing::Invoke

(

FunctionImpl &&

function_impl

)

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

                                                                         {
  return std::forward<FunctionImpl>(function_impl);
}

Invoke() [2/2]

template<class Class , typename MethodPtr >

internal::InvokeMethodAction<Class, MethodPtr> testing::Invoke	(	Class *	obj_ptr,
		MethodPtr	method_ptr
	)

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

                                                                            {
  return {obj_ptr, method_ptr};
}

InvokeArgument()

template<std::size_t index, typename... Params>

internal::InvokeArgumentAction<index, typename std::decay<Params>::type...> testing::InvokeArgument

(

Params &&...

params

)

Definition at line 651 of file gmock-more-actions.h.

                                   {
  return {internal::FlatTuple<typename std::decay<Params>::type...>(
      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
}

InvokeWithoutArgs() [1/2]

template<typename FunctionImpl >

internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type> testing::InvokeWithoutArgs

(

FunctionImpl

function_impl

)

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

                                              {
  return {std::move(function_impl)};
}

InvokeWithoutArgs() [2/2]

template<class Class , typename MethodPtr >

internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> testing::InvokeWithoutArgs	(	Class *	obj_ptr,
		MethodPtr	method_ptr
	)

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

                                          {
  return {obj_ptr, method_ptr};
}

IsEmpty()

PolymorphicMatcher<internal::IsEmptyMatcher> testing::IsEmpty ( )

inline

Definition at line 96 of file gmock-more-matchers.h.

                                                            {
  return MakePolymorphicMatcher(internal::IsEmptyMatcher());
}

IsNotSubstring() [1/3]

GTEST_API_ AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const char *	needle,
		const char *	haystack
	)

IsNotSubstring() [2/3]

GTEST_API_ AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const wchar_t *	needle,
		const wchar_t *	haystack
	)

IsNotSubstring() [3/3]

GTEST_API_ AssertionResult testing::IsNotSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const ::std::string &	needle,
		const ::std::string &	haystack
	)

IsSubstring() [1/3]

GTEST_API_ AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const char *	needle,
		const char *	haystack
	)

IsSubstring() [2/3]

GTEST_API_ AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const wchar_t *	needle,
		const wchar_t *	haystack
	)

IsSubstring() [3/3]

GTEST_API_ AssertionResult testing::IsSubstring	(	const char *	needle_expr,
		const char *	haystack_expr,
		const ::std::string &	needle,
		const ::std::string &	haystack
	)

MakeAction()

template<typename F >

Action<F> testing::MakeAction

(

ActionInterface< F > *

impl

)

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

                                               {
  return Action<F>(impl);
}

MakePolymorphicAction()

template<typename Impl >

PolymorphicAction<Impl> testing::MakePolymorphicAction ( const Impl &  impl )

inline

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

                                                                       {
  return PolymorphicAction<Impl>(impl);
}

MATCHER() [1/2]

testing::MATCHER	(	IsTrue	,
		negation ? "is false" :"is true"
	)

Definition at line 104 of file gmock-more-matchers.h.

                                      : "is true") {
  return static_cast<bool>(arg);
}

MATCHER() [2/2]

testing::MATCHER	(	IsFalse	,
		negation ? "is true" :"is false"
	)

Definition at line 112 of file gmock-more-matchers.h.

                                      : "is false") {
  return !static_cast<bool>(arg);
}

operator<<()

std::ostream& testing::operator<< ( std::ostream &  os, const Message &  sb  )

inline

Definition at line 200 of file gtest-message.h.

                                                                 {
  return os << sb.GetString();
}

PrintToString()

template<typename T >

::std::string testing::PrintToString

(

const T &

value

)

Definition at line 1118 of file gtest-printers.h.

                                        {
  ::std::stringstream ss;
  internal::UniversalTersePrinter<T>::Print(value, &ss);
  return ss.str();
}

Range() [1/2]

template<typename T , typename IncrementT >

internal::ParamGenerator<T> testing::Range	(	T	start,
		T	end,
		IncrementT	step
	)

Definition at line 229 of file gtest-param-test.h.

                                                                 {
  return internal::ParamGenerator<T>(
      new internal::RangeGenerator<T, IncrementT>(start, end, step));
}

Range() [2/2]

template<typename T >

internal::ParamGenerator<T> testing::Range	(	T	start,
		T	end
	)

Definition at line 235 of file gtest-param-test.h.

                                                {
  return Range(start, end, 1);
}

RegisterTest()

template<int &... ExplicitParameterBarrier, typename Factory >

TestInfo* testing::RegisterTest	(	const char *	test_suite_name,
		const char *	test_name,
		const char *	type_param,
		const char *	value_param,
		const char *	file,
		int	line,
		Factory	factory
	)

Definition at line 2280 of file gtest.h.

                                                                    {
  using TestT = typename std::remove_pointer<decltype(factory())>::type;

  class FactoryImpl : public internal::TestFactoryBase {
   public:
    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
    Test* CreateTest() override { return factory_(); }

   private:
    Factory factory_;
  };

  return internal::MakeAndRegisterTestInfo(
      test_suite_name, test_name, type_param, value_param,
      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
      new FactoryImpl{std::move(factory)});
}

Return() [1/2]

template<typename R >

internal::ReturnAction<R> testing::Return

(

R

value

)

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

                                        {
  return internal::ReturnAction<R>(std::move(value));
}

Return() [2/2]

PolymorphicAction<internal::ReturnVoidAction> testing::Return ( )

inline

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

                                                            {
  return MakePolymorphicAction(internal::ReturnVoidAction());
}

ReturnArg()

template<size_t k>

internal::ReturnArgAction<k> testing::ReturnArg

(

)

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

                                       {
  return {};
}

ReturnNew()

template<typename T , typename... Params>

internal::ReturnNewAction<T, typename std::decay<Params>::type...> testing::ReturnNew

(

Params &&...

params

)

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

                        {
  return {std::forward_as_tuple(std::forward<Params>(params)...)};
}

ReturnNull()

PolymorphicAction<internal::ReturnNullAction> testing::ReturnNull ( )

inline

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

                                                                {
  return MakePolymorphicAction(internal::ReturnNullAction());
}

ReturnPointee()

template<typename Ptr >

internal::ReturnPointeeAction<Ptr> testing::ReturnPointee

(

Ptr

pointer

)

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

                                                            {
  return {pointer};
}

ReturnRef() [1/2]

template<typename R >

internal::ReturnRefAction<R> testing::ReturnRef ( R &  x )

inline

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

                                                  {  // NOLINT
  return internal::ReturnRefAction<R>(x);
}

ReturnRef() [2/2]

template<typename R , R * = nullptr>

internal::ReturnRefAction<R> testing::ReturnRef ( R &&  )

delete

ReturnRefOfCopy()

template<typename R >

internal::ReturnRefOfCopyAction<R> testing::ReturnRefOfCopy ( const R &  x )

inline

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

                                                                    {
  return internal::ReturnRefOfCopyAction<R>(x);
}

ReturnRoundRobin() [1/2]

template<typename T >

internal::ReturnRoundRobinAction<T> testing::ReturnRoundRobin

(

std::vector< T >

vals

)

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

                                                                      {
  return internal::ReturnRoundRobinAction<T>(std::move(vals));
}

ReturnRoundRobin() [2/2]

template<typename T >

internal::ReturnRoundRobinAction<T> testing::ReturnRoundRobin

(

std::initializer_list< T >

vals

)

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

                                 {
  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
}

SaveArg()

template<size_t k, typename Ptr >

internal::SaveArgAction<k, Ptr> testing::SaveArg

(

Ptr

pointer

)

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

                                                   {
  return {pointer};
}

SaveArgPointee()

template<size_t k, typename Ptr >

internal::SaveArgPointeeAction<k, Ptr> testing::SaveArgPointee

(

Ptr

pointer

)

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

                                                                 {
  return {pointer};
}

SetArgPointee()

template<size_t N, typename T >

internal::SetArgumentPointeeAction<N, T> testing::SetArgPointee

(

T

value

)

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

                                                              {
  return {std::move(value)};
}

SetArgReferee()

template<size_t k, typename T >

internal::SetArgRefereeAction<k, typename std::decay<T>::type> testing::SetArgReferee

(

T &&

value

)

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

               {
  return {std::forward<T>(value)};
}

SetArgumentPointee()

template<size_t N, typename T >

internal::SetArgumentPointeeAction<N, T> testing::SetArgumentPointee

(

T

value

)

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

                                                                   {
  return {std::move(value)};
}

SetArrayArgument()

template<size_t k, typename I1 , typename I2 >

internal::SetArrayArgumentAction<k, I1, I2> testing::SetArrayArgument	(	I1	first,
		I2	last
	)

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

                                                                      {
  return {first, last};
}

SetErrnoAndReturn()

template<typename T >

PolymorphicAction<internal::SetErrnoAndReturnAction<T> > testing::SetErrnoAndReturn	(	int	errval,
		T	result
	)

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

                          {
  return MakePolymorphicAction(
      internal::SetErrnoAndReturnAction<T>(errval, result));
}

SrcDir()

GTEST_API_ std::string testing::SrcDir

(

)

StaticAssertTypeEq()

template<typename T1 , typename T2 >

constexpr bool testing::StaticAssertTypeEq ( )

noexcept

Definition at line 2134 of file gtest.h.

                                             {
  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
  return true;
}

TempDir()

GTEST_API_ std::string testing::TempDir

(

)

Values()

template<typename... T>

internal::ValueArray<T...> testing::Values

(

T...

v

)

Definition at line 335 of file gtest-param-test.h.

                                        {
  return internal::ValueArray<T...>(std::move(v)...);
}

ValuesIn() [1/3]

template<typename ForwardIterator >

internal::ParamGenerator< typename std::iterator_traits<ForwardIterator>::value_type> testing::ValuesIn	(	ForwardIterator	begin,
		ForwardIterator	end
	)

Definition at line 297 of file gtest-param-test.h.

                                                     {
  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
  return internal::ParamGenerator<ParamType>(
      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
}

ValuesIn() [2/3]

template<typename T , size_t N>

internal::ParamGenerator<T> testing::ValuesIn

(

const T(&)

array[N]

)

Definition at line 304 of file gtest-param-test.h.

                                                        {
  return ValuesIn(array, array + N);
}

ValuesIn() [3/3]

template<class Container >

internal::ParamGenerator< typename Container::value_type > testing::ValuesIn

(

const Container &

container

)

Definition at line 309 of file gtest-param-test.h.

                                {
  return ValuesIn(container.begin(), container.end());
}

WithArg()

template<size_t k, typename InnerAction >

internal::WithArgsAction<typename std::decay<InnerAction>::type, k> testing::WithArg

(

InnerAction &&

action

)

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

                          {
  return {std::forward<InnerAction>(action)};
}

WithArgs()

template<size_t k, size_t... ks, typename InnerAction >

internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...> testing::WithArgs

(

InnerAction &&

action

)

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

                               {
  return {std::forward<InnerAction>(action)};
}

WithoutArgs()

template<typename InnerAction >

internal::WithArgsAction<typename std::decay<InnerAction>::type> testing::WithoutArgs

(

InnerAction &&

action

)

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

                          {
  return {std::forward<InnerAction>(action)};
}

Variable Documentation

kMaxStackTraceDepth

const int testing::kMaxStackTraceDepth = 100

Definition at line 176 of file gtest.h.