Namespaces
	gmock_function_mocker_test

	gmock_generated_actions_test

	gmock_generated_function_mockers_test

	gmock_matchers_test

	gmock_more_actions_test

	gmock_nice_strict_test

	gtest_printers_test

	internal

	internal2

Classes
class	Action

class	ActionInterface

class	CodeLocationForTESTF

class	CodeLocationForTESTP

class	CodeLocationForTYPEDTEST

class	CodeLocationForTYPEDTESTP

class	CurrentTestInfoTest

class	DefaultValue

class	DefaultValue< T & >

class	DefaultValue< void >

class	EmptyTestEventListener

class	Environment

struct	Flags

class	Matcher

class	Message

class	NaggyMock

class	NiceMock

class	ParseFlagsTest

class	PolymorphicAction

struct	PrintToStringParamName

class	ScopedTrace

class	SetUpTestCaseTest

class	SetUpTestSuiteTest

class	StrictMock

class	Test

class	TestEventListener

class	TestEventListeners

class	TestInfo

class	TestInfoTest

struct	TestParamInfo

class	TestProperty

class	TestResult

class	TestSuite

class	TestWithParam

class	UnitTest

class	WithParamInterface

Typedefs
typedef internal::IgnoredValue	Unused

typedef internal::TimeInMillis	TimeInMillis

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 >
internal::ReturnRefOfCopyAction< R >	ReturnRefOfCopy (const R &x)

template<typename R >
internal::ByMoveWrapper< R >	ByMove (R x)

internal::DoDefaultAction	DoDefault ()

template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgPointee (T x)

template<size_t N, typename T >
internal::SetArgumentPointeeAction< N, T >	SetArgumentPointee (T x)

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)

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(p0))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_2_VALUE_PARAMS(p0, p1))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_3_VALUE_PARAMS(p0, p1, p2))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_4_VALUE_PARAMS(p0, p1, p2, p3))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8))

	ACTION_TEMPLATE (InvokeArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_0_VALUE_PARAMS())

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_1_VALUE_PARAMS(p0))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_2_VALUE_PARAMS(p0, p1))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_3_VALUE_PARAMS(p0, p1, p2))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_4_VALUE_PARAMS(p0, p1, p2, p3))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8))

	ACTION_TEMPLATE (ReturnNew, HAS_1_TEMPLATE_PARAMS(typename, T), AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))

	ACTION_TEMPLATE (ReturnArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())

	ACTION_TEMPLATE (SaveArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(pointer))

	ACTION_TEMPLATE (SaveArgPointee, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(pointer))

	ACTION_TEMPLATE (SetArgReferee, HAS_1_TEMPLATE_PARAMS(int, k), AND_1_VALUE_PARAMS(value))

	ACTION_TEMPLATE (SetArrayArgument, HAS_1_TEMPLATE_PARAMS(int, k), AND_2_VALUE_PARAMS(first, last))

	ACTION_TEMPLATE (DeleteArg, HAS_1_TEMPLATE_PARAMS(int, k), AND_0_VALUE_PARAMS())

	ACTION_P (ReturnPointee, pointer)

	MATCHER (IsEmpty, negation?"isn't empty":"is empty")

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

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

	GMOCK_DECLARE_bool_ (catch_leaked_mocks)

	GMOCK_DECLARE_string_ (verbose)

	GMOCK_DECLARE_int32_ (default_mock_behavior)

GTEST_API_ void	InitGoogleMock (int argc, char *argv)

GTEST_API_ void	InitGoogleMock (int argc, wchar_t *argv)

GTEST_API_ void	InitGoogleMock ()

GTEST_API_ Cardinality	AtLeast (int n)

GTEST_API_ Cardinality	AtMost (int n)

GTEST_API_ Cardinality	AnyNumber ()

GTEST_API_ Cardinality	Between (int min, int max)

GTEST_API_ Cardinality	Exactly (int n)

	GMOCK_DEFINE_bool_ (catch_leaked_mocks, true,"true iff Google Mock should report leaked mock objects ""as failures.")

	GMOCK_DEFINE_string_ (verbose, internal::kWarningVerbosity,"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only.")

	GMOCK_DEFINE_int32_ (default_mock_behavior, 1,"Controls the default behavior of mocks."" Valid values:\n"" 0 - by default, mocks act as NiceMocks.\n"" 1 - by default, mocks act as NaggyMocks.\n"" 2 - by default, mocks act as StrictMocks.")

	GTEST_DECLARE_string_ (death_test_style)

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::testing::internal::IteratorTraits< 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 >
::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 >
bool	StaticAssertTypeEq ()

