testing::internal Namespace Reference

Namespaces
namespace	edit_distance
namespace	gmockpp
namespace	internal_stream_operator_without_lexical_name_lookup
namespace	posix

Classes
struct	ActionImpl
struct	ActionImpl< R(Args...), Impl >
class	AssertHelper
class	AssignAction
class	Base
class	BriefUnitTestResultPrinter
class	BuiltInDefaultValue
class	BuiltInDefaultValue< const T >
class	BuiltInDefaultValue< T * >
struct	BuiltInDefaultValueGetter
struct	BuiltInDefaultValueGetter< T, false >
struct	ByMoveWrapper
class	CartesianProductGenerator
class	CartesianProductHolder
class	Castable
struct	CodeLocation
struct	conjunction
struct	conjunction< P1 >
struct	conjunction< P1, Ps... >
class	ConstAndNonConstCastable
class	ConstCastable
struct	ConstCharPtr
struct	ConstRef
struct	ConstRef< T & >
struct	ContainerPrinter
struct	ConvertibleToIntegerPrinter
struct	ConvertibleToStringViewPrinter
class	DefaultGlobalTestPartResultReporter
struct	DefaultNameGenerator
class	DefaultPerThreadTestPartResultReporter
struct	DeleteArgAction
class	Derived
struct	disjunction
struct	disjunction< P1 >
struct	disjunction< P1, Ps... >
class	DoAllAction
class	DoAllAction< FinalAction >
class	DoAllAction< InitialAction, OtherActions... >
class	DoDefaultAction
struct	DoubleSequence
struct	DoubleSequence< false, IndexSequence< I... >, sizeofT >
struct	DoubleSequence< true, IndexSequence< I... >, sizeofT >
struct	ElemFromList
struct	ElemFromListImpl
struct	ElemFromListImpl< IndexSequence< I... > >
class	EnvironmentInvocationCatcher
class	EqHelper
class	EventRecordingListener
class	EventRecordingListener2
struct	ExcessiveArg
class	FailureReporterInterface
struct	faketype
struct	FallbackPrinter
class	FinalSuccessChecker
struct	FindFirstPrinter
struct	FindFirstPrinter< T, decltype(Printer::PrintValue(std::declval< const T & >(), nullptr)), Printer, Printers... >
class	FlatTuple
struct	FlatTupleBase
struct	FlatTupleBase< FlatTuple< T... >, IndexSequence< Idx... > >
struct	FlatTupleConstructTag
struct	FlatTupleElemBase
struct	FlatTupleElemBase< FlatTuple< T... >, I >
class	FloatingPoint
class	FormatForComparison
class	FormatForComparison< ToPrint[N], OtherOperand >
struct	Function
struct	Function< R(Args...)>
struct	FunctionPointerPrinter
struct	GenerateTypeList
class	GoogleTestFailureReporter
class	GTestFlagSaver
class	GTestLog
class	GTestMutexLock
class	GTestNonCopyable
class	HasDebugStringAndShortDebugString
struct	Ignore
class	IgnoredValue
class	IgnoreResultAction
struct	ImplBase
struct	IndexSequence
struct	InvokeArgumentAction
struct	InvokeMethodAction
struct	InvokeMethodWithoutArgsAction
struct	InvokeWithoutArgsAction
struct	is_callable_r_impl
struct	is_callable_r_impl< void_t< call_result_t< F, Args... > >, R, F, Args... >
struct	is_implicitly_convertible
struct	is_proxy_type_list
struct	is_proxy_type_list< ProxyTypeList< Ts... > >
class	IsEmptyMatcher
struct	IsHashTable
struct	IsRecursiveContainer
struct	IsRecursiveContainerImpl
struct	IsRecursiveContainerImpl< C, false >
struct	IsRecursiveContainerImpl< C, true >
struct	KindOf
struct	LessByName
class	ListenerTest
struct	MakeIndexSequenceImpl
struct	MakeIndexSequenceImpl< 0 >
struct	MarkAsIgnored
class	MaxBipartiteMatchState
class	Mutex
class	NaggyMockImpl
struct	NameGeneratorSelector
class	NativeArray
struct	negation
class	NiceMockImpl
class	NoDefaultConstructor
struct	None
class	OsStackTraceGetter
class	OsStackTraceGetterInterface
class	ParamConverterGenerator
class	ParameterizedTestFactory
class	ParameterizedTestSuiteInfo
class	ParameterizedTestSuiteInfoBase
class	ParameterizedTestSuiteRegistry
class	ParamGenerator
class	ParamGeneratorConverter
class	ParamGeneratorInterface
class	ParamIterator
class	ParamIteratorInterface
struct	PointerPrinter
class	PrettyUnitTestResultPrinter
struct	ProtobufPrinter
struct	ProxyTypeList
class	Random
class	RangeGenerator
struct	RawBytesPrinter
struct	RelationToSourceCopy
struct	RelationToSourceReference
struct	RemoveConstFromKey
struct	RemoveConstFromKey< std::pair< const K, V > >
class	ReturnAction
class	ReturnAction< ByMoveWrapper< T > >
struct	ReturnArgAction
struct	ReturnNewAction
class	ReturnNullAction
struct	ReturnPointeeAction
class	ReturnRefAction
class	ReturnRefOfCopyAction
class	ReturnRoundRobinAction
class	ReturnVoidAction
struct	SaveArgAction
struct	SaveArgPointeeAction
class	Secret
struct	SetArgRefereeAction
struct	SetArgumentPointeeAction
struct	SetArrayArgumentAction
class	SetErrnoAndReturnAction
class	StlContainerView
class	StlContainerView< ::std::tuple< ElementPointer, Size > >
class	StlContainerView< Element[N]>
class	StrictMockImpl
class	String
struct	SuiteApiResolver
struct	Templates
struct	Templates< Head_ >
struct	TemplateSel
class	TestEventListenersAccessor
class	TestEventRepeater
class	TestFactoryBase
class	TestFactoryImpl
class	TestMetaFactory
class	TestMetaFactoryBase
class	TestPropertyKeyIs
class	TestResultAccessor
class	TestSuiteNameIs
class	TestSuiteWithCommentTest
struct	ThisRefAdjuster
class	ThreadLocal
class	Timer
class	To
struct	TraceInfo
struct	TrueWithString
class	TypeIdHelper
class	TypeParameterizedTest
class	TypeParameterizedTest< Fixture, TestSel, internal::None >
class	TypeParameterizedTestSuite
class	TypeParameterizedTestSuite< Fixture, internal::None, Types >
class	TypeParameterizedTestSuiteRegistry
struct	Types
struct	Types< Head_ >
class	TypeWithSize
class	TypeWithSize< 4 >
class	TypeWithSize< 8 >
class	UnitTestHelper
class	UnitTestImpl
class	UnitTestOptions
class	UnitTestRecordPropertyTestHelper
class	UniversalPrinter
class	UniversalPrinter< const T >
class	UniversalPrinter< T & >
class	UniversalPrinter< T[N]>
class	UniversalPrinter< Wrapper< T > >
class	UniversalTersePrinter
class	UniversalTersePrinter< char * >
class	UniversalTersePrinter< char16_t * >
class	UniversalTersePrinter< char32_t * >
class	UniversalTersePrinter< const char * >
class	UniversalTersePrinter< const char16_t * >
class	UniversalTersePrinter< const char32_t * >
class	UniversalTersePrinter< std::reference_wrapper< T > >
class	UniversalTersePrinter< T & >
class	UniversalTersePrinter< T[N]>
class	UniversalTersePrinter< wchar_t * >
class	ValueArray
class	ValuesInIteratorRangeGenerator
struct	WithArgsAction
class	WithoutMatchers

Typedefs
template<typename... >
using	void_t = void
template<typename F , typename... Args>
using	call_result_t = decltype(std::declval<F>()(std::declval<Args>()...))
template<typename R , typename F , typename... Args>
using	is_callable_r = is_callable_r_impl<void, R, F, Args...>
template<typename T >
using	identity_t = T
template<TypeKind kFromKind, typename From , TypeKind kToKind, typename To >
using	LosslessArithmeticConvertibleImpl
template<typename From , typename To >
using	LosslessArithmeticConvertible
template<size_t I, typename T >
using	TupleElement = typename std::tuple_element<I, T>::type
typedef ::std::vector<::std::string >	Strings
typedef FloatingPoint< float >	Float
typedef FloatingPoint< double >	Double
typedef const void *	TypeId
using	SetUpTestSuiteFunc = void (*)()
using	TearDownTestSuiteFunc = void (*)()
using	SetUpTearDownSuiteFuncType = void (*)()
using	TypedTestCasePState = TypedTestSuitePState
typedef int	IsContainer
typedef char	IsNotContainer
template<size_t N>
using	MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type
template<typename... T>
using	IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type
template<class TestCase >
using	ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>
typedef GTestMutexLock	MutexLock
using	BiggestInt = long long
using	TimeInMillis = int64_t

Enumerations
enum	TypeKind { kBool , kInteger , kFloatingPoint , kOther }
enum	LogSeverity { kInfo = 0 , kWarning = 1 }
enum	GTestLogSeverity { GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL }
enum	CharFormat { kAsIs , kHexEscape , kSpecialEscape }

Functions
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (::std::string, "")
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (wchar_t, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned int, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed int, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long long, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long long, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)
template<typename T >
std::add_const< T >::type &	as_const (T &t)
template<typename F , typename Impl >
::testing::Action< F >	MakeAction ()
template<typename F , typename Impl >
::testing::Action< F >	MakeAction (std::shared_ptr< Impl > impl)
constexpr bool	PrefixOf (const char *a, const char *b)
template<int N, int M>
constexpr bool	StartsWith (const char(&prefix)[N], const char(&str)[M])
template<int N, int M>
constexpr bool	EndsWith (const char(&suffix)[N], const char(&str)[M])
template<int N, int M>
constexpr bool	Equals (const char(&a)[N], const char(&b)[M])
template<int N>
constexpr bool	ValidateSpec (const char(&spec)[N])
template<typename F , typename... Args>
auto	InvokeArgument (F f, Args... args) -> decltype(f(args...))
template<typename T >
std::true_type	StrictnessModifierProbe (const NiceMock< T > &)
template<typename T >
std::true_type	StrictnessModifierProbe (const NaggyMock< T > &)
template<typename T >
std::true_type	StrictnessModifierProbe (const StrictMock< T > &)
std::false_type	StrictnessModifierProbe (...)
template<typename T >
constexpr bool	HasStrictnessModifier ()
GTEST_API_ std::string	JoinAsKeyValueTuple (const std::vector< const char * > &names, const Strings &values)
GTEST_API_ std::string	ConvertIdentifierNameToWords (const char *id_name)
template<typename Pointer >
const Pointer::element_type *	GetRawPointer (const Pointer &p)
template<typename Element >
const Element *	GetRawPointer (const std::reference_wrapper< Element > &r)
template<typename Element >
Element *	GetRawPointer (Element *p)
	GMOCK_DECLARE_KIND_ (bool, kBool)
	GMOCK_DECLARE_KIND_ (char, kInteger)
	GMOCK_DECLARE_KIND_ (signed char, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)
	GMOCK_DECLARE_KIND_ (short, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned short, kInteger)
	GMOCK_DECLARE_KIND_ (int, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned int, kInteger)
	GMOCK_DECLARE_KIND_ (long, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned long, kInteger)
	GMOCK_DECLARE_KIND_ (long long, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned long long, kInteger)
	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)
	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)
