testing Namespace Reference

Namespaces
namespace	gmock_function_mocker_test
namespace	gmock_matchers_test
namespace	gmock_more_actions_test
namespace	gmock_nice_strict_test
namespace	gtest_printers_test
namespace	internal

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
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)
	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 if and only if 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 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 >
::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 ()
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_ (fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()), "True if and only if a test failure should stop further test execution.")
	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 if and only if a failed assertion should be a debugger " "break-point.")
	GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true), "True if and only if " 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_ (brief, internal::BoolFromGTestEnv("brief", false), "True if only test failures should be displayed in text output.")
	GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true), "True if and only if " GTEST_NAME_ " should display elapsed time in text output.")
	GTEST_DEFINE_bool_ (print_utf8, internal::BoolFromGTestEnv("print_utf8", true), "True if and only if " 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 if and only if " GTEST_NAME_ " should include internal stack frames when " "printing test failure stack traces.")
	GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false), "True if and only if " 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<size_t 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, FailFast)
	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, BriefFlag)
	TEST_F (ParseFlagsTest, BriefFlagTrue)
	TEST_F (ParseFlagsTest, BriefFlagFalse)
	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

TimeInMillis

typedef internal::TimeInMillis testing::TimeInMillis

Definition at line 528 of file gtest.h.

Types

template<typename... Ts>

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

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

Unused

typedef internal::IgnoredValue testing::Unused

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

Function Documentation

AddGlobalTestEnvironment()

Environment * testing::AddGlobalTestEnvironment ( Environment *  env )

inline

Definition at line 1493 of file gtest.h.

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

AnyNumber()

GTEST_API_ Cardinality testing::AnyNumber

(

)

Definition at line 145 of file gmock-cardinalities.cc.

{ return AtLeast(0); }

ArrayAsVector()

template<size_t kSize>

std::vector< std::string > testing::ArrayAsVector

(

const char *const (&)

array[kSize]

)

Definition at line 2286 of file gtest.cc.

                                                                      {
  return std::vector<std::string>(array, array + kSize);
}

AssertionFailure() [1/2]

AssertionResult testing::AssertionFailure

(

)

Definition at line 1214 of file gtest.cc.

                                   {
  return AssertionResult(false);
}

AssertionFailure() [2/2]

AssertionResult testing::AssertionFailure

(

const Message &

message

)

Definition at line 1220 of file gtest.cc.

                                                         {
  return AssertionFailure() << message;
}

AssertionSuccess()

AssertionResult testing::AssertionSuccess

(

)

Definition at line 1209 of file gtest.cc.

                                   {
  return AssertionResult(true);
}

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 130 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 180 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 236 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 298 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 1322 of file gmock-actions.h.

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

AtLeast()

GTEST_API_ Cardinality testing::AtLeast

(

int

n

)

Definition at line 139 of file gmock-cardinalities.cc.

{ return Between(n, INT_MAX); }

AtMost()

GTEST_API_ Cardinality testing::AtMost

(

int

n

)

Definition at line 142 of file gmock-cardinalities.cc.

{ return Between(0, n); }

Between()

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

Definition at line 148 of file gmock-cardinalities.cc.

                                                 {
  return Cardinality(new BetweenCardinalityImpl(min, max));
}

Bool()

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

inline

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

                                           {
  return Values(false, true);
}

ByMove()

template<typename R >

internal::ByMoveWrapper< R > testing::ByMove

(

R

x

)

Definition at line 1281 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 1391 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 405 of file gtest-param-test.h.

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

DeleteArg()

template<size_t k>

internal::DeleteArgAction< k > testing::DeleteArg

(

)

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

                                       {
  return {};
}

DoAll()

template<typename... Action>

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

(

Action &&...

action

)

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

                        {
  return {std::forward_as_tuple(std::forward<Action>(action)...)};
}

DoDefault()

internal::DoDefaultAction testing::DoDefault ( )

inline

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

                                           {
  return internal::DoDefaultAction();
}