GTEST_API_ std::string	TempDir ()

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)

	GTEST_DEFINE_string_ (death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking).")

	GTEST_DEFINE_bool_ (death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false),"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is fixed, this flag will ""most likely be removed.")

std::ostream &	operator<< (std::ostream &os, const TestPartResult &result)

	GTEST_DEFINE_bool_ (also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false),"Run disabled tests too, in addition to the tests normally being run.")

	GTEST_DEFINE_bool_ (break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),"True iff a failed assertion should be a debugger break-point.")

	GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true),"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures.")

	GTEST_DEFINE_string_ (color, internal::StringFromGTestEnv("color","auto"),"Whether to use colors in the output. Valid values: yes, no, ""and auto. 'auto' means to use colors if the output is ""being sent to a terminal and the TERM environment variable ""is set to a terminal type that supports colors.")

	GTEST_DEFINE_string_ (filter, internal::StringFromGTestEnv("filter", GetDefaultFilter()),"A colon-separated list of glob (not regex) patterns ""for filtering the tests to run, optionally followed by a ""'-' and a : separated list of negative patterns (tests to ""exclude). A test is run if it matches one of the positive ""patterns and does not match any of the negative patterns.")

	GTEST_DEFINE_bool_ (install_failure_signal_handler, internal::BoolFromGTestEnv("install_failure_signal_handler", false),"If true and supported on the current platform, "GTEST_NAME_" should ""install a signal handler that dumps debugging information when fatal ""signals are raised.")

	GTEST_DEFINE_bool_ (list_tests, false,"List all tests without running them.")

	GTEST_DEFINE_string_ (output, internal::StringFromGTestEnv("output", internal::OutputFlagAlsoCheckEnvVar().c_str()),"A format (defaults to \"xml\" but can be specified to be \"json\"), ""optionally followed by a colon and an output file name or directory. ""A directory is indicated by a trailing pathname separator. ""Examples: \"xml:filename.xml\", \"xml::directoryname/\". ""If a directory is specified, output files will be created ""within that directory, with file-names based on the test ""executable's name and, if necessary, made unique by adding ""digits.")

	GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true),"True iff "GTEST_NAME_" should display elapsed time in text output.")

	GTEST_DEFINE_bool_ (print_utf8, internal::BoolFromGTestEnv("print_utf8", true),"True iff "GTEST_NAME_" prints UTF8 characters as text.")

	GTEST_DEFINE_int32_ (random_seed, internal::Int32FromGTestEnv("random_seed", 0),"Random number seed to use when shuffling test orders. Must be in range ""[1, 99999], or 0 to use a seed based on the current time.")

	GTEST_DEFINE_int32_ (repeat, internal::Int32FromGTestEnv("repeat", 1),"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests.")

	GTEST_DEFINE_bool_ (show_internal_stack_frames, false,"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces.")

	GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false),"True iff "GTEST_NAME_" should randomize tests' order on every run.")

	GTEST_DEFINE_int32_ (stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through 100, inclusive.")

	GTEST_DEFINE_string_ (stream_result_to, internal::StringFromGTestEnv("stream_result_to",""),"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux.")

	GTEST_DEFINE_bool_ (throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false),"When this flag is specified, a failed assertion will throw an exception ""if exceptions are enabled or exit the program with a non-zero code ""otherwise. For use with an external test framework.")

AssertionResult	AssertionSuccess ()

AssertionResult	AssertionFailure ()

AssertionResult	AssertionFailure (const Message &message)

template<int kSize>
std::vector< std::string >	ArrayAsVector (const char *const (&array)[kSize])

	TEST (GTestEnvVarTest, Dummy)