GTEST_API_ FailureReporterInterface *	GetFailureReporter ()
void	Assert (bool condition, const char *file, int line, const std::string &msg)
void	Assert (bool condition, const char *file, int line)
void	Expect (bool condition, const char *file, int line, const std::string &msg)
void	Expect (bool condition, const char *file, int line)
GTEST_API_ bool	LogIsVisible (LogSeverity severity)
GTEST_API_ void	Log (LogSeverity severity, const std::string &message, int stack_frames_to_skip)
GTEST_API_ WithoutMatchers	GetWithoutMatchers ()
template<typename T >
T	Invalid ()
GTEST_API_ void	IllegalDoDefault (const char *file, int line)
template<typename F , typename Tuple , size_t... Idx>
auto	ApplyImpl (F &&f, Tuple &&args, IndexSequence< Idx... >) -> decltype(std::forward< F >(f)(std::get< Idx >(std::forward< Tuple >(args))...))
template<typename F , typename Tuple >
auto	Apply (F &&f, Tuple &&args) -> decltype(ApplyImpl(std::forward< F >(f), std::forward< Tuple >(args), MakeIndexSequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >()))
bool	Base64Unescape (const std::string &encoded, std::string *decoded)
static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)
constexpr char	UndoWebSafeEncoding (char c)
constexpr char	UnBase64Impl (char c, const char *const base64, char carry)
template<size_t... I>
constexpr std::array< char, 256 >	UnBase64Impl (IndexSequence< I... >, const char *const base64)
constexpr std::array< char, 256 >	UnBase64 (const char *const base64)
GTEST_API_ std::string	FormatMatcherDescription (bool negation, const char *matcher_name, const std::vector< const char * > &param_names, const Strings &param_values)
GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)
static void	LogElementMatcherPairVec (const ElementMatcherPairs &pairs, ::std::ostream *stream)
GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)
GTEST_API_ void	LogWithLocation (testing::internal::LogSeverity severity, const char *file, int line, const std::string &message)
void	ReportUninterestingCall (CallReaction reaction, const std::string &msg)
static CallReaction	intToCallReaction (int mock_behavior)
static const char *	ParseGoogleMockFlagValue (const char *str, const char *flag_name, bool def_optional)
static bool	ParseGoogleMockFlag (const char *str, const char *flag_name, bool *value)
template<typename String >
static bool	ParseGoogleMockFlag (const char *str, const char *flag_name, String *value)
static bool	ParseGoogleMockFlag (const char *str, const char *flag_name, int32_t *value)
template<typename CharType >
void	InitGoogleMockImpl (int *argc, CharType **argv)
template<typename T >
std::string	StreamableToString (const T &streamable)
template<typename T >
void	UniversalPrint (const T &value, ::std::ostream *os)
GTEST_API_ void	PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ::std::ostream *os)
template<typename T >
void	PrintWithFallback (const T &value, ::std::ostream *os)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char16_t)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char32_t)
	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)
	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char16_t, ::std::u16string)
	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char32_t, ::std::u32string)