DoubleLE()

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

Definition at line 1652 of file gtest.cc.

                                                   {
  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
}

Exactly()

GTEST_API_ Cardinality testing::Exactly

(

int

n

)

Definition at line 153 of file gmock-cardinalities.cc.

{ return Between(n, n); }

FloatLE()

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

Definition at line 1645 of file gtest.cc.

                                                {
  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
}

GMOCK_DECLARE_bool_()

testing::GMOCK_DECLARE_bool_

(

catch_leaked_mocks

)

GMOCK_DECLARE_int32_()

testing::GMOCK_DECLARE_int32_

(

default_mock_behavior

)

GMOCK_DECLARE_string_()

testing::GMOCK_DECLARE_string_

(

verbose

)

GMOCK_DEFINE_bool_()

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

GMOCK_DEFINE_int32_()

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."
	)

GMOCK_DEFINE_string_()

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."
	)

GTEST_DECLARE_int32_()

testing::GTEST_DECLARE_int32_

(

repeat

)

GTEST_DECLARE_string_() [1/2]

testing::GTEST_DECLARE_string_

(

death_test_style

)

GTEST_DECLARE_string_() [2/2]

testing::GTEST_DECLARE_string_

(

filter

)

GTEST_DEFINE_bool_() [1/13]

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."
	)

GTEST_DEFINE_bool_() [2/13]

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

GTEST_DEFINE_bool_() [3/13]

testing::GTEST_DEFINE_bool_	(	brief	,
		internal::BoolFromGTestEnv("brief", false)	,
		"True if only test failures should be displayed in text output."
	)

GTEST_DEFINE_bool_() [4/13]

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

GTEST_DEFINE_bool_() [5/13]

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."
	)

GTEST_DEFINE_bool_() [6/13]

testing::GTEST_DEFINE_bool_	(	fail_fast	,
		internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast())	,
		"True if and only if a test failure should stop further test execution."
	)

GTEST_DEFINE_bool_() [7/13]

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."
	)

GTEST_DEFINE_bool_() [8/13]

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

GTEST_DEFINE_bool_() [9/13]

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

GTEST_DEFINE_bool_() [10/13]

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

GTEST_DEFINE_bool_() [11/13]

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

GTEST_DEFINE_bool_() [12/13]

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

GTEST_DEFINE_bool_() [13/13]

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."
	)

GTEST_DEFINE_int32_() [1/3]

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."
	)

GTEST_DEFINE_int32_() [2/3]

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."
	)

GTEST_DEFINE_int32_() [3/3]

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."
	)

GTEST_DEFINE_string_() [1/5]

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."
	)

GTEST_DEFINE_string_() [2/5]

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)."
	)

GTEST_DEFINE_string_() [3/5]

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."
	)

GTEST_DEFINE_string_() [4/5]

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."
	)

GTEST_DEFINE_string_() [5/5]

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."
	)

IgnoreResult()

template<typename A >

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

inline

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

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

InitGoogleMock() [1/3]

GTEST_API_ void testing::InitGoogleMock

(

)

Definition at line 203 of file gmock.cc.

                                 {
  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
  int argc = 1;
  const auto arg0 = "dummy";
  char* argv0 = const_cast<char*>(arg0);
  char** argv = &argv0;
 
  internal::InitGoogleMockImpl(&argc, argv);
}

InitGoogleMock() [2/3]

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

Definition at line 191 of file gmock.cc.

                                                       {
  internal::InitGoogleMockImpl(argc, argv);
}

InitGoogleMock() [3/3]

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

Definition at line 197 of file gmock.cc.

                                                          {
  internal::InitGoogleMockImpl(argc, argv);
}

InitGoogleTest() [1/3]

void testing::InitGoogleTest

(

)