void	PrintFlag (const char *flag)

	GTEST_DECLARE_string_ (filter)

	GTEST_DECLARE_int32_ (repeat)

	TEST (SuccessfulAssertionTest, SUCCEED)

	TEST (SuccessfulAssertionTest, EXPECT)

	TEST (SuccessfulAssertionTest, EXPECT_STR)

	TEST (SuccessfulAssertionTest, ASSERT)

	TEST (SuccessfulAssertionTest, ASSERT_STR)

	TEST_F (TestInfoTest, Names)

	TEST_F (TestInfoTest, result)

	TEST (CodeLocationForTEST, Verify)

	TEST_F (CodeLocationForTESTF, Verify)

	TEST_P (CodeLocationForTESTP, Verify)

	INSTANTIATE_TEST_SUITE_P (, CodeLocationForTESTP, Values(0))

	TYPED_TEST_SUITE (CodeLocationForTYPEDTEST, int)

	TYPED_TEST (CodeLocationForTYPEDTEST, Verify)

	TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP)

	TYPED_TEST_P (CodeLocationForTYPEDTESTP, Verify)

	REGISTER_TYPED_TEST_SUITE_P (CodeLocationForTYPEDTESTP, Verify)

	INSTANTIATE_TYPED_TEST_SUITE_P (My, CodeLocationForTYPEDTESTP, int)

	TEST_F (SetUpTestCaseTest, Test1)

	TEST_F (SetUpTestCaseTest, Test2)

	TEST_F (SetUpTestSuiteTest, TestSetupTestSuite1)

	TEST_F (SetUpTestSuiteTest, TestSetupTestSuite2)

	TEST_F (ParseFlagsTest, Empty)

	TEST_F (ParseFlagsTest, NoFlag)

	TEST_F (ParseFlagsTest, FilterBad)

	TEST_F (ParseFlagsTest, FilterEmpty)

	TEST_F (ParseFlagsTest, FilterNonEmpty)

	TEST_F (ParseFlagsTest, BreakOnFailureWithoutValue)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_0)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_f)

	TEST_F (ParseFlagsTest, BreakOnFailureFalse_F)

	TEST_F (ParseFlagsTest, BreakOnFailureTrue)

	TEST_F (ParseFlagsTest, CatchExceptions)

	TEST_F (ParseFlagsTest, DeathTestUseFork)

	TEST_F (ParseFlagsTest, DuplicatedFlags)

	TEST_F (ParseFlagsTest, UnrecognizedFlag)

	TEST_F (ParseFlagsTest, ListTestsFlag)

	TEST_F (ParseFlagsTest, ListTestsTrue)

	TEST_F (ParseFlagsTest, ListTestsFalse)

	TEST_F (ParseFlagsTest, ListTestsFalse_f)

	TEST_F (ParseFlagsTest, ListTestsFalse_F)

	TEST_F (ParseFlagsTest, OutputEmpty)

	TEST_F (ParseFlagsTest, OutputXml)

	TEST_F (ParseFlagsTest, OutputXmlFile)

	TEST_F (ParseFlagsTest, OutputXmlDirectory)

	TEST_F (ParseFlagsTest, PrintTimeFlag)

	TEST_F (ParseFlagsTest, PrintTimeTrue)

	TEST_F (ParseFlagsTest, PrintTimeFalse)

	TEST_F (ParseFlagsTest, PrintTimeFalse_f)

	TEST_F (ParseFlagsTest, PrintTimeFalse_F)

	TEST_F (ParseFlagsTest, RandomSeed)

	TEST_F (ParseFlagsTest, Repeat)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFlag)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsTrue)

	TEST_F (ParseFlagsTest, AlsoRunDisabledTestsFalse)

	TEST_F (ParseFlagsTest, ShuffleWithoutValue)

	TEST_F (ParseFlagsTest, ShuffleFalse_0)

	TEST_F (ParseFlagsTest, ShuffleTrue)

	TEST_F (ParseFlagsTest, StackTraceDepth)

	TEST_F (ParseFlagsTest, StreamResultTo)

	TEST_F (ParseFlagsTest, ThrowOnFailureWithoutValue)

	TEST_F (ParseFlagsTest, ThrowOnFailureFalse_0)

	TEST_F (ParseFlagsTest, ThrowOnFailureTrue)

	TEST_F (CurrentTestInfoTest, WorksForFirstTestInATestSuite)

	TEST_F (CurrentTestInfoTest, WorksForSecondTestInATestSuite)

Variables
class GTEST_API_ testing::ScopedTrace	GTEST_ATTRIBUTE_UNUSED_

Typedef Documentation

typedef internal::IgnoredValue testing::Unused

typedef internal::TimeInMillis testing::TimeInMillis

Function Documentation

template<typename F >

Action<F> testing::MakeAction ( ActionInterface< F > * impl )

template<typename Impl >

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

inline

Referenced by Assign(), Return(), ReturnNull(), and SetErrnoAndReturn().

template<typename... Action>

internal::DoAllAction<typename std::decay<Action>::type...> testing::DoAll ( Action &&... action )

References upload::action.

Referenced by testing::internal::ExpectationTester::SetCallCount(), testing::gmock_generated_actions_test::TEST(), and TEST().