template<typename T1 , typename T2 >
std::string	FormatForComparisonFailureMessage (const T1 &value, const T2 &)
template<typename T >
void	PrintTo (const T &value, ::std::ostream *os)
GTEST_API_ void	PrintTo (unsigned char c, ::std::ostream *os)
GTEST_API_ void	PrintTo (signed char c, ::std::ostream *os)
void	PrintTo (char c, ::std::ostream *os)
void	PrintTo (bool x, ::std::ostream *os)
GTEST_API_ void	PrintTo (wchar_t wc, ::std::ostream *os)
GTEST_API_ void	PrintTo (char32_t c, ::std::ostream *os)
void	PrintTo (char16_t c, ::std::ostream *os)
template<typename FloatType >
int	AppropriateResolution (FloatType val)
void	PrintTo (float f, ::std::ostream *os)
void	PrintTo (double d, ::std::ostream *os)
GTEST_API_ void	PrintTo (const char *s, ::std::ostream *os)
void	PrintTo (char *s, ::std::ostream *os)
void	PrintTo (const signed char *s, ::std::ostream *os)
void	PrintTo (signed char *s, ::std::ostream *os)
void	PrintTo (const unsigned char *s, ::std::ostream *os)
void	PrintTo (unsigned char *s, ::std::ostream *os)
GTEST_API_ void	PrintTo (const char16_t *s, ::std::ostream *os)
void	PrintTo (char16_t *s, ::std::ostream *os)
GTEST_API_ void	PrintTo (const char32_t *s, ::std::ostream *os)
void	PrintTo (char32_t *s, ::std::ostream *os)
GTEST_API_ void	PrintTo (const wchar_t *s, ::std::ostream *os)
void	PrintTo (wchar_t *s, ::std::ostream *os)
template<typename T >
void	PrintRawArrayTo (const T a[], size_t count, ::std::ostream *os)
GTEST_API_ void	PrintStringTo (const ::std::string &s, ::std::ostream *os)
void	PrintTo (const ::std::string &s, ::std::ostream *os)
GTEST_API_ void	PrintU16StringTo (const ::std::u16string &s, ::std::ostream *os)
void	PrintTo (const ::std::u16string &s, ::std::ostream *os)
GTEST_API_ void	PrintU32StringTo (const ::std::u32string &s, ::std::ostream *os)
void	PrintTo (const ::std::u32string &s, ::std::ostream *os)
void	PrintTo (std::nullptr_t, ::std::ostream *os)
template<typename T >
void	PrintTo (std::reference_wrapper< T > ref, ::std::ostream *os)
const void *	VoidifyPointer (const void *p)
const void *	VoidifyPointer (volatile const void *p)
template<typename T , typename Ptr >
void	PrintSmartPointer (const Ptr &ptr, std::ostream *os, char)
template<typename T , typename Ptr , typename = typename std::enable_if<!std::is_void<T>::value && !std::is_array<T>::value>::type>
void	PrintSmartPointer (const Ptr &ptr, std::ostream *os, int)
template<typename T , typename D >
void	PrintTo (const std::unique_ptr< T, D > &ptr, std::ostream *os)
template<typename T >
void	PrintTo (const std::shared_ptr< T > &ptr, std::ostream *os)
template<typename T >
void	PrintTupleTo (const T &, std::integral_constant< size_t, 0 >, ::std::ostream *)
template<typename T , size_t I>
void	PrintTupleTo (const T &t, std::integral_constant< size_t, I >, ::std::ostream *os)
template<typename... Types>
void	PrintTo (const ::std::tuple< Types... > &t, ::std::ostream *os)
template<typename T1 , typename T2 >
void	PrintTo (const ::std::pair< T1, T2 > &value, ::std::ostream *os)
template<typename T >
void	UniversalPrintArray (const T *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const char *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const char16_t *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const char32_t *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const wchar_t *begin, size_t len, ::std::ostream *os)
template<typename T >
void	UniversalTersePrint (const T &value, ::std::ostream *os)
template<typename Tuple >
void	TersePrintPrefixToStrings (const Tuple &, std::integral_constant< size_t, 0 >, Strings *)
template<typename Tuple , size_t I>
void	TersePrintPrefixToStrings (const Tuple &t, std::integral_constant< size_t, I >, Strings *strings)
template<typename Tuple >
Strings	UniversalTersePrintTupleFieldsToStrings (const Tuple &value)
class UnitTestImpl *	GetUnitTestImpl ()
void	ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
std::set< std::string > *	GetIgnoredParameterizedTestSuites ()
template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQFailure (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
bool	operator== (faketype, faketype)
bool	operator!= (faketype, faketype)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperOpFailure (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
GTEST_API_ AssertionResult	CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRCASEEQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ AssertionResult	CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
template<typename RawType >
AssertionResult	CmpHelperFloatingPointEQ (const char *lhs_expression, const char *rhs_expression, RawType lhs_value, RawType rhs_value)
GTEST_API_ AssertionResult	DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
GTEST_API_ std::string	AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
GTEST_API_ AssertionResult	EqFailure (const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
GTEST_API_ std::string	GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
template<typename T >
TypeId	GetTypeId ()
GTEST_API_ TypeId	GetTestTypeId ()
SetUpTearDownSuiteFuncType	GetNotDefaultOrNull (SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def)
GTEST_API_ TestInfo *	MakeAndRegisterTestInfo (const char *test_suite_name, const char *name, const char *type_param, const char *value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, TearDownTestSuiteFunc tear_down_tc, TestFactoryBase *factory)
GTEST_API_ bool	SkipPrefix (const char *prefix, const char **pstr)
	GTEST_DISABLE_MSC_WARNINGS_PUSH_ (4251) class GTEST_API_ TypedTestSuitePState
const char *	SkipComma (const char *str)
std::string	GetPrefixUntilComma (const char *str)
void	SplitString (const ::std::string &str, char delimiter, ::std::vector<::std::string > *dest)
template<typename NameGenerator >
void	GenerateNamesRecursively (internal::None, std::vector< std::string > *, int)
template<typename NameGenerator , typename Types >
void	GenerateNamesRecursively (Types, std::vector< std::string > *result, int i)
template<typename NameGenerator , typename Types >
std::vector< std::string >	GenerateNames ()
GTEST_API_ void	RegisterTypeParameterizedTestSuite (const char *test_suite_name, CodeLocation code_location)
GTEST_API_ void	RegisterTypeParameterizedTestSuiteInstantiation (const char *case_name)
GTEST_API_ std::string	GetCurrentOsStackTraceExceptTop (int skip_count)
GTEST_API_ bool	AlwaysTrue ()
bool	AlwaysFalse ()
template<class C , class Iterator = decltype(::std::declval<const C&>().begin()), class = decltype(::std::declval<const C&>().end()), class = decltype(++::std::declval<Iterator&>()), class = decltype(*::std::declval<Iterator>()), class = typename C::const_iterator>
IsContainer	IsContainerTest (int)
template<class C >
IsNotContainer	IsContainerTest (long)
template<typename T , typename U >
bool	ArrayEq (const T *lhs, size_t size, const U *rhs)
template<typename T , typename U >
bool	ArrayEq (const T &lhs, const U &rhs)
template<typename T , typename U , size_t N>
bool	ArrayEq (const T(&lhs)[N], const U(&rhs)[N])
template<typename Iter , typename Element >
Iter	ArrayAwareFind (Iter begin, Iter end, const Element &elem)
template<typename T , typename U >
void	CopyArray (const T *from, size_t size, U *to)
template<typename T , typename U >
void	CopyArray (const T &from, U *to)
template<typename T , typename U , size_t N>
void	CopyArray (const T(&from)[N], U(*to)[N])
	GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TEST_SUITE_P") const expr bool InstantiateTestCase_P_IsDeprecated()
	GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE_P is deprecated, please use " "TYPED_TEST_SUITE_P") const expr bool TypedTestCase_P_IsDeprecated()
	GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE is deprecated, please use " "TYPED_TEST_SUITE") const expr bool TypedTestCaseIsDeprecated()
	GTEST_INTERNAL_DEPRECATED ("REGISTER_TYPED_TEST_CASE_P is deprecated, please use " "REGISTER_TYPED_TEST_SUITE_P") const expr bool RegisterTypedTestCase_P_IsDeprecated()
	GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TYPED_TEST_SUITE_P") const expr bool InstantiateTypedTestCase_P_IsDeprecated()
GTEST_API_ void	ReportInvalidTestSuiteType (const char *test_suite_name, CodeLocation code_location)
template<class ParamType >
std::string	DefaultParamName (const TestParamInfo< ParamType > &info)
template<typename T = int>
void	TestNotEmpty ()
template<typename T = int>
void	TestNotEmpty (const T &)
GTEST_API_ void	InsertSyntheticTestCase (const std::string &name, CodeLocation location, bool has_test_p)
GTEST_API_ bool	IsTrue (bool condition)
GTEST_API_::std::string	FormatFileLocation (const char *file, int line)
GTEST_API_::std::string	FormatCompilerIndependentFileLocation (const char *file, int line)
void	LogToStderr ()
void	FlushInfoLog ()
template<typename To >
To	ImplicitCast_ (To x)
template<class Derived , class Base >
Derived *	CheckedDowncastToActualType (Base *base)
GTEST_API_ void	CaptureStdout ()
GTEST_API_ std::string	GetCapturedStdout ()
GTEST_API_ void	CaptureStderr ()
GTEST_API_ std::string	GetCapturedStderr ()
GTEST_API_ size_t	GetFileSize (FILE *file)
GTEST_API_ std::string	ReadEntireFile (FILE *file)
GTEST_API_ std::vector< std::string >	GetArgvs ()
GTEST_API_ size_t	GetThreadCount ()
bool	IsAlpha (char ch)
bool	IsAlNum (char ch)
bool	IsDigit (char ch)
bool	IsLower (char ch)
bool	IsSpace (char ch)
bool	IsUpper (char ch)
bool	IsXDigit (char ch)
bool	IsXDigit (char16_t ch)
bool	IsXDigit (char32_t ch)
bool	IsXDigit (wchar_t ch)
char	ToLower (char ch)
char	ToUpper (char ch)
std::string	StripTrailingSpaces (std::string str)
GTEST_API_ bool	ParseInt32 (const Message &src_text, const char *str, int32_t *value)
bool	BoolFromGTestEnv (const char *flag, bool default_val)
GTEST_API_ int32_t	Int32FromGTestEnv (const char *flag, int32_t default_val)
std::string	OutputFlagAlsoCheckEnvVar ()
const char *	StringFromGTestEnv (const char *flag, const char *default_val)
GTEST_API_ std::string	StringStreamToString (::std::stringstream *stream)
std::string	CanonicalizeForStdLibVersioning (std::string s)
template<typename T >
std::string	GetTypeName ()
GTEST_API_ TimeInMillis	GetTimeInMillis ()
GTEST_API_ bool	ShouldUseColor (bool stdout_is_tty)
GTEST_API_ std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)
GTEST_API_ std::string	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
GTEST_API_ bool	ParseFlag (const char *str, const char *flag, int32_t *value)
int	GetRandomSeedFromFlag (int32_t random_seed_flag)
int	GetNextRandomSeed (int seed)
GTEST_API_ std::string	CodePointToUtf8 (uint32_t code_point)
GTEST_API_ std::string	WideStringToUtf8 (const wchar_t *str, int num_chars)
void	WriteToShardStatusFileIfNeeded ()
GTEST_API_ bool	ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
GTEST_API_ int32_t	Int32FromEnvOrDie (const char *env_var, int32_t default_val)
GTEST_API_ bool	ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
template<class Container , typename Predicate >
int	CountIf (const Container &c, Predicate predicate)
template<class Container , typename Functor >
void	ForEach (const Container &c, Functor functor)
template<typename E >
E	GetElementOr (const std::vector< E > &v, int i, E default_value)
template<typename E >
void	ShuffleRange (internal::Random *random, int begin, int end, std::vector< E > *v)
template<typename E >
void	Shuffle (internal::Random *random, std::vector< E > *v)
template<typename T >
static void	Delete (T *x)
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
static std::string	FlagToEnvVar (const char *flag)
void	PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ostream *os)
bool	IsPrintableAscii (char32_t c)
template<typename Char >
static CharFormat	PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (char32_t c, ostream *os)
static const char *	GetCharWidthPrefix (char)
static const char *	GetCharWidthPrefix (signed char)
static const char *	GetCharWidthPrefix (unsigned char)
static const char *	GetCharWidthPrefix (char16_t)
static const char *	GetCharWidthPrefix (char32_t)
static const char *	GetCharWidthPrefix (wchar_t)
static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (char16_t c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)
template<typename Char >
void	PrintCharAndCodeTo (Char c, ostream *os)
void	PrintTo (wchar_t wc, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ CharFormat	PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
void	UniversalPrintArray (const char *begin, size_t len, ostream *os)
void	UniversalPrintArray (const char16_t *begin, size_t len, ostream *os)
void	UniversalPrintArray (const char32_t *begin, size_t len, ostream *os)
void	UniversalPrintArray (const wchar_t *begin, size_t len, ostream *os)
void	PrintTo (const char *s, ostream *os)
void	PrintTo (const char16_t *s, ostream *os)
void	PrintTo (const char32_t *s, ostream *os)
void	PrintTo (const wchar_t *s, ostream *os)
void	PrintStringTo (const ::std::string &s, ostream *os)
void	PrintU16StringTo (const ::std::u16string &s, ostream *os)
void	PrintU32StringTo (const ::std::u32string &s, ostream *os)
static const char *	SkipSpaces (const char *str)
static std::vector< std::string >	SplitIntoTestNames (const char *src)
static bool	GTestIsInitialized ()
static int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)
static bool	TestSuitePassed (const TestSuite *test_suite)
static bool	TestSuiteFailed (const TestSuite *test_suite)
static bool	ShouldRunTestSuite (const TestSuite *test_suite)
static bool	PatternMatchesString (const std::string &name_str, const char *pattern, const char *pattern_end)
static AssertionResult	HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const std::string &substr)
void	SplitString (const ::std::string &str, char delimiter, ::std::vector< ::std::string > *dest)
template<typename RawType >
AssertionResult	FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
uint32_t	ChopLowBits (uint32_t *bits, int n)
bool	IsUtf16SurrogatePair (wchar_t first, wchar_t second)
uint32_t	CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
template<class T , typename Result >
Result	HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
template<class T , typename Result >
Result	HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
static std::string	PrintTestPartResultToString (const TestPartResult &test_part_result)
static void	PrintTestPartResult (const TestPartResult &test_part_result)
static const char *	GetAnsiColorCode (GTestColor color)
static void	ColoredPrintf (GTestColor color, const char *fmt,...)
static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)
static void	SetUpEnvironment (Environment *env)
static void	TearDownEnvironment (Environment *env)
static void	PrintOnOneLine (const char *str, int max_length)
static const char *	ParseFlagValue (const char *str, const char *flag_name, bool def_optional)
static bool	ParseFlag (const char *str, const char *flag_name, bool *value)
template<typename String >
static bool	ParseFlag (const char *str, const char *flag_name, String *value)
static bool	HasGoogleTestFlagPrefix (const char *str)
static void	PrintColorEncoded (const char *str)
static bool	ParseGoogleTestFlag (const char *const arg)
template<typename CharType >
void	ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
template<typename CharType >
void	InitGoogleTestImpl (int *argc, CharType **argv)
	TEST_F (ListenerTest, DoesFoo)
	TEST_F (ListenerTest, DoesBar)
	TEST (IsXDigitTest, WorksForNarrowAscii)
	TEST (IsXDigitTest, ReturnsFalseForNarrowNonAscii)
	TEST (IsXDigitTest, WorksForWideAscii)
	TEST (IsXDigitTest, ReturnsFalseForWideNonAscii)
	TEST (ImplicitCastTest, ConvertsPointers)
	TEST (ImplicitCastTest, CanUseInheritance)
	TEST (ImplicitCastTest, CanUseNonConstCastOperator)
	TEST (ImplicitCastTest, CanUseConstCastOperatorOnConstValues)
	TEST (ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately)
	TEST (ImplicitCastTest, CanUseImplicitConstructor)
	TEST (GtestCheckSyntaxTest, BehavesLikeASingleStatement)
	TEST (GtestCheckSyntaxTest, WorksWithSwitch)
	TEST (FormatFileLocationTest, FormatsFileLocation)
	TEST (FormatFileLocationTest, FormatsUnknownFile)
	TEST (FormatFileLocationTest, FormatsUknownLine)
	TEST (FormatFileLocationTest, FormatsUknownFileAndLine)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsFileLocation)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFile)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownLine)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine)
	TEST (GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads)
	TEST (GtestCheckDeathTest, DiesWithCorrectOutputOnFailure)
	TEST (RegexEngineSelectionTest, SelectsCorrectRegexEngine)
	TEST (CaptureTest, CapturesStdout)
	TEST (CaptureTest, CapturesStderr)
	TEST (CaptureTest, CapturesStdoutAndStderr)
	TEST (CaptureDeathTest, CannotReenterStdoutCapture)
	TEST (ThreadLocalTest, DefaultConstructorInitializesToDefaultValues)
	TEST (ThreadLocalTest, SingleParamConstructorInitializesToParam)
	TEST (ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion)
	TEST (ThreadLocalTest, GetAndPointerReturnSameValue)
	TEST (ThreadLocalTest, PointerAndConstPointerReturnSameValue)
	TYPED_TEST_SUITE (TestSuiteWithCommentTest, Types< int >)
	TYPED_TEST (TestSuiteWithCommentTest, Dummy)
	TEST (ApiTest, UnitTestImmutableAccessorsWork)