Definition at line 6680 of file gtest.cc.

                      {
  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
  int argc = 1;
  const auto arg0 = "dummy";
  char* argv0 = const_cast<char*>(arg0);
  char** argv = &argv0;
 
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(&argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

InitGoogleTest() [2/3]

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

Definition at line 6660 of file gtest.cc.

                                            {
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

InitGoogleTest() [3/3]

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

Definition at line 6670 of file gtest.cc.

                                               {
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

INSTANTIATE_TEST_SUITE_P()

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

INSTANTIATE_TYPED_TEST_SUITE_P()

testing::INSTANTIATE_TYPED_TEST_SUITE_P	(	My	,
		CodeLocationForTYPEDTESTP	,
		int
	)

Invoke() [1/2]

template<class Class , typename MethodPtr >

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

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

                                                                            {
  return {obj_ptr, method_ptr};
}

Invoke() [2/2]

template<typename FunctionImpl >

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

(

FunctionImpl &&

function_impl

)

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

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

InvokeArgument()

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

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

(

Params &&...

params

)

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

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

InvokeWithoutArgs() [1/2]

template<class Class , typename MethodPtr >

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

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

                                          {
  return {obj_ptr, method_ptr};
}

InvokeWithoutArgs() [2/2]

template<typename FunctionImpl >

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

(

FunctionImpl

function_impl

)

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

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

IsNotSubstring() [1/3]

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

Definition at line 1807 of file gtest.cc.

                                                        {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

IsNotSubstring() [2/3]

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

Definition at line 1789 of file gtest.cc.

                                              {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

IsNotSubstring() [3/3]

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

Definition at line 1795 of file gtest.cc.

                                                    {
  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
}

IsSubstring() [1/3]

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

Definition at line 1801 of file gtest.cc.

                                                        {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

IsSubstring() [2/3]

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

Definition at line 1777 of file gtest.cc.

                                              {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

IsSubstring() [3/3]

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

Definition at line 1783 of file gtest.cc.

                                                    {
  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
}

MakeAction()

template<typename F >

Action< F > testing::MakeAction

(

ActionInterface< F > *

impl

)

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

                                               {
  return Action<F>(impl);
}

MakePolymorphicAction()

template<typename Impl >

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

inline

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

                                                                       {
  return PolymorphicAction<Impl>(impl);
}

MATCHER() [1/3]

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

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

                                          : "is empty") {
  if (arg.empty()) {
    return true;
  }
  *result_listener << "whose size is " << arg.size();
  return false;
}

MATCHER() [2/3]

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

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

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

MATCHER() [3/3]

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

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

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

operator<<() [1/2]

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

inline

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

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

operator<<() [2/2]

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

Definition at line 50 of file gtest-test-part.cc.

                                                                     {
  return os << internal::FormatFileLocation(result.file_name(),
                                            result.line_number())
            << " "
            << (result.type() == TestPartResult::kSuccess
                    ? "Success"
                    : result.type() == TestPartResult::kSkip
                          ? "Skipped"
                          : result.type() == TestPartResult::kFatalFailure
                                ? "Fatal failure"
                                : "Non-fatal failure")
            << ":\n"
            << result.message() << std::endl;
}

PrintFlag()

void testing::PrintFlag

(

const char *

flag

)

Definition at line 49 of file googletest-env-var-test_.cc.

                                 {
  if (strcmp(flag, "break_on_failure") == 0) {
    cout << GTEST_FLAG(break_on_failure);
    return;
  }
 
  if (strcmp(flag, "catch_exceptions") == 0) {
    cout << GTEST_FLAG(catch_exceptions);
    return;
  }
 
  if (strcmp(flag, "color") == 0) {
    cout << GTEST_FLAG(color);
    return;
  }
 
  if (strcmp(flag, "death_test_style") == 0) {
    cout << GTEST_FLAG(death_test_style);
    return;
  }
 
  if (strcmp(flag, "death_test_use_fork") == 0) {
    cout << GTEST_FLAG(death_test_use_fork);
    return;
  }
 
  if (strcmp(flag, "fail_fast") == 0) {
    cout << GTEST_FLAG(fail_fast);
    return;
  }
 
  if (strcmp(flag, "filter") == 0) {
    cout << GTEST_FLAG(filter);
    return;
  }
 
  if (strcmp(flag, "output") == 0) {
    cout << GTEST_FLAG(output);
    return;
  }
 
  if (strcmp(flag, "brief") == 0) {
    cout << GTEST_FLAG(brief);
    return;
  }
 
  if (strcmp(flag, "print_time") == 0) {
    cout << GTEST_FLAG(print_time);
    return;
  }
 
  if (strcmp(flag, "repeat") == 0) {
    cout << GTEST_FLAG(repeat);
    return;
  }
 
  if (strcmp(flag, "stack_trace_depth") == 0) {
    cout << GTEST_FLAG(stack_trace_depth);
    return;
  }
 
  if (strcmp(flag, "throw_on_failure") == 0) {
    cout << GTEST_FLAG(throw_on_failure);
    return;
  }
 
  cout << "Invalid flag name " << flag
       << ".  Valid names are break_on_failure, color, filter, etc.\n";
  exit(1);
}

PrintToString()

template<typename T >

::std::string testing::PrintToString

(

const T &

value

)

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

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

Range() [1/2]

template<typename T >

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

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

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

Range() [2/2]

template<typename T , typename IncrementT >

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

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

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

REGISTER_TYPED_TEST_SUITE_P()

testing::REGISTER_TYPED_TEST_SUITE_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

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 2455 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]

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

inline

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

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

Return() [2/2]

template<typename R >

internal::ReturnAction< R > testing::Return

(

R

value

)

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

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

ReturnArg()

template<size_t k>

internal::ReturnArgAction< k > testing::ReturnArg

(

)

Definition at line 1406 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 1399 of file gmock-actions.h.

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

ReturnNull()

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

inline

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

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

ReturnPointee()

template<typename Ptr >

internal::ReturnPointeeAction< Ptr > testing::ReturnPointee

(

Ptr

pointer

)

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

                                                            {
  return {pointer};
}

ReturnRef() [1/2]

template<typename R , R * = nullptr>

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

delete

ReturnRef() [2/2]

template<typename R >

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

inline

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

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

ReturnRefOfCopy()

template<typename R >

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

inline

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

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

ReturnRoundRobin() [1/2]

template<typename T >

internal::ReturnRoundRobinAction< T > testing::ReturnRoundRobin

(

std::initializer_list< T >

vals

)

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

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

ReturnRoundRobin() [2/2]

template<typename T >

internal::ReturnRoundRobinAction< T > testing::ReturnRoundRobin

(

std::vector< T >

vals

)

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

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

SaveArg()

template<size_t k, typename Ptr >

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

(

Ptr

pointer

)

Definition at line 1413 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 1420 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 1310 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 1427 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 1316 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 1438 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 1331 of file gmock-actions.h.

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

StaticAssertTypeEq()

template<typename T1 , typename T2 >

constexpr bool testing::StaticAssertTypeEq ( )

constexprnoexcept

Definition at line 2316 of file gtest.h.

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

TempDir()

std::string testing::TempDir

(

)

Definition at line 6694 of file gtest.cc.

                    {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS_MOBILE
  return "\\temp\\";
#elif GTEST_OS_WINDOWS
  const char* temp_dir = internal::posix::GetEnv("TEMP");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "\\temp\\";
  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
    return temp_dir;
  } else {
    return std::string(temp_dir) + "\\";
  }
#elif GTEST_OS_LINUX_ANDROID
  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "/data/local/tmp/";
  } else {
    return temp_dir;
  }
#elif GTEST_OS_LINUX
  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
  if (temp_dir == nullptr || temp_dir[0] == '\0') {
    return "/tmp/";
  } else {
    return temp_dir;
  }
#else
  return "/tmp/";
#endif  // GTEST_OS_WINDOWS_MOBILE
}

TEST() [1/7]

testing::TEST	(	CodeLocationForTEST	,
		Verify
	)

Definition at line 5394 of file gtest_unittest.cc.

                                  {
  VERIFY_CODE_LOCATION;
}

TEST() [2/7]

testing::TEST	(	GTestEnvVarTest	,
		Dummy
	)

Definition at line 46 of file googletest-env-var-test_.cc.

                             {
}

TEST() [3/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT
	)

Definition at line 4316 of file gtest_unittest.cc.

                                      {
  ASSERT_TRUE(true);
  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
}

TEST() [4/7]

testing::TEST	(	SuccessfulAssertionTest	,
		ASSERT_STR
	)

Definition at line 4322 of file gtest_unittest.cc.

                                          {
  ASSERT_STREQ("", "");
  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
}

TEST() [5/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT
	)

Definition at line 4304 of file gtest_unittest.cc.

                                      {
  EXPECT_TRUE(true);
  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
}

TEST() [6/7]

testing::TEST	(	SuccessfulAssertionTest	,
		EXPECT_STR
	)

Definition at line 4310 of file gtest_unittest.cc.

                                          {
  EXPECT_STREQ("", "");
  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
}

TEST() [7/7]

testing::TEST	(	SuccessfulAssertionTest	,
		SUCCEED
	)

Definition at line 4297 of file gtest_unittest.cc.

                                       {
  SUCCEED();
  SUCCEED() << "OK";
  EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
}

TEST_F() [1/54]

testing::TEST_F	(	CodeLocationForTESTF	,
		Verify
	)

Definition at line 5401 of file gtest_unittest.cc.

                                     {
  VERIFY_CODE_LOCATION;
}

TEST_F() [2/54]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForFirstTestInATestSuite
	)

Definition at line 6402 of file gtest_unittest.cc.

                                                           {
  const TestInfo* test_info =
    UnitTest::GetInstance()->current_test_info();
  ASSERT_TRUE(nullptr != test_info)
      << "There is a test running so we should have a valid TestInfo.";
  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
      << "Expected the name of the currently running test suite.";
  EXPECT_STREQ("WorksForFirstTestInATestSuite", test_info->name())
      << "Expected the name of the currently running test.";
}

TEST_F() [3/54]

testing::TEST_F	(	CurrentTestInfoTest	,
		WorksForSecondTestInATestSuite
	)

Definition at line 6417 of file gtest_unittest.cc.

                                                            {
  const TestInfo* test_info =
    UnitTest::GetInstance()->current_test_info();
  ASSERT_TRUE(nullptr != test_info)
      << "There is a test running so we should have a valid TestInfo.";
  EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
      << "Expected the name of the currently running test suite.";
  EXPECT_STREQ("WorksForSecondTestInATestSuite", test_info->name())
      << "Expected the name of the currently running test.";
}

TEST_F() [4/54]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFalse
	)

Definition at line 6186 of file gtest_unittest.cc.

                                                  {
  const char* argv[] = {"foo.exe", "--gtest_also_run_disabled_tests=0",
                        nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false),
                            false);
}

TEST_F() [5/54]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsFlag
	)