template<size_t k, typename InnerAction >

internal::WithArgsAction<typename std::decay<InnerAction>::type, k> testing::WithArg ( InnerAction && action )

References upload::action.

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

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

References upload::action.

template<typename InnerAction >

internal::WithArgsAction<typename std::decay<InnerAction>::type> testing::WithoutArgs ( InnerAction && action )

References upload::action.

Referenced by TEST(), and testing::gmock_more_actions_test::TEST().

template<typename R >

internal::ReturnAction<R> testing::Return ( R value )

Referenced by testing::internal::ExpectationTester::SetCallCount(), TEST(), testing::gmock_generated_actions_test::TEST(), testing::gmock_function_mocker_test::TEST(), testing::gmock_generated_function_mockers_test::TEST(), TEST_F(), testing::gmock_function_mocker_test::TEST_F(), and testing::gmock_generated_function_mockers_test::TEST_F().

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

inline

References MakePolymorphicAction().

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

inline

References MakePolymorphicAction().

template<typename R >

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

inline

References x.

Referenced by TEST(), testing::gmock_function_mocker_test::TEST(), and testing::gmock_generated_function_mockers_test::TEST().

template<typename R >

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

inline

References x.

template<typename R >

internal::ByMoveWrapper<R> testing::ByMove ( R x )

internal::DoDefaultAction testing::DoDefault ( )

inline

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), testing::internal::ExpectationTester::SetCallCount(), TEST(), testing::gmock_function_mocker_test::TEST_F(), and testing::gmock_generated_function_mockers_test::TEST_F().

template<size_t N, typename T >

internal::SetArgumentPointeeAction<N, T> testing::SetArgPointee ( T x )

Referenced by testing::internal::ExpectationTester::SetCallCount().

template<size_t N, typename T >

internal::SetArgumentPointeeAction<N, T> testing::SetArgumentPointee ( T x )

template<typename T1 , typename T2 >

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

References MakePolymorphicAction().

Referenced by TEST().

template<typename T >

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

References MakePolymorphicAction().

Referenced by TEST().

template<typename FunctionImpl >

std::decay<FunctionImpl>::type testing::Invoke ( FunctionImpl && function_impl )

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), testing::gmock_nice_strict_test::MockBaz::MockBaz(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_more_actions_test::TEST(), testing::gmock_nice_strict_test::TEST(), and TEST().

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 )

Referenced by testing::internal::ExpectationTester::SetCallCount(), and TEST().

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 )

inline

Referenced by testing::internal::ExpectationTester::SetCallCount(), and TEST().

template<typename T >

inline ::std::reference_wrapper<T> testing::ByRef ( T & l_value )

Referenced by testing::gmock_generated_actions_test::TEST().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(p0)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_2_VALUE_PARAMS(p0, p1)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_3_VALUE_PARAMS(p0, p1, p2)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_4_VALUE_PARAMS(p0, p1, p2, p3)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	InvokeArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
	)

References testing::internal::invoke_argument::InvokeArgumentAdl().

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_0_VALUE_PARAMS()
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_1_VALUE_PARAMS(p0)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_2_VALUE_PARAMS(p0, p1)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_3_VALUE_PARAMS(p0, p1, p2)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_4_VALUE_PARAMS(p0, p1, p2, p3)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)
	)

testing::ACTION_TEMPLATE	(	ReturnNew	,
		HAS_1_TEMPLATE_PARAMS(typename, T)	,
		AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)
	)

testing::ACTION_TEMPLATE	(	ReturnArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

testing::ACTION_TEMPLATE	(	SaveArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(pointer)
	)

testing::ACTION_TEMPLATE	(	SaveArgPointee	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(pointer)
	)

testing::ACTION_TEMPLATE	(	SetArgReferee	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_1_VALUE_PARAMS(value)
	)

References GTEST_COMPILE_ASSERT_, upload::type, and value.

testing::ACTION_TEMPLATE	(	SetArrayArgument	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_2_VALUE_PARAMS(first, last)
	)

References testing::internal::CopyElements().

testing::ACTION_TEMPLATE	(	DeleteArg	,
		HAS_1_TEMPLATE_PARAMS(int, k)	,
		AND_0_VALUE_PARAMS()
	)

testing::ACTION_P	(	ReturnPointee	,
		pointer
	)

testing::MATCHER	(	IsEmpty	,
		negation?"isn't empty":"is empty"
	)

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

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

testing::GMOCK_DECLARE_bool_ ( catch_leaked_mocks )

testing::GMOCK_DECLARE_string_ ( verbose )

testing::GMOCK_DECLARE_int32_ ( default_mock_behavior )

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

References testing::internal::InitGoogleMockImpl().

Referenced by main(), and TestInitGoogleMock().

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

References testing::internal::InitGoogleMockImpl().

GTEST_API_ void testing::InitGoogleMock ( )

References testing::internal::InitGoogleMockImpl().

GTEST_API_ Cardinality testing::AtLeast ( int n )

References Between().

Referenced by AnyNumber(), GTEST_DISABLE_MSC_WARNINGS_PUSH_(), and testing::internal::ExpectationTester::SetCallCount().

GTEST_API_ Cardinality testing::AtMost ( int n )

References Between().

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), and testing::internal::ExpectationTester::SetCallCount().