AssertionResult	IsNull (const char *str)
	TEST (ApiTest, TestSuiteImmutableAccessorsWork)
	TEST (ApiTest, TestSuiteDisabledAccessorsWork)
	TEST (ApiTest, DISABLED_Dummy1)
	TEST (DISABLED_Test, Dummy2)

Variables
const char	kInfoVerbosity [] = "info"
const char	kWarningVerbosity [] = "warning"
const char	kErrorVerbosity [] = "error"
static constexpr char	kBase64 []
static constexpr std::array< char, 256 >	kUnBase64 = UnBase64(kBase64)
GTEST_API_ ThreadLocal< Sequence * >	g_gmock_implicit_sequence
const char	kDeathTestStyleFlag [] = "death_test_style"
const char	kDeathTestUseFork [] = "death_test_use_fork"
const char	kInternalRunDeathTestFlag [] = "internal_run_death_test"
GTEST_API_ const char	kStackTraceMarker [] = "\nStack trace:\n"
constexpr BiggestInt	kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)()
GTEST_API_ const TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()
const int	kMaxRandomSeed = 99999
GTEST_API_ bool	g_help_flag = false
const char	kUnknownFile [] = "unknown file"
static ::std::vector< std::string >	g_argvs
constexpr uint32_t	kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1
constexpr uint32_t	kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1
constexpr uint32_t	kMaxCodePoint3
constexpr uint32_t	kMaxCodePoint4
static const char	kTypeParamLabel [] = "TypeParam"
static const char	kValueParamLabel [] = "GetParam()"
static const char	kColorEncodedHelpMessage []
const int	kTypedTestSuites = 1
const int	kTypedTests = 1

Typedef Documentation

BiggestInt

using testing::internal::BiggestInt = long long

call_result_t

template<typename F , typename... Args>

using testing::internal::call_result_t = decltype(std::declval<F>()(std::declval<Args>()...))

Double

typedef FloatingPoint<double> testing::internal::Double

Float

typedef FloatingPoint<float> testing::internal::Float

identity_t

template<typename T >

using testing::internal::identity_t = T

IndexSequenceFor

template<typename... T>

using testing::internal::IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type

is_callable_r

template<typename R , typename F , typename... Args>

using testing::internal::is_callable_r = is_callable_r_impl<void, R, F, Args...>

IsContainer

typedef int testing::internal::IsContainer

IsNotContainer

typedef char testing::internal::IsNotContainer

LosslessArithmeticConvertible

template<typename From , typename To >

using testing::internal::LosslessArithmeticConvertible

Initial value:

 
    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
                                      GMOCK_KIND_OF_(To), To>

LosslessArithmeticConvertibleImpl

template<TypeKind kFromKind, typename From , TypeKind kToKind, typename To >

using testing::internal::LosslessArithmeticConvertibleImpl