Definition at line 6165 of file gtest_unittest.cc.

                                                 {
  const char* argv[] = {"foo.exe", "--gtest_also_run_disabled_tests", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true),
                            false);
}

TEST_F() [6/54]

testing::TEST_F	(	ParseFlagsTest	,
		AlsoRunDisabledTestsTrue
	)

Definition at line 6175 of file gtest_unittest.cc.

                                                 {
  const char* argv[] = {"foo.exe", "--gtest_also_run_disabled_tests=1",
                        nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true),
                            false);
}

TEST_F() [7/54]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_0
	)

Definition at line 5912 of file gtest_unittest.cc.

                                              {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}

TEST_F() [8/54]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_f
	)

Definition at line 5921 of file gtest_unittest.cc.

                                              {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure=f", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}

TEST_F() [9/54]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureFalse_F
	)

Definition at line 5930 of file gtest_unittest.cc.

                                              {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure=F", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
}

TEST_F() [10/54]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureTrue
	)

Definition at line 5940 of file gtest_unittest.cc.

                                           {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
}

TEST_F() [11/54]

testing::TEST_F	(	ParseFlagsTest	,
		BreakOnFailureWithoutValue
	)

Definition at line 5903 of file gtest_unittest.cc.

                                                   {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
}

TEST_F() [12/54]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlag
	)