GTEST_API_ Cardinality testing::AnyNumber ( )

References AtLeast().

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_function_mocker_test::TEST(), testing::gmock_generated_function_mockers_test::TEST(), and TEST_F().

GTEST_API_ Cardinality testing::Between	(	int	min,
		int	max
	)

Referenced by AtLeast(), AtMost(), Exactly(), GTEST_DISABLE_MSC_WARNINGS_PUSH_(), and testing::internal::ExpectationTester::SetCallCount().

GTEST_API_ Cardinality testing::Exactly ( int n )

References Between().

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), and testing::internal::LogWithLocation().

testing::GMOCK_DEFINE_bool_	(	catch_leaked_mocks	,
		true	,
		"true iff Google Mock should report leaked mock objects ""as failures."
	)

testing::GMOCK_DEFINE_string_	(	verbose	,
		internal::kWarningVerbosity	,
		"Controls how verbose Google Mock's output is."" Valid values:\n"" info - prints all messages.\n"" warning - prints warnings and errors.\n"" error - prints errors only."
	)

testing::GMOCK_DEFINE_int32_	(	default_mock_behavior	,
		1	,
		"Controls the default behavior of mocks."" Valid values:\n"" 0 - by	default,
		mocks act as NiceMocks.\n""1-by	default,
		mocks act as NaggyMocks.\n""2-by	default,
		mocks act as StrictMocks."
	)

testing::GTEST_DECLARE_string_ ( death_test_style )

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

inline

References testing::Message::GetString().

Referenced by GTEST_DISABLE_MSC_WARNINGS_PUSH_(), testing::Message::operator<<(), and TEST().

template<typename T , typename IncrementT >

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

Referenced by TEST(), TEST_F(), and TEST_P().

template<typename T >

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

template<typename ForwardIterator >

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

Referenced by testing::internal::ParameterizedTestSuiteRegistry::GetTestCasePatternHolder(), testing::internal::ValueArray< Ts >::operator ParamGenerator< T >(), TEST(), and TEST_P().

template<typename T , size_t N>

internal::ParamGenerator<T> testing::ValuesIn ( const T(&) array[N] )

References ValuesIn().

template<class Container >

internal::ParamGenerator< typename Container::value_type > testing::ValuesIn ( const Container & container )

Referenced by ValuesIn().

template<typename... T>

internal::ValueArray<T...> testing::Values ( T... v )

Referenced by Bool(), CustomParamNameFunctor::operator()(), TEST(), TEST_P(), and TEST_P().

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

inline

References Values().

Referenced by TEST().

template<typename... Generator>

internal::CartesianProductHolder<Generator...> testing::Combine ( const Generator &... g )

Referenced by TEST().

template<typename T >

::std::string testing::PrintToString ( const T & value )

References testing::internal::UniversalTersePrinter< T >::Print().

Referenced by AssertPred1Helper(), AssertPred2Helper(), AssertPred3Helper(), AssertPred4Helper(), AssertPred5Helper(), testing::internal::CmpHelperSTRCASEEQ(), testing::internal::CmpHelperSTREQ(), testing::internal::CmpHelperSTRNE(), testing::internal::FormatForComparison< ToPrint, OtherOperand >::Format(), GTEST_DISABLE_MSC_WARNINGS_PUSH_(), testing::PrintToStringParamName::operator()(), StatefulNamingFunctor::operator()(), PrintValue(), testing::internal::ParameterizedTestSuiteInfo< TestSuite >::RegisterTests(), testing::gtest_printers_test::TEST(), and TEST_P().

Environment* testing::AddGlobalTestEnvironment ( Environment * env )

inline