Initial value:

 std::integral_constant<
    bool,
    
      
      (kFromKind == kBool) ? true
      
      
    : (kFromKind != kToKind) ? false
    : (kFromKind == kInteger &&
       
       
      (((sizeof(From) < sizeof(To)) &&
        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
       
       
       ((sizeof(From) == sizeof(To)) &&
        (std::is_signed<From>::value == std::is_signed<To>::value)))
       ) ? true
      
      
    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
    : false
    
    >

MakeIndexSequence

template<size_t N>

using testing::internal::MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type

MutexLock

typedef GTestMutexLock testing::internal::MutexLock

ParameterizedTestCaseInfo

template<class TestCase >

using testing::internal::ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>

SetUpTearDownSuiteFuncType

using testing::internal::SetUpTearDownSuiteFuncType = void (*)()

SetUpTestSuiteFunc

using testing::internal::SetUpTestSuiteFunc = void (*)()

Strings

typedef ::std::vector<::std::string> testing::internal::Strings

TearDownTestSuiteFunc

using testing::internal::TearDownTestSuiteFunc = void (*)()

TimeInMillis

using testing::internal::TimeInMillis = int64_t

TupleElement

template<size_t I, typename T >

using testing::internal::TupleElement = typename std::tuple_element<I, T>::type

TypedTestCasePState

using testing::internal::TypedTestCasePState = TypedTestSuitePState

TypeId

typedef const void* testing::internal::TypeId

void_t

template<typename... >

using testing::internal::void_t = void

Enumeration Type Documentation

CharFormat

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape

GTestLogSeverity

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

LogSeverity

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning

TypeKind

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

Function Documentation

AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

AlwaysTrue()

bool testing::internal::AlwaysTrue

(

)

AppendUserMessage()

std::string testing::internal::AppendUserMessage	(	const std::string &	gtest_msg,
		const Message &	user_msg )

Apply()

template<typename F , typename Tuple >

auto testing::internal::Apply	(	F &&	f,
		Tuple &&	args ) -> decltype(ApplyImpl( std::forward<F>(f), std::forward<Tuple>(args), MakeIndexSequence<std::tuple_size< typename std::remove_reference<Tuple>::type>::value>()))

ApplyImpl()

template<typename F , typename Tuple , size_t... Idx>

auto testing::internal::ApplyImpl	(	F &&	f,
		Tuple &&	args,
		IndexSequence< Idx... >	) -> decltype(std::forward<F>(f)( std::get<Idx>(std::forward<Tuple>(args))...))

AppropriateResolution()

template<typename FloatType >

int testing::internal::AppropriateResolution

(

FloatType

val

)

ArrayAwareFind()

template<typename Iter , typename Element >

Iter testing::internal::ArrayAwareFind	(	Iter	begin,
		Iter	end,
		const Element &	elem )

ArrayEq() [1/3]

template<typename T , typename U >

bool testing::internal::ArrayEq ( const T & lhs, const U & rhs )

inline

ArrayEq() [2/3]

template<typename T , typename U >

bool testing::internal::ArrayEq	(	const T *	lhs,
		size_t	size,
		const U *	rhs )

ArrayEq() [3/3]

template<typename T , typename U , size_t N>

bool testing::internal::ArrayEq ( const T(&) lhs[N], const U(&) rhs[N] )

inline

as_const()

template<typename T >

std::add_const< T >::type & testing::internal::as_const

(

T &

t

)

Assert() [1/2]

void testing::internal::Assert ( bool condition, const char * file, int line )

inline

Assert() [2/2]

void testing::internal::Assert ( bool condition, const char * file, int line, const std::string & msg )

inline

Base64Unescape()

bool testing::internal::Base64Unescape	(	const std::string &	encoded,
		std::string *	decoded )

BoolFromGTestEnv()

bool testing::internal::BoolFromGTestEnv	(	const char *	flag,
		bool	default_val )

CanonicalizeForStdLibVersioning()

std::string testing::internal::CanonicalizeForStdLibVersioning ( std::string s )

inline

CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr

(

)

CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout

(

)

CheckedDowncastToActualType()

template<class Derived , class Base >

Derived * testing::internal::CheckedDowncastToActualType

(

Base *

base

)

ChopLowBits()

uint32_t testing::internal::ChopLowBits ( uint32_t * bits, int n )

inline

CmpHelperEQ()

template<typename T1 , typename T2 >

AssertionResult testing::internal::CmpHelperEQ	(	const char *	lhs_expression,
		const char *	rhs_expression,
		const T1 &	lhs,
		const T2 &	rhs )

CmpHelperEQFailure()

template<typename T1 , typename T2 >

AssertionResult testing::internal::CmpHelperEQFailure	(	const char *	lhs_expression,
		const char *	rhs_expression,
		const T1 &	lhs,
		const T2 &	rhs )

CmpHelperFloatingPointEQ()

template<typename RawType >

AssertionResult testing::internal::CmpHelperFloatingPointEQ	(	const char *	lhs_expression,
		const char *	rhs_expression,
		RawType	lhs_value,
		RawType	rhs_value )

CmpHelperOpFailure()

template<typename T1 , typename T2 >

AssertionResult testing::internal::CmpHelperOpFailure	(	const char *	expr1,
		const char *	expr2,
		const T1 &	val1,
		const T2 &	val2,
		const char *	op )

CmpHelperSTRCASEEQ()

AssertionResult testing::internal::CmpHelperSTRCASEEQ	(	const char *	s1_expression,
		const char *	s2_expression,
		const char *	s1,
		const char *	s2 )

CmpHelperSTRCASENE()

AssertionResult testing::internal::CmpHelperSTRCASENE	(	const char *	s1_expression,
		const char *	s2_expression,
		const char *	s1,
		const char *	s2 )

CmpHelperSTREQ() [1/2]

AssertionResult testing::internal::CmpHelperSTREQ	(	const char *	s1_expression,
		const char *	s2_expression,
		const char *	s1,
		const char *	s2 )

CmpHelperSTREQ() [2/2]

AssertionResult testing::internal::CmpHelperSTREQ	(	const char *	s1_expression,
		const char *	s2_expression,
		const wchar_t *	s1,
		const wchar_t *	s2 )

CmpHelperSTRNE() [1/2]

AssertionResult testing::internal::CmpHelperSTRNE	(	const char *	s1_expression,
		const char *	s2_expression,
		const char *	s1,
		const char *	s2 )

CmpHelperSTRNE() [2/2]

AssertionResult testing::internal::CmpHelperSTRNE	(	const char *	s1_expression,
		const char *	s2_expression,
		const wchar_t *	s1,
		const wchar_t *	s2 )

CodePointToUtf8()

std::string testing::internal::CodePointToUtf8

(

uint32_t

code_point

)

ColoredPrintf()

static void testing::internal::ColoredPrintf ( GTestColor color, const char * fmt, ... )

static

ConvertIdentifierNameToWords()

GTEST_API_ std::string testing::internal::ConvertIdentifierNameToWords

(

const char *

id_name

)

CopyArray() [1/3]

template<typename T , typename U >

void testing::internal::CopyArray ( const T & from, U * to )

inline

CopyArray() [2/3]

template<typename T , typename U >

void testing::internal::CopyArray	(	const T *	from,
		size_t	size,
		U *	to )

CopyArray() [3/3]

template<typename T , typename U , size_t N>

void testing::internal::CopyArray ( const T(&) from[N], U(*) to[N] )

inline

CountIf()

template<class Container , typename Predicate >

int testing::internal::CountIf ( const Container & c, Predicate predicate )

inline

CreateCodePointFromUtf16SurrogatePair()

uint32_t testing::internal::CreateCodePointFromUtf16SurrogatePair ( wchar_t first, wchar_t second )

inline

DefaultParamName()

template<class ParamType >

std::string testing::internal::DefaultParamName

(

const TestParamInfo< ParamType > &

info

)

Delete()

template<typename T >

static void testing::internal::Delete ( T * x )

static

DoubleNearPredFormat()

AssertionResult testing::internal::DoubleNearPredFormat	(	const char *	expr1,
		const char *	expr2,
		const char *	abs_error_expr,
		double	val1,
		double	val2,
		double	abs_error )

EndsWith()

template<int N, int M>

bool testing::internal::EndsWith ( const char(&) suffix[N], const char(&) str[M] )

constexpr

EqFailure()

AssertionResult testing::internal::EqFailure	(	const char *	expected_expression,
		const char *	actual_expression,
		const std::string &	expected_value,
		const std::string &	actual_value,
		bool	ignoring_case )

Equals()

template<int N, int M>

bool testing::internal::Equals ( const char(&) a[N], const char(&) b[M] )

constexpr

Expect() [1/2]

void testing::internal::Expect ( bool condition, const char * file, int line )

inline

Expect() [2/2]

void testing::internal::Expect ( bool condition, const char * file, int line, const std::string & msg )

inline

FindMaxBipartiteMatching()

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching

(

const MatchMatrix &

g

)

FlagToEnvVar()

static std::string testing::internal::FlagToEnvVar ( const char * flag )

static

FloatingPointLE()

template<typename RawType >

AssertionResult testing::internal::FloatingPointLE	(	const char *	expr1,
		const char *	expr2,
		RawType	val1,
		RawType	val2 )

FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

ForEach()

template<class Container , typename Functor >

void testing::internal::ForEach	(	const Container &	c,
		Functor	functor )

FormatCompilerIndependentFileLocation()

GTEST_API_::std::string testing::internal::FormatCompilerIndependentFileLocation	(	const char *	file,
		int	line )

FormatEpochTimeInMillisAsIso8601()

GTEST_API_ std::string testing::internal::FormatEpochTimeInMillisAsIso8601

(

TimeInMillis

ms

)

FormatFileLocation()

GTEST_API_::std::string testing::internal::FormatFileLocation	(	const char *	file,
		int	line )

FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >

std::string testing::internal::FormatForComparisonFailureMessage	(	const T1 &	value,
		const T2 &	)

FormatMatcherDescription()

GTEST_API_ std::string testing::internal::FormatMatcherDescription	(	bool	negation,
		const char *	matcher_name,
		const std::vector< const char * > &	param_names,
		const Strings &	param_values )

FormatTimeInMillisAsSeconds()

GTEST_API_ std::string testing::internal::FormatTimeInMillisAsSeconds

(

TimeInMillis

ms

)

GenerateNames()

template<typename NameGenerator , typename Types >

std::vector< std::string > testing::internal::GenerateNames

(

)

GenerateNamesRecursively() [1/2]

template<typename NameGenerator >

void testing::internal::GenerateNamesRecursively	(	internal::None	,
		std::vector< std::string > *	,
		int	)

GenerateNamesRecursively() [2/2]

template<typename NameGenerator , typename Types >

void testing::internal::GenerateNamesRecursively	(	Types	,
		std::vector< std::string > *	result,
		int	i )

GetAnsiColorCode()

static const char * testing::internal::GetAnsiColorCode ( GTestColor color )

static

GetArgvs()

std::vector< std::string > testing::internal::GetArgvs

(

)

GetBoolAssertionFailureMessage()

std::string testing::internal::GetBoolAssertionFailureMessage	(	const AssertionResult &	assertion_result,
		const char *	expression_text,
		const char *	actual_predicate_value,
		const char *	expected_predicate_value )

GetCapturedStderr()

GTEST_API_ std::string testing::internal::GetCapturedStderr

(

)

GetCapturedStdout()

GTEST_API_ std::string testing::internal::GetCapturedStdout

(

)

GetCharWidthPrefix() [1/6]

static const char * testing::internal::GetCharWidthPrefix ( char )

static

GetCharWidthPrefix() [2/6]

static const char * testing::internal::GetCharWidthPrefix ( char16_t )

static

GetCharWidthPrefix() [3/6]

static const char * testing::internal::GetCharWidthPrefix ( char32_t )

static

GetCharWidthPrefix() [4/6]

static const char * testing::internal::GetCharWidthPrefix ( signed char )

static

GetCharWidthPrefix() [5/6]

static const char * testing::internal::GetCharWidthPrefix ( unsigned char )

static

GetCharWidthPrefix() [6/6]

static const char * testing::internal::GetCharWidthPrefix ( wchar_t )

static

GetCurrentOsStackTraceExceptTop()

GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_ std::string testing::internal::GetCurrentOsStackTraceExceptTop

(

int

skip_count

)

GetElementOr()

template<typename E >

E testing::internal::GetElementOr ( const std::vector< E > & v, int i, E default_value )

inline

GetFailureReporter()

GTEST_API_ FailureReporterInterface * testing::internal::GetFailureReporter

(

)

GetFileSize()

size_t testing::internal::GetFileSize

(

FILE *

file

)

GetIgnoredParameterizedTestSuites()

std::set< std::string > * testing::internal::GetIgnoredParameterizedTestSuites

(

)

GetNextRandomSeed()

int testing::internal::GetNextRandomSeed ( int seed )

inline

GetNotDefaultOrNull()

SetUpTearDownSuiteFuncType testing::internal::GetNotDefaultOrNull ( SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def )

inline

GetPrefixUntilComma()

std::string testing::internal::GetPrefixUntilComma ( const char * str )

inline

GetRandomSeedFromFlag()

int testing::internal::GetRandomSeedFromFlag ( int32_t random_seed_flag )

inline

GetRawPointer() [1/3]

template<typename Pointer >

const Pointer::element_type * testing::internal::GetRawPointer ( const Pointer & p )

inline

GetRawPointer() [2/3]

template<typename Element >

const Element * testing::internal::GetRawPointer ( const std::reference_wrapper< Element > & r )

inline

GetRawPointer() [3/3]

template<typename Element >

Element * testing::internal::GetRawPointer ( Element * p )

inline

GetTestTypeId()

TypeId testing::internal::GetTestTypeId

(

)

GetThreadCount()

size_t testing::internal::GetThreadCount

(

)

GetTimeInMillis()

TimeInMillis testing::internal::GetTimeInMillis

(

)

GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId

(

)

GetTypeName()

template<typename T >

std::string testing::internal::GetTypeName

(

)

GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

GetWithoutMatchers()

GTEST_API_ WithoutMatchers testing::internal::GetWithoutMatchers

(

)

GMOCK_DECLARE_KIND_() [1/16]

testing::internal::GMOCK_DECLARE_KIND_	(	bool	,
		kBool	)

GMOCK_DECLARE_KIND_() [2/16]

testing::internal::GMOCK_DECLARE_KIND_	(	char	,
		kInteger	)

GMOCK_DECLARE_KIND_() [3/16]

testing::internal::GMOCK_DECLARE_KIND_	(	double	,
		kFloatingPoint	)

GMOCK_DECLARE_KIND_() [4/16]

testing::internal::GMOCK_DECLARE_KIND_	(	float	,
		kFloatingPoint	)

GMOCK_DECLARE_KIND_() [5/16]

testing::internal::GMOCK_DECLARE_KIND_	(	int	,
		kInteger	)

GMOCK_DECLARE_KIND_() [6/16]

testing::internal::GMOCK_DECLARE_KIND_	(	long double	,
		kFloatingPoint	)

GMOCK_DECLARE_KIND_() [7/16]

testing::internal::GMOCK_DECLARE_KIND_	(	long long	,
		kInteger	)

GMOCK_DECLARE_KIND_() [8/16]

testing::internal::GMOCK_DECLARE_KIND_	(	long	,
		kInteger	)

GMOCK_DECLARE_KIND_() [9/16]

testing::internal::GMOCK_DECLARE_KIND_	(	short	,
		kInteger	)

GMOCK_DECLARE_KIND_() [10/16]

testing::internal::GMOCK_DECLARE_KIND_	(	signed char	,
		kInteger	)

GMOCK_DECLARE_KIND_() [11/16]

testing::internal::GMOCK_DECLARE_KIND_	(	unsigned char	,
		kInteger	)

GMOCK_DECLARE_KIND_() [12/16]

testing::internal::GMOCK_DECLARE_KIND_	(	unsigned int	,
		kInteger	)

GMOCK_DECLARE_KIND_() [13/16]

testing::internal::GMOCK_DECLARE_KIND_	(	unsigned long long	,
		kInteger	)

GMOCK_DECLARE_KIND_() [14/16]

testing::internal::GMOCK_DECLARE_KIND_	(	unsigned long	,
		kInteger	)

GMOCK_DECLARE_KIND_() [15/16]

testing::internal::GMOCK_DECLARE_KIND_	(	unsigned short	,
		kInteger	)

GMOCK_DECLARE_KIND_() [16/16]

testing::internal::GMOCK_DECLARE_KIND_	(	wchar_t	,
		kInteger	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	::std::string	,
		""	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	bool	,
		false	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	char	,
		'\0'	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	double	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	float	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	signed char	,
		'\0'	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	signed int	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	signed long long	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	signed long	,
		0L	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	signed short	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	unsigned char	,
		'\0'	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	unsigned int	,
		0U	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	unsigned long long	,
		0	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	unsigned long	,
		0UL	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [15/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	unsigned short	,
		0U	)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [16/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_

(

void

)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [17/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_	(	wchar_t	,
		0U	)

GTEST_DEFINE_STATIC_MUTEX_() [1/2]

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_

(

g_gmock_mutex

)

GTEST_DEFINE_STATIC_MUTEX_() [2/2]

static testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_log_mutex )

static

GTEST_DISABLE_MSC_WARNINGS_PUSH_()

testing::internal::GTEST_DISABLE_MSC_WARNINGS_PUSH_

(

4251

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

char

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

char16_t

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [3/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

char32_t

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [4/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

wchar_t

)

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [1/3]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(	char	,
		::std::string	)

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [2/3]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(	char16_t	,
		::std::u16string	)

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [3/3]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(	char32_t	,
		::std::u32string	)

GTEST_INTERNAL_DEPRECATED() [1/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"INSTANTIATE_TEST_CASE_P is	deprecated,
		please use " "INSTANTIATE_TEST_SUITE_P"	) const

GTEST_INTERNAL_DEPRECATED() [2/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"INSTANTIATE_TYPED_TEST_CASE_P is	deprecated,
		please use " "INSTANTIATE_TYPED_TEST_SUITE_P"	) const

GTEST_INTERNAL_DEPRECATED() [3/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"REGISTER_TYPED_TEST_CASE_P is	deprecated,
		please use " "REGISTER_TYPED_TEST_SUITE_P"	) const

GTEST_INTERNAL_DEPRECATED() [4/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"TYPED_TEST_CASE is	deprecated,
		please use " "TYPED_TEST_SUITE"	) const

GTEST_INTERNAL_DEPRECATED() [5/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"TYPED_TEST_CASE_P is	deprecated,
		please use " "TYPED_TEST_SUITE_P"	) const

GTestIsInitialized()

static bool testing::internal::GTestIsInitialized ( )

static

HandleExceptionsInMethodIfSupported()

template<class T , typename Result >

Result testing::internal::HandleExceptionsInMethodIfSupported	(	T *	object,
		Result(T::*	method )(),
		const char *	location )

HandleSehExceptionsInMethodIfSupported()

template<class T , typename Result >

Result testing::internal::HandleSehExceptionsInMethodIfSupported	(	T *	object,
		Result(T::*	method )(),
		const char *	location )

HasGoogleTestFlagPrefix()

static bool testing::internal::HasGoogleTestFlagPrefix ( const char * str )

static

HasOneFailure()

static AssertionResult testing::internal::HasOneFailure ( const char * , const char * , const char * , const TestPartResultArray & results, TestPartResult::Type type, const std::string & substr )

static

HasStrictnessModifier()

template<typename T >

bool testing::internal::HasStrictnessModifier ( )

constexpr

IllegalDoDefault()

GTEST_API_ void testing::internal::IllegalDoDefault	(	const char *	file,
		int	line )

ImplicitCast_()

template<typename To >

To testing::internal::ImplicitCast_ ( To x )

inline

InitGoogleMockImpl()

template<typename CharType >

void testing::internal::InitGoogleMockImpl	(	int *	argc,
		CharType **	argv )

InitGoogleTestImpl()

template<typename CharType >

void testing::internal::InitGoogleTestImpl	(	int *	argc,
		CharType **	argv )

InsertSyntheticTestCase()

void testing::internal::InsertSyntheticTestCase	(	const std::string &	name,
		CodeLocation	location,
		bool	has_test_p )

Int32FromEnvOrDie()

int32_t testing::internal::Int32FromEnvOrDie	(	const char *	env_var,
		int32_t	default_val )

Int32FromGTestEnv()

int32_t testing::internal::Int32FromGTestEnv	(	const char *	flag,
		int32_t	default_val )

intToCallReaction()

static CallReaction testing::internal::intToCallReaction ( int mock_behavior )

static

Invalid()

template<typename T >

T testing::internal::Invalid ( )

inline

InvokeArgument()

template<typename F , typename... Args>

auto testing::internal::InvokeArgument	(	F	f,
		Args...	args ) -> decltype(f(args...))

IsAlNum()

bool testing::internal::IsAlNum ( char ch )

inline

IsAlpha()

bool testing::internal::IsAlpha ( char ch )

inline

IsContainerTest() [1/2]

template<class C , class Iterator = decltype(::std::declval<const C&>().begin()), class = decltype(::std::declval<const C&>().end()), class = decltype(++::std::declval<Iterator&>()), class = decltype(*::std::declval<Iterator>()), class = typename C::const_iterator>

IsContainer testing::internal::IsContainerTest

(

int

)

IsContainerTest() [2/2]

template<class C >

IsNotContainer testing::internal::IsContainerTest

(

long

)

IsDigit()

bool testing::internal::IsDigit ( char ch )

inline

IsLower()

bool testing::internal::IsLower ( char ch )

inline

IsNull()

AssertionResult testing::internal::IsNull

(

const char *

str

)

IsPrintableAscii()

bool testing::internal::IsPrintableAscii ( char32_t c )

inline

IsSpace()

bool testing::internal::IsSpace ( char ch )

inline

IsTrue()

bool testing::internal::IsTrue

(

bool

condition

)

IsUpper()

bool testing::internal::IsUpper ( char ch )

inline

IsUtf16SurrogatePair()

bool testing::internal::IsUtf16SurrogatePair ( wchar_t first, wchar_t second )

inline

IsXDigit() [1/4]

bool testing::internal::IsXDigit ( char ch )

inline

IsXDigit() [2/4]

bool testing::internal::IsXDigit ( char16_t ch )

inline

IsXDigit() [3/4]

bool testing::internal::IsXDigit ( char32_t ch )

inline

IsXDigit() [4/4]

bool testing::internal::IsXDigit ( wchar_t ch )

inline

JoinAsKeyValueTuple()

GTEST_API_ std::string testing::internal::JoinAsKeyValueTuple	(	const std::vector< const char * > &	names,
		const Strings &	values )

Log()

GTEST_API_ void testing::internal::Log	(	LogSeverity	severity,
		const std::string &	message,
		int	stack_frames_to_skip )

LogElementMatcherPairVec()

static void testing::internal::LogElementMatcherPairVec ( const ElementMatcherPairs & pairs, ::std::ostream * stream )

static

LogIsVisible()

GTEST_API_ bool testing::internal::LogIsVisible

(

LogSeverity

severity

)

LogToStderr()

void testing::internal::LogToStderr ( )

inline

LogWithLocation()

GTEST_API_ void testing::internal::LogWithLocation	(	testing::internal::LogSeverity	severity,
		const char *	file,
		int	line,
		const std::string &	message )

MakeAction() [1/2]

template<typename F , typename Impl >

::testing::Action< F > testing::internal::MakeAction

(

)

MakeAction() [2/2]

template<typename F , typename Impl >

::testing::Action< F > testing::internal::MakeAction

(

std::shared_ptr< Impl >

impl

)

MakeAndRegisterTestInfo()

TestInfo * testing::internal::MakeAndRegisterTestInfo	(	const char *	test_suite_name,
		const char *	name,
		const char *	type_param,
		const char *	value_param,
		CodeLocation	code_location,
		TypeId	fixture_class_id,
		SetUpTestSuiteFunc	set_up_tc,
		TearDownTestSuiteFunc	tear_down_tc,
		TestFactoryBase *	factory )

operator!=()

bool testing::internal::operator!= ( faketype , faketype  )

inline

operator==()

bool testing::internal::operator== ( faketype , faketype  )

inline

OutputFlagAlsoCheckEnvVar()

std::string testing::internal::OutputFlagAlsoCheckEnvVar

(

)

ParseFlag() [1/3]

bool testing::internal::ParseFlag	(	const char *	str,
		const char *	flag,
		int32_t *	value )

ParseFlag() [2/3]

static bool testing::internal::ParseFlag ( const char * str, const char * flag_name, bool * value )

static

ParseFlag() [3/3]

template<typename String >

static bool testing::internal::ParseFlag ( const char * str, const char * flag_name, String * value )

static

ParseFlagValue()

static const char * testing::internal::ParseFlagValue ( const char * str, const char * flag_name, bool def_optional )

static

ParseGoogleMockFlag() [1/3]

static bool testing::internal::ParseGoogleMockFlag ( const char * str, const char * flag_name, bool * value )

static

ParseGoogleMockFlag() [2/3]

static bool testing::internal::ParseGoogleMockFlag ( const char * str, const char * flag_name, int32_t * value )

static

ParseGoogleMockFlag() [3/3]

template<typename String >

static bool testing::internal::ParseGoogleMockFlag ( const char * str, const char * flag_name, String * value )

static

ParseGoogleMockFlagValue()

static const char * testing::internal::ParseGoogleMockFlagValue ( const char * str, const char * flag_name, bool def_optional )

static

ParseGoogleTestFlag()

static bool testing::internal::ParseGoogleTestFlag ( const char *const arg )

static

ParseGoogleTestFlagsOnly() [1/2]

void testing::internal::ParseGoogleTestFlagsOnly	(	int *	argc,
		char **	argv )

ParseGoogleTestFlagsOnly() [2/2]

void testing::internal::ParseGoogleTestFlagsOnly	(	int *	argc,
		wchar_t **	argv )

ParseGoogleTestFlagsOnlyImpl()

template<typename CharType >

void testing::internal::ParseGoogleTestFlagsOnlyImpl	(	int *	argc,
		CharType **	argv )

ParseInt32()

bool testing::internal::ParseInt32	(	const Message &	src_text,
		const char *	str,
		int32_t *	value )

PatternMatchesString()

static bool testing::internal::PatternMatchesString ( const std::string & name_str, const char * pattern, const char * pattern_end )

static

PrefixOf()

bool testing::internal::PrefixOf ( const char * a, const char * b )

constexpr

PrintAsCharLiteralTo()

template<typename Char >

static CharFormat testing::internal::PrintAsCharLiteralTo ( Char c, ostream * os )

static

PrintAsStringLiteralTo() [1/4]

static CharFormat testing::internal::PrintAsStringLiteralTo ( char c, ostream * os )

static

PrintAsStringLiteralTo() [2/4]

static CharFormat testing::internal::PrintAsStringLiteralTo ( char16_t c, ostream * os )

static

PrintAsStringLiteralTo() [3/4]

static CharFormat testing::internal::PrintAsStringLiteralTo ( char32_t c, ostream * os )

static

PrintAsStringLiteralTo() [4/4]

static CharFormat testing::internal::PrintAsStringLiteralTo ( wchar_t c, ostream * os )

static

PrintBytesInObjectTo() [1/2]

GTEST_API_ void testing::internal::PrintBytesInObjectTo	(	const unsigned char *	obj_bytes,
		size_t	count,
		::std::ostream *	os )

PrintBytesInObjectTo() [2/2]

void testing::internal::PrintBytesInObjectTo	(	const unsigned char *	obj_bytes,
		size_t	count,
		ostream *	os )

PrintCharAndCodeTo()

template<typename Char >

void testing::internal::PrintCharAndCodeTo	(	Char	c,
		ostream *	os )

PrintCharsAsStringTo()

template<typename CharType >

GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ CharFormat testing::internal::PrintCharsAsStringTo ( const CharType * begin, size_t len, ostream * os )

static

PrintColorEncoded()

static void testing::internal::PrintColorEncoded ( const char * str )

static

PrintFullTestCommentIfPresent()

static void testing::internal::PrintFullTestCommentIfPresent ( const TestInfo & test_info )

static

PrintOnOneLine()

static void testing::internal::PrintOnOneLine ( const char * str, int max_length )

static

PrintRawArrayTo()

template<typename T >

void testing::internal::PrintRawArrayTo	(	const T	a[],
		size_t	count,
		::std::ostream *	os )

PrintSmartPointer() [1/2]

template<typename T , typename Ptr >

void testing::internal::PrintSmartPointer	(	const Ptr &	ptr,
		std::ostream *	os,
		char	)

PrintSmartPointer() [2/2]

template<typename T , typename Ptr , typename = typename std::enable_if<!std::is_void<T>::value && !std::is_array<T>::value>::type>

void testing::internal::PrintSmartPointer	(	const Ptr &	ptr,
		std::ostream *	os,
		int	)

PrintStringTo() [1/2]

GTEST_API_ void testing::internal::PrintStringTo	(	const ::std::string &	s,
		::std::ostream *	os )

PrintStringTo() [2/2]

void testing::internal::PrintStringTo	(	const ::std::string &	s,
		ostream *	os )

PrintTestPartResult()

static void testing::internal::PrintTestPartResult ( const TestPartResult & test_part_result )

static

PrintTestPartResultToString()

static std::string testing::internal::PrintTestPartResultToString ( const TestPartResult & test_part_result )

static

PrintTo() [1/36]

void testing::internal::PrintTo ( bool x, ::std::ostream * os )

inline

PrintTo() [2/36]

void testing::internal::PrintTo ( char * s, ::std::ostream * os )

inline

PrintTo() [3/36]

void testing::internal::PrintTo ( char c, ::std::ostream * os )

inline

PrintTo() [4/36]

void testing::internal::PrintTo ( char16_t * s, ::std::ostream * os )

inline

PrintTo() [5/36]

void testing::internal::PrintTo ( char16_t c, ::std::ostream * os )

inline

PrintTo() [6/36]

void testing::internal::PrintTo ( char32_t * s, ::std::ostream * os )

inline

PrintTo() [7/36]

void testing::internal::PrintTo	(	char32_t	c,
		::std::ostream *	os )

PrintTo() [8/36]

template<typename T1 , typename T2 >

void testing::internal::PrintTo	(	const ::std::pair< T1, T2 > &	value,
		::std::ostream *	os )

PrintTo() [9/36]

void testing::internal::PrintTo ( const ::std::string & s, ::std::ostream * os )

inline

PrintTo() [10/36]

template<typename... Types>

void testing::internal::PrintTo	(	const ::std::tuple< Types... > &	t,
		::std::ostream *	os )

PrintTo() [11/36]

void testing::internal::PrintTo ( const ::std::u16string & s, ::std::ostream * os )

inline

PrintTo() [12/36]

void testing::internal::PrintTo ( const ::std::u32string & s, ::std::ostream * os )

inline

PrintTo() [13/36]

GTEST_API_ void testing::internal::PrintTo	(	const char *	s,
		::std::ostream *	os )

PrintTo() [14/36]

void testing::internal::PrintTo	(	const char *	s,
		ostream *	os )

PrintTo() [15/36]

GTEST_API_ void testing::internal::PrintTo	(	const char16_t *	s,
		::std::ostream *	os )

PrintTo() [16/36]

void testing::internal::PrintTo	(	const char16_t *	s,
		ostream *	os )

PrintTo() [17/36]

GTEST_API_ void testing::internal::PrintTo	(	const char32_t *	s,
		::std::ostream *	os )

PrintTo() [18/36]

void testing::internal::PrintTo	(	const char32_t *	s,
		ostream *	os )

PrintTo() [19/36]

void testing::internal::PrintTo ( const signed char * s, ::std::ostream * os )

inline

PrintTo() [20/36]

template<typename T >

void testing::internal::PrintTo	(	const std::shared_ptr< T > &	ptr,
		std::ostream *	os )

PrintTo() [21/36]

template<typename T , typename D >

void testing::internal::PrintTo	(	const std::unique_ptr< T, D > &	ptr,
		std::ostream *	os )

PrintTo() [22/36]

template<typename T >

void testing::internal::PrintTo	(	const T &	value,
		::std::ostream *	os )

PrintTo() [23/36]

void testing::internal::PrintTo ( const unsigned char * s, ::std::ostream * os )

inline

PrintTo() [24/36]

GTEST_API_ void testing::internal::PrintTo	(	const wchar_t *	s,
		::std::ostream *	os )

PrintTo() [25/36]

void testing::internal::PrintTo	(	const wchar_t *	s,
		ostream *	os )

PrintTo() [26/36]

void testing::internal::PrintTo ( double d, ::std::ostream * os )

inline

PrintTo() [27/36]

void testing::internal::PrintTo ( float f, ::std::ostream * os )

inline

PrintTo() [28/36]

void testing::internal::PrintTo ( signed char * s, ::std::ostream * os )

inline

PrintTo() [29/36]

void testing::internal::PrintTo	(	signed char	c,
		::std::ostream *	os )

PrintTo() [30/36]

void testing::internal::PrintTo ( std::nullptr_t , ::std::ostream * os )

inline

PrintTo() [31/36]

template<typename T >

void testing::internal::PrintTo	(	std::reference_wrapper< T >	ref,
		::std::ostream *	os )

PrintTo() [32/36]

void testing::internal::PrintTo ( unsigned char * s, ::std::ostream * os )

inline

PrintTo() [33/36]

void testing::internal::PrintTo	(	unsigned char	c,
		::std::ostream *	os )

PrintTo() [34/36]

void testing::internal::PrintTo ( wchar_t * s, ::std::ostream * os )

inline

PrintTo() [35/36]

GTEST_API_ void testing::internal::PrintTo	(	wchar_t	wc,
		::std::ostream *	os )

PrintTo() [36/36]

void testing::internal::PrintTo	(	wchar_t	wc,
		ostream *	os )

PrintTupleTo() [1/2]

template<typename T >

void testing::internal::PrintTupleTo	(	const T &	,
		std::integral_constant< size_t, 0 >	,
		::std::ostream *	)

PrintTupleTo() [2/2]

template<typename T , size_t I>

void testing::internal::PrintTupleTo	(	const T &	t,
		std::integral_constant< size_t, I >	,
		::std::ostream *	os )

PrintU16StringTo() [1/2]

GTEST_API_ void testing::internal::PrintU16StringTo	(	const ::std::u16string &	s,
		::std::ostream *	os )

PrintU16StringTo() [2/2]

void testing::internal::PrintU16StringTo	(	const ::std::u16string &	s,
		ostream *	os )

PrintU32StringTo() [1/2]

GTEST_API_ void testing::internal::PrintU32StringTo	(	const ::std::u32string &	s,
		::std::ostream *	os )

PrintU32StringTo() [2/2]

void testing::internal::PrintU32StringTo	(	const ::std::u32string &	s,
		ostream *	os )

PrintWithFallback()

template<typename T >

void testing::internal::PrintWithFallback	(	const T &	value,
		::std::ostream *	os )

ReadEntireFile()

std::string testing::internal::ReadEntireFile

(

FILE *

file

)

RegisterTypeParameterizedTestSuite()

void testing::internal::RegisterTypeParameterizedTestSuite	(	const char *	test_suite_name,
		CodeLocation	code_location )

RegisterTypeParameterizedTestSuiteInstantiation()

void testing::internal::RegisterTypeParameterizedTestSuiteInstantiation

(

const char *

case_name

)

ReportFailureInUnknownLocation()

void testing::internal::ReportFailureInUnknownLocation	(	TestPartResult::Type	result_type,
		const std::string &	message )

ReportInvalidTestSuiteType()

void testing::internal::ReportInvalidTestSuiteType	(	const char *	test_suite_name,
		CodeLocation	code_location )

ReportUninterestingCall()

void testing::internal::ReportUninterestingCall	(	CallReaction	reaction,
		const std::string &	msg )

SetUpEnvironment()

static void testing::internal::SetUpEnvironment ( Environment * env )

static

ShouldRunTestOnShard()

bool testing::internal::ShouldRunTestOnShard	(	int	total_shards,
		int	shard_index,
		int	test_id )

ShouldRunTestSuite()

static bool testing::internal::ShouldRunTestSuite ( const TestSuite * test_suite )

static

ShouldShard()

bool testing::internal::ShouldShard	(	const char *	total_shards_str,
		const char *	shard_index_str,
		bool	in_subprocess_for_death_test )

ShouldUseColor()

bool testing::internal::ShouldUseColor

(

bool

stdout_is_tty

)

Shuffle()

template<typename E >

void testing::internal::Shuffle ( internal::Random * random, std::vector< E > * v )

inline

ShuffleRange()

template<typename E >

void testing::internal::ShuffleRange	(	internal::Random *	random,
		int	begin,
		int	end,
		std::vector< E > *	v )

SkipComma()

const char * testing::internal::SkipComma ( const char * str )

inline

SkipPrefix()

bool testing::internal::SkipPrefix	(	const char *	prefix,
		const char **	pstr )

SkipSpaces()

static const char * testing::internal::SkipSpaces ( const char * str )

static

SplitIntoTestNames()

static std::vector< std::string > testing::internal::SplitIntoTestNames ( const char * src )

static

SplitString() [1/2]

void testing::internal::SplitString	(	const ::std::string &	str,
		char	delimiter,
		::std::vector< ::std::string > *	dest )

SplitString() [2/2]

void testing::internal::SplitString	(	const ::std::string &	str,
		char	delimiter,
		::std::vector<::std::string > *	dest )

StartsWith()

template<int N, int M>

bool testing::internal::StartsWith ( const char(&) prefix[N], const char(&) str[M] )

constexpr

StreamableToString()

template<typename T >

std::string testing::internal::StreamableToString

(

const T &

streamable

)

StrictnessModifierProbe() [1/4]

std::false_type testing::internal::StrictnessModifierProbe

(

...

)

StrictnessModifierProbe() [2/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe

(

const NaggyMock< T > &

)

StrictnessModifierProbe() [3/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe

(

const NiceMock< T > &

)

StrictnessModifierProbe() [4/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe

(

const StrictMock< T > &

)

StringFromGTestEnv()

const char * testing::internal::StringFromGTestEnv	(	const char *	flag,
		const char *	default_val )

StringStreamToString()

std::string testing::internal::StringStreamToString

(

::std::stringstream *

stream

)

StripTrailingSpaces()

std::string testing::internal::StripTrailingSpaces ( std::string str )

inline

SumOverTestSuiteList()

static int testing::internal::SumOverTestSuiteList ( const std::vector< TestSuite * > & case_list, int(TestSuite::* method )() const )

static

TearDownEnvironment()

static void testing::internal::TearDownEnvironment ( Environment * env )

static

TersePrintPrefixToStrings() [1/2]

template<typename Tuple >

void testing::internal::TersePrintPrefixToStrings	(	const Tuple &	,
		std::integral_constant< size_t, 0 >	,
		Strings *	)

TersePrintPrefixToStrings() [2/2]

template<typename Tuple , size_t I>

void testing::internal::TersePrintPrefixToStrings	(	const Tuple &	t,
		std::integral_constant< size_t, I >	,
		Strings *	strings )

TEST() [1/37]

testing::internal::TEST	(	ApiTest	,
		DISABLED_Dummy1	)

TEST() [2/37]

testing::internal::TEST	(	ApiTest	,
		TestSuiteDisabledAccessorsWork	)

TEST() [3/37]

testing::internal::TEST	(	ApiTest	,
		TestSuiteImmutableAccessorsWork	)

TEST() [4/37]

testing::internal::TEST	(	ApiTest	,
		UnitTestImmutableAccessorsWork	)

TEST() [5/37]

testing::internal::TEST	(	CaptureDeathTest	,
		CannotReenterStdoutCapture	)

TEST() [6/37]

testing::internal::TEST	(	CaptureTest	,
		CapturesStderr	)

TEST() [7/37]

testing::internal::TEST	(	CaptureTest	,
		CapturesStdout	)

TEST() [8/37]

testing::internal::TEST	(	CaptureTest	,
		CapturesStdoutAndStderr	)

TEST() [9/37]

testing::internal::TEST	(	DISABLED_Test	,
		Dummy2	)

TEST() [10/37]

testing::internal::TEST	(	FormatCompilerIndependentFileLocationTest	,
		FormatsFileLocation	)

TEST() [11/37]

testing::internal::TEST	(	FormatCompilerIndependentFileLocationTest	,
		FormatsUknownFile	)

TEST() [12/37]

testing::internal::TEST	(	FormatCompilerIndependentFileLocationTest	,
		FormatsUknownFileAndLine	)

TEST() [13/37]

testing::internal::TEST	(	FormatCompilerIndependentFileLocationTest	,
		FormatsUknownLine	)

TEST() [14/37]

testing::internal::TEST	(	FormatFileLocationTest	,
		FormatsFileLocation	)

TEST() [15/37]

testing::internal::TEST	(	FormatFileLocationTest	,
		FormatsUknownFileAndLine	)

TEST() [16/37]

testing::internal::TEST	(	FormatFileLocationTest	,
		FormatsUknownLine	)

TEST() [17/37]

testing::internal::TEST	(	FormatFileLocationTest	,
		FormatsUnknownFile	)

TEST() [18/37]

testing::internal::TEST	(	GetThreadCountTest	,
		ReturnsZeroWhenUnableToCountThreads	)

TEST() [19/37]

testing::internal::TEST	(	GtestCheckDeathTest	,
		DiesWithCorrectOutputOnFailure	)

TEST() [20/37]

testing::internal::TEST	(	GtestCheckSyntaxTest	,
		BehavesLikeASingleStatement	)

TEST() [21/37]

testing::internal::TEST	(	GtestCheckSyntaxTest	,
		WorksWithSwitch	)

TEST() [22/37]

testing::internal::TEST	(	ImplicitCastTest	,
		CanSelectBetweenConstAndNonConstCasrAppropriately	)

TEST() [23/37]

testing::internal::TEST	(	ImplicitCastTest	,
		CanUseConstCastOperatorOnConstValues	)

TEST() [24/37]

testing::internal::TEST	(	ImplicitCastTest	,
		CanUseImplicitConstructor	)

TEST() [25/37]

testing::internal::TEST	(	ImplicitCastTest	,
		CanUseInheritance	)

TEST() [26/37]

testing::internal::TEST	(	ImplicitCastTest	,
		CanUseNonConstCastOperator	)

TEST() [27/37]

testing::internal::TEST	(	ImplicitCastTest	,
		ConvertsPointers	)

TEST() [28/37]

testing::internal::TEST	(	IsXDigitTest	,
		ReturnsFalseForNarrowNonAscii	)

TEST() [29/37]

testing::internal::TEST	(	IsXDigitTest	,
		ReturnsFalseForWideNonAscii	)

TEST() [30/37]

testing::internal::TEST	(	IsXDigitTest	,
		WorksForNarrowAscii	)

TEST() [31/37]

testing::internal::TEST	(	IsXDigitTest	,
		WorksForWideAscii	)

TEST() [32/37]

testing::internal::TEST	(	RegexEngineSelectionTest	,
		SelectsCorrectRegexEngine	)

TEST() [33/37]

testing::internal::TEST	(	ThreadLocalTest	,
		DefaultConstructorInitializesToDefaultValues	)

TEST() [34/37]

testing::internal::TEST	(	ThreadLocalTest	,
		GetAndPointerReturnSameValue	)

TEST() [35/37]

testing::internal::TEST	(	ThreadLocalTest	,
		PointerAndConstPointerReturnSameValue	)

TEST() [36/37]

testing::internal::TEST	(	ThreadLocalTest	,
		SingleParamConstructorInitializesToParam	)

TEST() [37/37]

testing::internal::TEST	(	ThreadLocalTest	,
		ValueDefaultContructorIsNotRequiredForParamVersion	)

TEST_F() [1/2]

testing::internal::TEST_F	(	ListenerTest	,
		DoesBar	)

TEST_F() [2/2]

testing::internal::TEST_F	(	ListenerTest	,
		DoesFoo	)

TestNotEmpty() [1/2]

template<typename T = int>

void testing::internal::TestNotEmpty

(

)

TestNotEmpty() [2/2]

template<typename T = int>

void testing::internal::TestNotEmpty

(

const T &

)

TestSuiteFailed()

static bool testing::internal::TestSuiteFailed ( const TestSuite * test_suite )

static

TestSuitePassed()

static bool testing::internal::TestSuitePassed ( const TestSuite * test_suite )

static

ToLower()

char testing::internal::ToLower ( char ch )

inline

ToUpper()

char testing::internal::ToUpper ( char ch )

inline

TYPED_TEST()

testing::internal::TYPED_TEST	(	TestSuiteWithCommentTest	,
		Dummy	)

TYPED_TEST_SUITE()

testing::internal::TYPED_TEST_SUITE	(	TestSuiteWithCommentTest	,
		Types< int >	)

UnBase64()

std::array< char, 256 > testing::internal::UnBase64 ( const char *const base64 )

constexpr

UnBase64Impl() [1/2]

char testing::internal::UnBase64Impl ( char c, const char *const base64, char carry )

constexpr

UnBase64Impl() [2/2]

template<size_t... I>

std::array< char, 256 > testing::internal::UnBase64Impl ( IndexSequence< I... > , const char *const base64 )

constexpr

UndoWebSafeEncoding()

char testing::internal::UndoWebSafeEncoding ( char c )

constexpr

UniversalPrint()

template<typename T >

void testing::internal::UniversalPrint	(	const T &	value,
		::std::ostream *	os )

UniversalPrintArray() [1/9]

GTEST_API_ void testing::internal::UniversalPrintArray	(	const char *	begin,
		size_t	len,
		::std::ostream *	os )

UniversalPrintArray() [2/9]

void testing::internal::UniversalPrintArray	(	const char *	begin,
		size_t	len,
		ostream *	os )

UniversalPrintArray() [3/9]

GTEST_API_ void testing::internal::UniversalPrintArray	(	const char16_t *	begin,
		size_t	len,
		::std::ostream *	os )

UniversalPrintArray() [4/9]

void testing::internal::UniversalPrintArray	(	const char16_t *	begin,
		size_t	len,
		ostream *	os )

UniversalPrintArray() [5/9]

GTEST_API_ void testing::internal::UniversalPrintArray	(	const char32_t *	begin,
		size_t	len,
		::std::ostream *	os )

UniversalPrintArray() [6/9]

void testing::internal::UniversalPrintArray	(	const char32_t *	begin,
		size_t	len,
		ostream *	os )

UniversalPrintArray() [7/9]

template<typename T >

void testing::internal::UniversalPrintArray	(	const T *	begin,
		size_t	len,
		::std::ostream *	os )

UniversalPrintArray() [8/9]

GTEST_API_ void testing::internal::UniversalPrintArray	(	const wchar_t *	begin,
		size_t	len,
		::std::ostream *	os )

UniversalPrintArray() [9/9]

void testing::internal::UniversalPrintArray	(	const wchar_t *	begin,
		size_t	len,
		ostream *	os )

UniversalPrintCharArray()

template<typename CharType >

GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void testing::internal::UniversalPrintCharArray ( const CharType * begin, size_t len, ostream * os )

static

UniversalTersePrint()

template<typename T >

void testing::internal::UniversalTersePrint	(	const T &	value,
		::std::ostream *	os )

UniversalTersePrintTupleFieldsToStrings()

template<typename Tuple >

Strings testing::internal::UniversalTersePrintTupleFieldsToStrings

(

const Tuple &

value

)

ValidateSpec()

template<int N>

bool testing::internal::ValidateSpec ( const char(&) spec[N] )

constexpr

VoidifyPointer() [1/2]

const void * testing::internal::VoidifyPointer ( const void * p )

inline

VoidifyPointer() [2/2]

const void * testing::internal::VoidifyPointer ( volatile const void * p )

inline

WideStringToUtf8()

std::string testing::internal::WideStringToUtf8	(	const wchar_t *	str,
		int	num_chars )

WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded

(

)

Variable Documentation

g_argvs

::std::vector<std::string> testing::internal::g_argvs

g_gmock_implicit_sequence

GTEST_API_ ThreadLocal<Sequence*> testing::internal::g_gmock_implicit_sequence

g_help_flag

bool testing::internal::g_help_flag = false

kBase64

char testing::internal::kBase64[]

staticconstexpr

Initial value:

=
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

kColorEncodedHelpMessage

const char testing::internal::kColorEncodedHelpMessage[]

static

kDeathTestStyleFlag

const char testing::internal::kDeathTestStyleFlag[] = "death_test_style"

kDeathTestUseFork

const char testing::internal::kDeathTestUseFork[] = "death_test_use_fork"

kErrorVerbosity

const char testing::internal::kErrorVerbosity[] = "error"

kInfoVerbosity

const char testing::internal::kInfoVerbosity[] = "info"

kInternalRunDeathTestFlag

const char testing::internal::kInternalRunDeathTestFlag[] = "internal_run_death_test"

kMaxBiggestInt

BiggestInt testing::internal::kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)()

constexpr

kMaxCodePoint1

uint32_t testing::internal::kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1

constexpr

kMaxCodePoint2

uint32_t testing::internal::kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1

constexpr

kMaxCodePoint3

uint32_t testing::internal::kMaxCodePoint3

constexpr

Initial value:

=
    (static_cast<uint32_t>(1) << (4 + 2 * 6)) - 1

kMaxCodePoint4

uint32_t testing::internal::kMaxCodePoint4

constexpr

Initial value:

=
    (static_cast<uint32_t>(1) << (3 + 3 * 6)) - 1

kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

kStackTraceMarker

const char testing::internal::kStackTraceMarker = "\nStack trace:\n"

kTestTypeIdInGoogleTest

const TypeId testing::internal::kTestTypeIdInGoogleTest = GetTestTypeId()

extern

kTypedTests

const int testing::internal::kTypedTests = 1

kTypedTestSuites

const int testing::internal::kTypedTestSuites = 1

kTypeParamLabel

const char testing::internal::kTypeParamLabel[] = "TypeParam"

static

kUnBase64

std::array<char, 256> testing::internal::kUnBase64 = UnBase64(kBase64)

staticconstexpr

kUnknownFile

const char testing::internal::kUnknownFile[] = "unknown file"

kValueParamLabel

const char testing::internal::kValueParamLabel[] = "GetParam()"

static

kWarningVerbosity

const char testing::internal::kWarningVerbosity[] = "warning"