Definition at line 6075 of file gtest_unittest.cc.

                                  {
  const char* argv[] = {"foo.exe", "--gtest_brief", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Brief(true), false);
}

TEST_F() [13/54]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlagFalse
	)

Definition at line 6093 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_brief=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Brief(false), false);
}

TEST_F() [14/54]

testing::TEST_F	(	ParseFlagsTest	,
		BriefFlagTrue
	)

Definition at line 6084 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_brief=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Brief(true), false);
}

TEST_F() [15/54]

testing::TEST_F	(	ParseFlagsTest	,
		CatchExceptions
	)

Definition at line 5949 of file gtest_unittest.cc.

                                        {
  const char* argv[] = {"foo.exe", "--gtest_catch_exceptions", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
}

TEST_F() [16/54]

testing::TEST_F	(	ParseFlagsTest	,
		DeathTestUseFork
	)

Definition at line 5958 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_death_test_use_fork", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
}

TEST_F() [17/54]

testing::TEST_F	(	ParseFlagsTest	,
		DuplicatedFlags
	)

Definition at line 5968 of file gtest_unittest.cc.

                                        {
  const char* argv[] = {"foo.exe", "--gtest_filter=a", "--gtest_filter=b",
                        nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
}

TEST_F() [18/54]

testing::TEST_F	(	ParseFlagsTest	,
		Empty
	)

Definition at line 5849 of file gtest_unittest.cc.

                              {
  const char* argv[] = {nullptr};
 
  const char* argv2[] = {nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
}

TEST_F() [19/54]

testing::TEST_F	(	ParseFlagsTest	,
		FailFast
	)

Definition at line 5867 of file gtest_unittest.cc.

                                 {
  const char* argv[] = {"foo.exe", "--gtest_fail_fast", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::FailFast(true), false);
}

TEST_F() [20/54]

testing::TEST_F	(	ParseFlagsTest	,
		FilterBad
	)

Definition at line 5876 of file gtest_unittest.cc.

                                  {
  const char* argv[] = {"foo.exe", "--gtest_filter", nullptr};
 
  const char* argv2[] = {"foo.exe", "--gtest_filter", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
}

TEST_F() [21/54]

testing::TEST_F	(	ParseFlagsTest	,
		FilterEmpty
	)

Definition at line 5885 of file gtest_unittest.cc.

                                    {
  const char* argv[] = {"foo.exe", "--gtest_filter=", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
}

TEST_F() [22/54]

testing::TEST_F	(	ParseFlagsTest	,
		FilterNonEmpty
	)

Definition at line 5894 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_filter=abc", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
}

TEST_F() [23/54]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse
	)

Definition at line 6010 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_list_tests=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}

TEST_F() [24/54]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_f
	)