References GTEST_API_, and InitGoogleTest().

Referenced by main().

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

Examples:: AutoDiffLinearizerTest.cpp, CodegenTests.cpp, DiscreteTrajectoryTest.cpp, IntegrationTest.cpp, InterpolationTest.cpp, LinspaceTest.cpp, NoiseTest.cpp, and SecondOrderSystemTest.cpp.

References testing::internal::InitGoogleTestImpl().

Referenced by testing::internal::InitGoogleMockImpl(), and main().

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

References testing::internal::InitGoogleTestImpl().

void testing::InitGoogleTest ( )

References testing::internal::InitGoogleTestImpl().

Referenced by AddGlobalTestEnvironment().

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

Referenced by IsNotSubstring(), testing::internal::ExpectationTester::SetCallCount(), testing::internal::TEST(), and testing::ParseFlagsTest::TestParsingFlags().

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

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

Referenced by IsNotSubstring(), testing::internal::ExpectationTester::SetCallCount(), and testing::ParseFlagsTest::TestParsingFlags().

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

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

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

References AssertionFailure(), AssertionSuccess(), IsNotSubstring(), testing::internal::IsSpace(), and IsSubstring().

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

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

template<typename T1 , typename T2 >

bool testing::StaticAssertTypeEq ( )

Referenced by testing::internal::StlContainerView< RawContainer >::ConstReference(), GTEST_DISABLE_MSC_WARNINGS_PUSH_(), and testing::internal::TEST().

std::string testing::TempDir ( )

References testing::internal::posix::GetEnv(), and testing::UnitTest::GetInstance().

Referenced by TEST_F().

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
	)

References GTEST_MUST_USE_RESULT_, testing::internal::MakeAndRegisterTestInfo(), RUN_ALL_TESTS(), and upload::type.

template<typename Pred , typename T1 >

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

References AssertionFailure(), AssertionSuccess(), and PrintToString().

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
	)

References AssertionFailure(), AssertionSuccess(), and PrintToString().

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
	)

References AssertionFailure(), AssertionSuccess(), and PrintToString().

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
	)

References AssertionFailure(), AssertionSuccess(), and PrintToString().

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
	)

References AssertionFailure(), AssertionSuccess(), and PrintToString().

testing::GTEST_DEFINE_string_	(	death_test_style	,
		internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle)	,
		"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking)."
	)

testing::GTEST_DEFINE_bool_	(	death_test_use_fork	,
		internal::BoolFromGTestEnv("death_test_use_fork", false)	,
		"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is	fixed,
		this flag will""most likely be removed."
	)

std::ostream& testing::operator<<	(	std::ostream &	os,
		const TestPartResult &	result
	)

References testing::internal::posix::Abort().

testing::GTEST_DEFINE_bool_	(	also_run_disabled_tests	,
		internal::BoolFromGTestEnv("also_run_disabled_tests", false)	,
		"Run disabled tests	too,
		in addition to the tests normally being run."
	)

testing::GTEST_DEFINE_bool_	(	break_on_failure	,
		internal::BoolFromGTestEnv("break_on_failure", false)	,
		"True iff a failed assertion should be a debugger break-point."
	)

testing::GTEST_DEFINE_bool_	(	catch_exceptions	,
		internal::BoolFromGTestEnv("catch_exceptions", true)	,
		"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures."
	)

testing::GTEST_DEFINE_string_	(	color	,
		internal::StringFromGTestEnv("color","auto")	,
		"Whether to use colors in the output. Valid values:	yes,
		no	,
		""and auto. 'auto'means to use colors if the output is""being sent to a terminal and the TERM environment variable""is set to a terminal type that supports colors."
	)

testing::GTEST_DEFINE_string_	(	filter	,
		internal::StringFromGTestEnv("filter", GetDefaultFilter())	,
		"A colon-separated list of glob (not regex) patterns ""for filtering the tests to	run,
		optionally followed by a""'-'and a:separated list of negative patterns(tests to""exclude).A test is run if it matches one of the positive""patterns and does not match any of the negative patterns."
	)

testing::GTEST_DEFINE_bool_	(	install_failure_signal_handler	,
		internal::BoolFromGTestEnv("install_failure_signal_handler", false)	,
		"If true and supported on the current	platform,
		"GTEST_NAME_"should""install a signal handler that dumps debugging information when fatal""signals are raised."
	)

testing::GTEST_DEFINE_bool_	(	list_tests	,
		false	,
		"List all tests without running them."
	)

testing::GTEST_DEFINE_string_	(	output	,
		internal::StringFromGTestEnv("output", internal::OutputFlagAlsoCheckEnvVar().c_str())	,
		"A format	defaults to \"xml\" but can be specified to be \"json\",
		""optionally followed by a colon and an output file name or directory.""A directory is indicated by a trailing pathname separator.""Examples:\"xml:filename.xml\"	,
		\"xml::directoryname/\". ""If a directory is	specified,
		output files will be created""within that	directory,
		with file-names based on the test""executable's name	and,
		if	necessary,
		made unique by adding""digits."
	)

testing::GTEST_DEFINE_bool_	(	print_time	,
		internal::BoolFromGTestEnv("print_time", true)	,
		"True iff "GTEST_NAME_" should display elapsed time in text output."
	)

testing::GTEST_DEFINE_bool_	(	print_utf8	,
		internal::BoolFromGTestEnv("print_utf8", true)	,
		"True iff "GTEST_NAME_" prints UTF8 characters as text."
	)

testing::GTEST_DEFINE_int32_	(	random_seed	,
		internal::Int32FromGTestEnv("random_seed", 0)	,
		"Random number seed to use when shuffling test orders. Must be in range ""	[1, 99999],
		or 0 to use a seed based on the current time."
	)

testing::GTEST_DEFINE_int32_	(	repeat	,
		internal::Int32FromGTestEnv("repeat", 1)	,
		"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests."
	)

testing::GTEST_DEFINE_bool_	(	show_internal_stack_frames	,
		false	,
		"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces."
	)

testing::GTEST_DEFINE_bool_	(	shuffle	,
		internal::BoolFromGTestEnv("shuffle", false)	,
		"True iff "GTEST_NAME_" should randomize tests' order on every run."
	)

testing::GTEST_DEFINE_int32_	(	stack_trace_depth	,
		internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth)	,
		"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through	100,
		inclusive."
	)

testing::GTEST_DEFINE_string_	(	stream_result_to	,
		internal::StringFromGTestEnv("stream_result_to","")	,
		"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux."
	)

testing::GTEST_DEFINE_bool_	(	throw_on_failure	,
		internal::BoolFromGTestEnv("throw_on_failure", false)	,
		"When this flag is	specified,
		a failed assertion will throw an exception""if exceptions are enabled or exit the program with a non-zero code""otherwise.For use with an external test framework."
	)

AssertionResult testing::AssertionSuccess ( )

AssertionResult testing::AssertionFailure ( const Message & message )

References AssertionFailure(), and googletest-output-test::message.

Referenced by IsNotSubstring().

template<int kSize>

std::vector<std::string> testing::ArrayAsVector ( const char *const (&) array[kSize] )

References ADD_FAILURE, testing::Message::GetString(), GTEST_CHECK_, GTEST_NAME_, i, and testing::TestProperty::key().

testing::TEST	(	GTestEnvVarTest	,
		Dummy
	)

void testing::PrintFlag ( const char * flag )

References GTEST_FLAG, and gmock_output_test::output.

Referenced by main().

testing::GTEST_DECLARE_string_ ( filter )

testing::GTEST_DECLARE_int32_ ( repeat )

testing::TEST	(	SuccessfulAssertionTest	,
		SUCCEED
	)

References EXPECT_EQ, and SUCCEED.

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT
	)

References EXPECT_EQ, and EXPECT_TRUE.

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT_STR
	)

References EXPECT_EQ, and EXPECT_STREQ.

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT
	)

References ASSERT_TRUE, and EXPECT_EQ.

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT_STR
	)

testing::TEST_F	(	TestInfoTest	,
		Names
	)

References ASSERT_STREQ, testing::TestInfo::name(), and testing::TestInfo::test_case_name().

testing::TEST_F	(	TestInfoTest	,
		result
	)

References ASSERT_EQ.

testing::TEST	(	CodeLocationForTEST	,
		Verify
	)

References VERIFY_CODE_LOCATION.

testing::TEST_F	(	CodeLocationForTESTF	,
		Verify
	)

References VERIFY_CODE_LOCATION.

testing::TEST_P	(	CodeLocationForTESTP	,
		Verify
	)

References INSTANTIATE_TEST_SUITE_P(), Values(), and VERIFY_CODE_LOCATION.

testing::INSTANTIATE_TEST_SUITE_P	(	CodeLocationForTESTP	,
		Values(0)
	)

Referenced by TEST_P().