Definition at line 6019 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_list_tests=f", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}

TEST_F() [25/54]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFalse_F
	)

Definition at line 6028 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_list_tests=F", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
}

TEST_F() [26/54]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsFlag
	)

Definition at line 5992 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_list_tests", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
}

TEST_F() [27/54]

testing::TEST_F	(	ParseFlagsTest	,
		ListTestsTrue
	)

Definition at line 6001 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_list_tests=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
}

TEST_F() [28/54]

testing::TEST_F	(	ParseFlagsTest	,
		NoFlag
	)

Definition at line 5858 of file gtest_unittest.cc.

                               {
  const char* argv[] = {"foo.exe", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
}

TEST_F() [29/54]

testing::TEST_F	(	ParseFlagsTest	,
		OutputEmpty
	)

Definition at line 6037 of file gtest_unittest.cc.

                                    {
  const char* argv[] = {"foo.exe", "--gtest_output", nullptr};
 
  const char* argv2[] = {"foo.exe", "--gtest_output", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
}

TEST_F() [30/54]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXml
	)

Definition at line 6046 of file gtest_unittest.cc.

                                  {
  const char* argv[] = {"foo.exe", "--gtest_output=xml", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
}

TEST_F() [31/54]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlDirectory
	)

Definition at line 6064 of file gtest_unittest.cc.

                                           {
  const char* argv[] = {"foo.exe", "--gtest_output=xml:directory/path/",
                        nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2,
                            Flags::Output("xml:directory/path/"), false);
}

TEST_F() [32/54]

testing::TEST_F	(	ParseFlagsTest	,
		OutputXmlFile
	)

Definition at line 6055 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_output=xml:file", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
}

TEST_F() [33/54]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse
	)

Definition at line 6120 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_print_time=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}

TEST_F() [34/54]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_f
	)

Definition at line 6129 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_print_time=f", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}

TEST_F() [35/54]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFalse_F
	)

Definition at line 6138 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_print_time=F", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
}

TEST_F() [36/54]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeFlag
	)

Definition at line 6102 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_print_time", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
}

TEST_F() [37/54]

testing::TEST_F	(	ParseFlagsTest	,
		PrintTimeTrue
	)

Definition at line 6111 of file gtest_unittest.cc.

                                      {
  const char* argv[] = {"foo.exe", "--gtest_print_time=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
}

TEST_F() [38/54]

testing::TEST_F	(	ParseFlagsTest	,
		RandomSeed
	)

Definition at line 6147 of file gtest_unittest.cc.

                                   {
  const char* argv[] = {"foo.exe", "--gtest_random_seed=1000", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
}

TEST_F() [39/54]

testing::TEST_F	(	ParseFlagsTest	,
		Repeat
	)

Definition at line 6156 of file gtest_unittest.cc.

                               {
  const char* argv[] = {"foo.exe", "--gtest_repeat=1000", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
}

TEST_F() [40/54]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleFalse_0
	)

Definition at line 6206 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_shuffle=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
}

TEST_F() [41/54]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleTrue
	)

Definition at line 6215 of file gtest_unittest.cc.

                                    {
  const char* argv[] = {"foo.exe", "--gtest_shuffle=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
}

TEST_F() [42/54]

testing::TEST_F	(	ParseFlagsTest	,
		ShuffleWithoutValue
	)

Definition at line 6197 of file gtest_unittest.cc.

                                            {
  const char* argv[] = {"foo.exe", "--gtest_shuffle", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
}

TEST_F() [43/54]

testing::TEST_F	(	ParseFlagsTest	,
		StackTraceDepth
	)

Definition at line 6224 of file gtest_unittest.cc.

                                        {
  const char* argv[] = {"foo.exe", "--gtest_stack_trace_depth=5", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
}

TEST_F() [44/54]

testing::TEST_F	(	ParseFlagsTest	,
		StreamResultTo
	)

Definition at line 6232 of file gtest_unittest.cc.

                                       {
  const char* argv[] = {"foo.exe", "--gtest_stream_result_to=localhost:1234",
                        nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(
      argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
}

TEST_F() [45/54]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureFalse_0
	)

Definition at line 6252 of file gtest_unittest.cc.

                                              {
  const char* argv[] = {"foo.exe", "--gtest_throw_on_failure=0", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
}

TEST_F() [46/54]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureTrue
	)

Definition at line 6262 of file gtest_unittest.cc.

                                           {
  const char* argv[] = {"foo.exe", "--gtest_throw_on_failure=1", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
}

TEST_F() [47/54]

testing::TEST_F	(	ParseFlagsTest	,
		ThrowOnFailureWithoutValue
	)

Definition at line 6243 of file gtest_unittest.cc.

                                                   {
  const char* argv[] = {"foo.exe", "--gtest_throw_on_failure", nullptr};
 
  const char* argv2[] = {"foo.exe", nullptr};
 
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
}

TEST_F() [48/54]

testing::TEST_F	(	ParseFlagsTest	,
		UnrecognizedFlag
	)

Definition at line 5978 of file gtest_unittest.cc.

                                         {
  const char* argv[] = {"foo.exe", "--gtest_break_on_failure",
                        "bar",  // Unrecognized by Google Test.
                        "--gtest_filter=b", nullptr};
 
  const char* argv2[] = {"foo.exe", "bar", nullptr};
 
  Flags flags;
  flags.break_on_failure = true;
  flags.filter = "b";
  GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
}

TEST_F() [49/54]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test1
	)

Definition at line 5495 of file gtest_unittest.cc.

{ EXPECT_STRNE(nullptr, shared_resource_); }

TEST_F() [50/54]

testing::TEST_F	(	SetUpTestCaseTest	,
		Test2
	)

Definition at line 5498 of file gtest_unittest.cc.

                                 {
  EXPECT_STREQ("123", shared_resource_);
}

TEST_F() [51/54]

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite1
	)

Definition at line 5556 of file gtest_unittest.cc.

                                                {
  EXPECT_STRNE(nullptr, shared_resource_);
}

TEST_F() [52/54]

testing::TEST_F	(	SetUpTestSuiteTest	,
		TestSetupTestSuite2
	)

Definition at line 5561 of file gtest_unittest.cc.

                                                {
  EXPECT_STREQ("123", shared_resource_);
}

TEST_F() [53/54]

testing::TEST_F	(	TestInfoTest	,
		Names
	)

Definition at line 5369 of file gtest_unittest.cc.

                            {
  const TestInfo* const test_info = GetTestInfo("Names");
 
  ASSERT_STREQ("TestInfoTest", test_info->test_suite_name());
  ASSERT_STREQ("Names", test_info->name());
}

TEST_F() [54/54]

testing::TEST_F	(	TestInfoTest	,
		result
	)

Definition at line 5377 of file gtest_unittest.cc.

                             {
  const TestInfo* const test_info = GetTestInfo("result");
 
  // Initially, there is no TestPartResult for this test.
  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
 
  // After the previous assertion, there is still none.
  ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
}

TEST_P()

testing::TEST_P	(	CodeLocationForTESTP	,
		Verify
	)

Definition at line 5408 of file gtest_unittest.cc.

                                     {
  VERIFY_CODE_LOCATION;
}

TYPED_TEST()

testing::TYPED_TEST	(	CodeLocationForTYPEDTEST	,
		Verify
	)

Definition at line 5420 of file gtest_unittest.cc.

                                             {
  VERIFY_CODE_LOCATION;
}

TYPED_TEST_P()

testing::TYPED_TEST_P	(	CodeLocationForTYPEDTESTP	,
		Verify
	)

Definition at line 5430 of file gtest_unittest.cc.

                                                {
  VERIFY_CODE_LOCATION;
}

TYPED_TEST_SUITE()

testing::TYPED_TEST_SUITE	(	CodeLocationForTYPEDTEST	,
		int
	)

TYPED_TEST_SUITE_P()

testing::TYPED_TEST_SUITE_P

(

CodeLocationForTYPEDTESTP

)

Values()

template<typename... T>

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

(

T...

v

)

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

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

ValuesIn() [1/3]

template<class Container >

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

(

const Container &

container

)

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

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

ValuesIn() [2/3]

template<typename T , size_t N>

internal::ParamGenerator< T > testing::ValuesIn

(

const T(&)

array[N]

)

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

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

ValuesIn() [3/3]

template<typename ForwardIterator >

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

Definition at line 294 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));
}

WithArg()

template<size_t k, typename InnerAction >

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

(

InnerAction &&

action

)

Definition at line 1216 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 1226 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 1236 of file gmock-actions.h.

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

Variable Documentation

GTEST_ATTRIBUTE_UNUSED_

class GTEST_API_ testing::ScopedTrace testing::GTEST_ATTRIBUTE_UNUSED_