testing::TYPED_TEST_SUITE	(	CodeLocationForTYPEDTEST	,
		int
	)

Referenced by testing::internal::UnitTestHelper::GetSortedTests(), and testing::internal::TEST().

testing::TYPED_TEST	(	CodeLocationForTYPEDTEST	,
		Verify
	)

References VERIFY_CODE_LOCATION.

Referenced by testing::internal::UnitTestHelper::GetSortedTests(), and testing::internal::TEST().

testing::TYPED_TEST_SUITE_P ( CodeLocationForTYPEDTESTP )

testing::TYPED_TEST_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

References INSTANTIATE_TYPED_TEST_SUITE_P(), REGISTER_TYPED_TEST_SUITE_P(), and VERIFY_CODE_LOCATION.

testing::REGISTER_TYPED_TEST_SUITE_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

Referenced by TYPED_TEST_P().

testing::INSTANTIATE_TYPED_TEST_SUITE_P	(	My	,
		CodeLocationForTYPEDTESTP	,
		int
	)

Referenced by TYPED_TEST_P().

testing::TEST_F	(	SetUpTestCaseTest	,
		Test1
	)

References EXPECT_STRNE.

testing::TEST_F	(	SetUpTestCaseTest	,
		Test2
	)

References EXPECT_STREQ.

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite1
	)

References EXPECT_STRNE.

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite2
	)

References EXPECT_STREQ.

testing::TEST_F	(	ParseFlagsTest	,
		Empty
	)

References GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		NoFlag
	)

References GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		FilterBad
	)

References testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		FilterEmpty
	)

References testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		FilterNonEmpty
	)

References testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureWithoutValue
	)

References testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_0
	)

References testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_f
	)

References testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_F
	)

References testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureTrue
	)

References testing::Flags::BreakOnFailure(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		CatchExceptions
	)

References testing::Flags::CatchExceptions(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		DeathTestUseFork
	)

References testing::Flags::DeathTestUseFork(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		DuplicatedFlags
	)

References testing::Flags::Filter(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		UnrecognizedFlag
	)

References testing::Flags::break_on_failure, testing::Flags::filter, and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFlag
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsTrue
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_f
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_F
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ListTests().

testing::TEST_F	(	ParseFlagsTest	,
		OutputEmpty
	)

References GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		OutputXml
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlFile
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlDirectory
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Output().

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFlag
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeTrue
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_f
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_F
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::PrintTime().

testing::TEST_F	(	ParseFlagsTest	,
		RandomSeed
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::RandomSeed().

testing::TEST_F	(	ParseFlagsTest	,
		Repeat
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Repeat().

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFlag
	)

References testing::Flags::AlsoRunDisabledTests(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsTrue
	)

References testing::Flags::AlsoRunDisabledTests(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFalse
	)

References testing::Flags::AlsoRunDisabledTests(), and GTEST_TEST_PARSING_FLAGS_.

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleWithoutValue
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleFalse_0
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleTrue
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::Shuffle().

testing::TEST_F	(	ParseFlagsTest	,
		StackTraceDepth
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::StackTraceDepth().

testing::TEST_F	(	ParseFlagsTest	,
		StreamResultTo
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::StreamResultTo().

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureWithoutValue
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ThrowOnFailure().

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureFalse_0
	)

References GTEST_TEST_PARSING_FLAGS_, and testing::Flags::ThrowOnFailure().

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureTrue
	)

References testing::Flags::break_on_failure, EXPECT_TRUE, FILE, testing::Flags::Filter(), testing::Flags::filter, testing::internal::posix::FOpen(), testing::internal::GetCurrentExecutableName(), GTEST_FLAG_PREFIX_, GTEST_TEST_PARSING_FLAGS_, testing::Flags::list_tests, testing::internal::posix::RmDir(), testing::ParseFlagsTest::SetUp(), testing::Test::TearDown(), TempDir(), testing::internal::TEST_F(), testdata_path_, and testing::Flags::ThrowOnFailure().

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForFirstTestInATestSuite
	)

References ASSERT_TRUE, testing::UnitTest::current_test_info(), EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::TestInfo::name(), and testing::TestInfo::test_case_name().

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForSecondTestInATestSuite
	)

References ASSERT_TRUE, testing::UnitTest::current_test_info(), EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::TestInfo::name(), and testing::TestInfo::test_case_name().

Variable Documentation

class GTEST_API_ testing::ScopedTrace testing::GTEST_ATTRIBUTE_UNUSED_

Referenced by TEST().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation