Namespaces
	posix

Classes
class	ActionAdaptor

class	ActionHelper

class	ActionResultHolder

class	ActionResultHolder< void >

struct	AddReference

struct	AddReference< T & >

struct	AllOfResult1

struct	AllOfResult10

struct	AllOfResult2

struct	AllOfResult3

struct	AllOfResult4

struct	AllOfResult5

struct	AllOfResult6

struct	AllOfResult7

struct	AllOfResult8

struct	AllOfResult9

class	AnyMatcherImpl

struct	AnyOfResult1

struct	AnyOfResult10

struct	AnyOfResult2

struct	AnyOfResult3

struct	AnyOfResult4

struct	AnyOfResult5

struct	AnyOfResult6

struct	AnyOfResult7

struct	AnyOfResult8

struct	AnyOfResult9

class	AnythingMatcher

class	ArgsMatcher

class	ArgsMatcherImpl

class	AssertHelper

class	AssignAction

struct	bool_constant

struct	BooleanConstant

class	BothOfMatcher

class	BothOfMatcherImpl

class	BuiltInDefaultValue

class	BuiltInDefaultValue< const T >

class	BuiltInDefaultValue< T * >

class	CallableHelper

struct	CallableTraits

struct	CallableTraits< ResType(*)(ArgType)>

struct	CastAndAppendTransform

struct	CompileAssert

struct	CompileAssertTypesEqual

struct	CompileAssertTypesEqual< T, T >

struct	ConstCharPtr

class	ContainerEqMatcher

class	ContainsMatcher

class	ContainsMatcherImpl

struct	DecayArray

struct	DecayArray< T[]>

struct	DecayArray< T[N]>

class	DefaultGlobalTestPartResultReporter

class	DefaultPerThreadTestPartResultReporter

class	DoBothAction

class	DoDefaultAction

class	DummyMatchResultListener

class	EachMatcher

class	EachMatcherImpl

class	EitherOfMatcher

class	EitherOfMatcherImpl

class	ElementsAreArrayMatcher

class	ElementsAreMatcher

class	ElementsAreMatcherImpl

struct	EnableIf

struct	EnableIf< true >

class	EndsWithMatcher

class	EqHelper

class	EqHelper< true >

struct	ExcessiveArg

class	ExpectationBase

class	FieldMatcher

class	FilePath

class	FloatingEqMatcher

class	FloatingPoint

class	FormatForComparison

class	FormatForComparison< ToPrint[N], OtherOperand >

struct	Function

struct	Function< R(A1)>

struct	Function< R(A1, A2)>

struct	Function< R(A1, A2, A3)>

struct	Function< R(A1, A2, A3, A4)>

struct	Function< R(A1, A2, A3, A4, A5)>

struct	Function< R(A1, A2, A3, A4, A5, A6)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>

class	FunctionMocker

class	FunctionMocker< R(A1)>

class	FunctionMocker< R(A1, A2)>

class	FunctionMocker< R(A1, A2, A3)>

class	FunctionMocker< R(A1, A2, A3, A4)>

class	FunctionMocker< R(A1, A2, A3, A4, A5)>

class	FunctionMocker< R(A1, A2, A3, A4, A5, A6)>

class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)>

class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)>

class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>

class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>

class	FunctionMockerBase

class	GTestFlagSaver

class	GTestLog

class	GTestMutexLock

class	HasNewFatalFailureHelper

class	HasSubstrMatcher

class	IgnoredValue

class	IgnoreResultAction

class	ImplicitlyConvertible

class	InvokeAction

class	InvokeHelper

class	InvokeHelper< R, ::std::tr1::tuple< A1 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >

class	InvokeHelper< R, ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > >

class	InvokeHelper< R, ::std::tr1::tuple<> >

class	InvokeMethodAction

class	InvokeMethodWithoutArgsAction

class	InvokeWithoutArgsAction

struct	is_pointer

struct	is_pointer< T * >

struct	is_reference

struct	is_reference< T & >

struct	IsAProtocolMessage

class	IsNullMatcher

struct	IteratorTraits

struct	IteratorTraits< const T * >

struct	IteratorTraits< T * >

class	KeyMatcher

class	KeyMatcherImpl

struct	KindOf

struct	LessComparator

class	linked_ptr

class	linked_ptr_internal

struct	LinkedPtrLessThan

struct	LosslessArithmeticConvertibleImpl

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To >

class	MatcherAsPredicate

class	MatcherBase

class	MatcherCastImpl

class	MatcherCastImpl< T, Matcher< T > >

class	MatcherCastImpl< T, Matcher< U > >

struct	MatcherTuple

struct	MatcherTuple< ::std::tr1::tuple< A1 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >

struct	MatcherTuple< ::std::tr1::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > >

struct	MatcherTuple< ::std::tr1::tuple<> >

class	MatchesRegexMatcher

class	MatchMatrix

class	MockSpec

class	Mutex

class	NativeArray

class	NotMatcher

class	NotMatcherImpl

class	NotNullMatcher

class	OnCallSpec

class	OsStackTraceGetter

class	OsStackTraceGetterInterface

class	PairMatcher

class	PairMatcherImpl

class	PointeeMatcher

struct	PointeeOf

struct	PointeeOf< T * >

class	PointwiseMatcher

class	PredicateFormatterFromMatcher

class	PropertyMatcher

class	QuantifierMatcherImpl

class	Random

class	RE

class	ReferenceWrapper

class	RefMatcher

class	RefMatcher< T & >

struct	remove_reference

struct	remove_reference< T & >

struct	RemoveConst

struct	RemoveConst< const T >

struct	RemoveConst< const T[N]>

struct	RemoveConstFromKey

struct	RemoveConstFromKey< std::pair< const K, V > >

struct	RemoveReference

struct	RemoveReference< T & >

class	ResultOfMatcher

class	ReturnAction

class	ReturnNullAction

class	ReturnRefAction

class	ReturnRefOfCopyAction

class	ReturnVoidAction

class	scoped_ptr

class	ScopedTrace

class	SelectArgs

class	SelectArgs< Result, ArgumentTuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, -1, -1, -1, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, -1, -1, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, -1, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, -1, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, -1, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, -1, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, -1, -1 >

class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9, -1 >

class	SetArgumentPointeeAction

class	SetArgumentPointeeAction< N, Proto, true >

class	SetErrnoAndReturnAction

class	SingleFailureChecker

class	SizeIsMatcher

class	StartsWithMatcher

struct	StaticAssertTypeEqHelper

struct	StaticAssertTypeEqHelper< T, T >

class	StlContainerView

class	StlContainerView< ::std::tr1::tuple< ElementPointer, Size > >

class	StlContainerView< Element[N]>

class	StreamMatchResultListener

class	StrEqualityMatcher

class	String

class	TestFactoryBase

class	TestFactoryImpl

class	TestPropertyKeyIs

class	TestResultAccessor

class	ThreadLocal

struct	TraceInfo

class	TransformTupleValuesHelper

class	TrulyMatcher

class	TupleFields

class	TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >

class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >

class	TuplePrefix

class	TuplePrefix< 0 >

struct	type_equals

struct	type_equals< T, T >

class	TypedExpectation

class	TypeIdHelper

class	TypeWithSize

class	TypeWithSize< 4 >

class	TypeWithSize< 8 >

class	UnitTestImpl

class	UnitTestOptions

class	UniversalPrinter

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

class	UniversalTersePrinter

class	UniversalTersePrinter< char * >

class	UniversalTersePrinter< const char * >

class	UniversalTersePrinter< T & >

class	UniversalTersePrinter< T[N]>

class	UniversalTersePrinter< wchar_t * >

class	UnorderedElementsAreArrayMatcher

class	UnorderedElementsAreMatcher

class	UnorderedElementsAreMatcherImpl

class	UnorderedElementsAreMatcherImplBase

class	UntypedActionResultHolderBase

class	UntypedFunctionMockerBase

class	UntypedOnCallSpecBase

class	WhenSortedByMatcher

class	WithArgsAction

Typedefs
typedef ::std::pair< size_t, size_t >	ElementMatcherPair

typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs

typedef FloatingPoint< float >	Float

typedef FloatingPoint< double >	Double

typedef const void *	TypeId

typedef void(*	SetUpTestCaseFunc) ()

typedef void(*	TearDownTestCaseFunc) ()

typedef int	IsContainer

typedef char	IsNotContainer

typedef ::std::string	string

typedef ::std::wstring	wstring

typedef GTestMutexLock	MutexLock

typedef bool_constant< false >	false_type

typedef bool_constant< true >	true_type

typedef long long	BiggestInt

typedef TypeWithSize< 4 >::Int	Int32

typedef TypeWithSize< 4 >::UInt	UInt32

typedef TypeWithSize< 8 >::Int	Int64

typedef TypeWithSize< 8 >::UInt	UInt64

typedef TypeWithSize< 8 >::Int	TimeInMillis

Enumerations
enum	CallReaction { kAllow, kWarn, kFail, kDefault = kWarn, kAllow, kWarn, kFail, kDefault = kWarn }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	RelationToSource { kReference, kCopy, kReference, kCopy }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	CallReaction { kAllow, kWarn, kFail, kDefault = kWarn, kAllow, kWarn, kFail, kDefault = kWarn }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	RelationToSource { kReference, kCopy, kReference, kCopy }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

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_ (unsigned short, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 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_ (UInt64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (Int64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)

template<typename T >
void	PrintTo (const ReferenceWrapper< T > &ref, ::std::ostream *os)

void	PrintIfNotEmpty (const internal::string &explanation, ::std::ostream *os)

bool	IsReadableTypeName (const string &type_name)

template<typename Value , typename T >
bool	MatchPrintAndExplain (Value &value, const Matcher< T > &matcher, MatchResultListener *listener)

template<typename MatcherTuple , typename ValueTuple >
bool	TupleMatches (const MatcherTuple &matcher_tuple, const ValueTuple &value_tuple)

template<typename MatcherTuple , typename ValueTuple >
void	ExplainMatchFailureTupleTo (const MatcherTuple &matchers, const ValueTuple &values, ::std::ostream *os)

template<typename Tuple , typename Func , typename OutIter >
OutIter	TransformTupleValues (Func f, const Tuple &t, OutIter out)

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Eq,==, "is equal to", "isn't equal to")

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Ge, >=, "is >=", "isn't >=")

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Gt, >, "is >", "isn't >")

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Le,<=, "is <=", "isn't <=")

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Lt,<, "is <", "isn't <")

	GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Ne, !=, "isn't equal to", "is equal to")

bool	CaseInsensitiveCStringEquals (const char lhs, const char rhs)

bool	CaseInsensitiveCStringEquals (const wchar_t lhs, const wchar_t rhs)

template<typename StringType >
bool	CaseInsensitiveStringEquals (const StringType &s1, const StringType &s2)

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Eq,==, "an equal pair")

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Ge, >=, "a pair where the first >= the second")

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Gt, >, "a pair where the first > the second")

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Le,<=, "a pair where the first <= the second")

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Lt,<, "a pair where the first < the second")

	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Ne, !=, "an unequal pair")

template<typename M >
PredicateFormatterFromMatcher< M >	MakePredicateFormatterFromMatcher (const M &matcher)

GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)

GTEST_API_ bool	FindPairing (const MatchMatrix &matrix, MatchResultListener *listener)

GTEST_API_ string	FormatMatcherDescription (bool negation, const char *matcher_name, const Strings &param_values)

GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_gmock_mutex)

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

void	ReportUninterestingCall (CallReaction reaction, const string &msg)

GTEST_API_ string	ConvertIdentifierNameToWords (const char *id_name)

template<typename Pointer >
const Pointer::element_type *	GetRawPointer (const Pointer &p)

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_ (int, kInteger)

	GMOCK_DECLARE_KIND_ (long, kInteger)

	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)

	GMOCK_DECLARE_KIND_ (Int64, kInteger)

	GMOCK_DECLARE_KIND_ (UInt64, kInteger)

	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)

template<typename From , typename To >
void	Assert (bool condition, const char *file, int line)

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

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

GTEST_API_ bool	LogIsVisible (LogSeverity severity)

GTEST_API_ void	Log (LogSeverity severity, const string &message, int stack_frames_to_skip)

template<typename T >
T	Invalid ()

template<>
void	Invalid< void > ()

template<typename T >
std::string	StreamableToString (const T &streamable)

template<typename T >
void	UniversalPrint (const T &value, ::std::ostream *os)

template<typename C >
void	DefaultPrintTo (IsContainer, false_type, const C &container, ::std::ostream *os)

template<typename T >
void	DefaultPrintTo (IsNotContainer, true_type, T p, ::std::ostream os)

template<typename T >
void	DefaultPrintTo (IsNotContainer, false_type, const T &value, ::std::ostream *os)

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 (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 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)

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 wchar_t begin, size_t len, ::std::ostream os)

template<typename T >
void	UniversalTersePrint (const T &value, ::std::ostream *os)

class UnitTestImpl *	GetUnitTestImpl ()

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

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)

	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)

template<typename T1 , typename T2 >
std::string	FormatForComparisonFailureMessage (const T1 &value, const T2 &)

template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQ (const char expected_expression, const char actual_expression, const T1 &expected, const T2 &actual)

GTEST_API_ AssertionResult	CmpHelperEQ (const char expected_expression, const char actual_expression, BiggestInt expected, BiggestInt actual)

	GTEST_IMPL_CMP_HELPER_ (NE, !=)

	GTEST_IMPL_CMP_HELPER_ (LE,<=)

	GTEST_IMPL_CMP_HELPER_ (LT,<)

	GTEST_IMPL_CMP_HELPER_ (GE, >=)

	GTEST_IMPL_CMP_HELPER_ (GT, >)

GTEST_API_ AssertionResult	CmpHelperSTREQ (const char expected_expression, const char actual_expression, const char expected, const char actual)

GTEST_API_ AssertionResult	CmpHelperSTRCASEEQ (const char expected_expression, const char actual_expression, const char expected, const char actual)

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 expected_expression, const char actual_expression, const wchar_t expected, const wchar_t actual)

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 expected_expression, const char actual_expression, RawType expected, RawType actual)

GTEST_API_ AssertionResult	DoubleNearPredFormat (const char expr1, const char expr2, const char *abs_error_expr, double val1, double val2, double abs_error)

	GTEST_DECLARE_string_ (internal_run_death_test)

char	IsNullLiteralHelper (Secret *p)

char(&	IsNullLiteralHelper (...))[2]

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 ()

GTEST_API_ TestInfo *	MakeAndRegisterTestInfo (const char test_case_name, const char name, const char type_param, const char value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)

GTEST_API_ bool	SkipPrefix (const char prefix, const char *pstr)

GTEST_API_ std::string	GetCurrentOsStackTraceExceptTop (UnitTest *unit_test, int skip_count)

GTEST_API_ bool	AlwaysTrue ()

bool	AlwaysFalse ()

template<class C >
IsContainer	IsContainerTest (int, typename C::iterator =NULL, typename C::const_iterator =NULL)

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_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_linked_ptr_mutex)

template<typename T >
bool	operator== (T *ptr, const linked_ptr< T > &x)

template<typename T >
bool	operator!= (T *ptr, const linked_ptr< T > &x)

template<typename T >
linked_ptr< T >	make_linked_ptr (T *ptr)

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<typename To , typename From >
To	DownCast_ (From *f)

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	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 (wchar_t ch)

char	ToLower (char ch)

char	ToUpper (char ch)

bool	ParseInt32 (const Message &src_text, const char str, Int32 value)

bool	BoolFromGTestEnv (const char *flag, bool default_val)

GTEST_API_ Int32	Int32FromGTestEnv (const char *flag, Int32 default_val)

const char *	StringFromGTestEnv (const char flag, const char default_val)

GTEST_API_ std::string	StringStreamToString (::std::stringstream *stream)

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	ParseInt32Flag (const char str, const char flag, Int32 *value)

int	GetRandomSeedFromFlag (Int32 random_seed_flag)

int	GetNextRandomSeed (int seed)

GTEST_API_ std::string	CodePointToUtf8 (UInt32 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	Int32FromEnvOrDie (const char *env_var, Int32 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_ FilePath	GetCurrentExecutableName ()

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, char *argv)

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, wchar_t *argv)

template<typename T >
static void	Delete (T *x)

Variables
GTEST_API_ ThreadLocal< Sequence * >	g_gmock_implicit_sequence

const char	kInfoVerbosity [] = "info"

const char	kWarningVerbosity [] = "warning"

const char	kErrorVerbosity [] = "error"

const char	kDeathTestStyleFlag [] = "death_test_style"

const char	kDeathTestUseFork [] = "death_test_use_fork"

const char	kInternalRunDeathTestFlag [] = "internal_run_death_test"

GTEST_API_ int	g_init_gtest_count

GTEST_API_ const char	kStackTraceMarker []

class GTEST_API_ testing::internal::ScopedTrace	GTEST_ATTRIBUTE_UNUSED_

const BiggestInt	kMaxBiggestInt

GTEST_API_ const TypeId	kTestTypeIdInGoogleTest

const char	kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"

const char	kBreakOnFailureFlag [] = "break_on_failure"

const char	kCatchExceptionsFlag [] = "catch_exceptions"

const char	kColorFlag [] = "color"

const char	kFilterFlag [] = "filter"

const char	kListTestsFlag [] = "list_tests"

const char	kOutputFlag [] = "output"

const char	kPrintTimeFlag [] = "print_time"

const char	kRandomSeedFlag [] = "random_seed"

const char	kRepeatFlag [] = "repeat"

const char	kShuffleFlag [] = "shuffle"

const char	kStackTraceDepthFlag [] = "stack_trace_depth"

const char	kStreamResultToFlag [] = "stream_result_to"

const char	kThrowOnFailureFlag [] = "throw_on_failure"

const int	kMaxRandomSeed = 99999

GTEST_API_ bool	g_help_flag

Typedef Documentation

◆ BiggestInt

typedef long long testing::internal::BiggestInt

◆ Double

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

◆ ElementMatcherPair

typedef::std::pair< size_t, size_t > testing::internal::ElementMatcherPair

◆ ElementMatcherPairs

typedef::std::vector< ElementMatcherPair > testing::internal::ElementMatcherPairs

◆ false_type

typedef bool_constant< false > testing::internal::false_type

◆ Float

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

◆ Int32

typedef TypeWithSize< 4 >::Int testing::internal::Int32

◆ Int64

typedef TypeWithSize< 8 >::Int testing::internal::Int64

◆ IsContainer

typedef int testing::internal::IsContainer

◆ IsNotContainer

typedef char testing::internal::IsNotContainer

◆ MutexLock

typedef GTestMutexLock testing::internal::MutexLock

◆ SetUpTestCaseFunc

typedef void(* testing::internal::SetUpTestCaseFunc)()

◆ string

typedef::std::string testing::internal::string

◆ TearDownTestCaseFunc

typedef void(* testing::internal::TearDownTestCaseFunc)()

◆ TimeInMillis

typedef TypeWithSize< 8 >::Int testing::internal::TimeInMillis

◆ true_type

typedef bool_constant< true > testing::internal::true_type

◆ TypeId

typedef const void * testing::internal::TypeId

◆ UInt32

typedef TypeWithSize< 4 >::UInt testing::internal::UInt32

◆ UInt64

typedef TypeWithSize< 8 >::UInt testing::internal::UInt64

◆ wstring

typedef::std::wstring testing::internal::wstring

Enumeration Type Documentation

◆ CallReaction [1/2]

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault

◆ CallReaction [2/2]

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault

◆ GTestLogSeverity [1/2]

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

◆ GTestLogSeverity [2/2]

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

◆ LogSeverity [1/2]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning

◆ LogSeverity [2/2]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning

◆ RelationToSource [1/2]

enum testing::internal::RelationToSource

Enumerator
kReference
kCopy
kReference
kCopy

◆ RelationToSource [2/2]

enum testing::internal::RelationToSource

Enumerator
kReference
kCopy
kReference
kCopy

◆ TypeKind [1/2]

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther

◆ TypeKind [2/2]

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther

Function Documentation

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

References AlwaysTrue().

◆ AlwaysTrue()

GTEST_API_ bool testing::internal::AlwaysTrue ( )

Referenced by AlwaysFalse().

◆ AppendUserMessage()

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

◆ ArrayAwareFind()

template<typename Iter , typename Element >

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

References ArrayEq().

Referenced by testing::internal::ContainerEqMatcher< Container >::MatchAndExplain().

◆ ArrayEq() [1/3]

template<typename T , typename U >

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

Referenced by ArrayAwareFind(), ArrayEq(), and testing::internal::NativeArray< Element >::operator==().

◆ ArrayEq() [2/3]

template<typename T , typename U >

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

inline

◆ ArrayEq() [3/3]

template<typename T , typename U , size_t N>

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

inline

References ArrayEq().

◆ Assert()

template<typename From , typename To >

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

inline

Referenced by testing::internal::UntypedOnCallSpecBase::AssertSpecProperty(), testing::internal::ExpectationBase::AssertSpecProperty(), testing::internal::BuiltInDefaultValue< T >::Get(), testing::Action< InnerFunctionType >::Perform(), and testing::internal::FunctionMockerBase< R(A1, A2)>::PerformDefaultAction().

◆ BoolFromGTestEnv()

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

◆ CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr ( )

◆ CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout ( )

◆ CaseInsensitiveCStringEquals() [1/2]

bool testing::internal::CaseInsensitiveCStringEquals	(	const char *	lhs,
		const char *	rhs
	)

inline

References testing::internal::String::CaseInsensitiveCStringEquals().

Referenced by CaseInsensitiveStringEquals().

◆ CaseInsensitiveCStringEquals() [2/2]

bool testing::internal::CaseInsensitiveCStringEquals	(	const wchar_t *	lhs,
		const wchar_t *	rhs
	)

inline

References testing::internal::String::CaseInsensitiveWideCStringEquals().

◆ CaseInsensitiveStringEquals()

template<typename StringType >

bool testing::internal::CaseInsensitiveStringEquals	(	const StringType &	s1,
		const StringType &	s2
	)

References CaseInsensitiveCStringEquals().

Referenced by testing::internal::StrEqualityMatcher< StringType >::MatchAndExplain().

◆ CheckedDowncastToActualType()

template<class Derived , class Base >

Derived * testing::internal::CheckedDowncastToActualType ( Base * base )

References GTEST_CHECK_.

◆ CmpHelperEQ() [1/2]

template<typename T1 , typename T2 >

AssertionResult testing::internal::CmpHelperEQ	(	const char *	expected_expression,
		const char *	actual_expression,
		const T1 &	expected,
		const T2 &	actual
	)

References testing::AssertionSuccess(), EqFailure(), and FormatForComparisonFailureMessage().

Referenced by testing::internal::EqHelper< lhs_is_null_literal >::Compare(), and testing::internal::EqHelper< true >::Compare().

◆ CmpHelperEQ() [2/2]

GTEST_API_ AssertionResult testing::internal::CmpHelperEQ	(	const char *	expected_expression,
		const char *	actual_expression,
		BiggestInt	expected,
		BiggestInt	actual
	)

Referenced by testing::internal::EqHelper< lhs_is_null_literal >::Compare(), and testing::internal::EqHelper< true >::Compare().

◆ CmpHelperFloatingPointEQ()

template<typename RawType >

AssertionResult testing::internal::CmpHelperFloatingPointEQ	(	const char *	expected_expression,
		const char *	actual_expression,
		RawType	expected,
		RawType	actual
	)

References testing::AssertionSuccess(), EqFailure(), and StringStreamToString().

◆ CmpHelperSTRCASEEQ()

GTEST_API_ AssertionResult testing::internal::CmpHelperSTRCASEEQ	(	const char *	expected_expression,
		const char *	actual_expression,
		const char *	expected,
		const char *	actual
	)

◆ CmpHelperSTRCASENE()

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

◆ CmpHelperSTREQ() [1/2]

GTEST_API_ AssertionResult testing::internal::CmpHelperSTREQ	(	const char *	expected_expression,
		const char *	actual_expression,
		const char *	expected,
		const char *	actual
	)

◆ CmpHelperSTREQ() [2/2]

GTEST_API_ AssertionResult testing::internal::CmpHelperSTREQ	(	const char *	expected_expression,
		const char *	actual_expression,
		const wchar_t *	expected,
		const wchar_t *	actual
	)

◆ CmpHelperSTRNE() [1/2]

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

◆ CmpHelperSTRNE() [2/2]

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

◆ CodePointToUtf8()

GTEST_API_ std::string testing::internal::CodePointToUtf8 ( UInt32 code_point )

◆ ConvertIdentifierNameToWords()

GTEST_API_ string testing::internal::ConvertIdentifierNameToWords ( const char * id_name )

◆ CopyArray() [1/3]

template<typename T , typename U >

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

Referenced by CopyArray().

◆ CopyArray() [2/3]

template<typename T , typename U >

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

inline

◆ CopyArray() [3/3]

template<typename T , typename U , size_t N>

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

inline

References CopyArray().

◆ CountIf()

template<class Container , typename Predicate >

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

inline

◆ DefaultPrintTo() [1/3]

template<typename C >

void testing::internal::DefaultPrintTo	(	IsContainer	,
		false_type	,
		const C &	container,
		::std::ostream *	os
	)

References UniversalPrint().

Referenced by PrintTo().

◆ DefaultPrintTo() [2/3]

template<typename T >

void testing::internal::DefaultPrintTo	(	IsNotContainer	,
		true_type	,
		T *	p,
		::std::ostream *	os
	)

References IsTrue().

◆ DefaultPrintTo() [3/3]

template<typename T >

void testing::internal::DefaultPrintTo	(	IsNotContainer	,
		false_type	,
		const T &	value,
		::std::ostream *	os
	)

References testing_internal::DefaultPrintNonContainerTo().

◆ Delete() [1/2]

template<typename T >

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

static

◆ Delete() [2/2]

template<typename T >

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

static

◆ DoubleNearPredFormat()

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

◆ DownCast_()

template<typename To , typename From >

To testing::internal::DownCast_ ( From * f )

inline

References GTEST_CHECK_.

◆ EqFailure()

GTEST_API_ 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
	)

Referenced by CmpHelperEQ(), and CmpHelperFloatingPointEQ().

◆ Expect() [1/2]

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

inline

Referenced by Expect(), testing::internal::UntypedOnCallSpecBase::ExpectSpecProperty(), and testing::internal::ExpectationBase::ExpectSpecProperty().

◆ Expect() [2/2]

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

inline

References Expect().

◆ ExplainMatchFailureTupleTo()

template<typename MatcherTuple , typename ValueTuple >

void testing::internal::ExplainMatchFailureTupleTo	(	const MatcherTuple &	matchers,
		const ValueTuple &	values,
		::std::ostream *	os
	)

◆ FindMaxBipartiteMatching()

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching ( const MatchMatrix & g )

◆ FindPairing()

GTEST_API_ bool testing::internal::FindPairing	(	const MatchMatrix &	matrix,
		MatchResultListener *	listener
	)

Referenced by testing::internal::UnorderedElementsAreMatcherImpl< Container >::MatchAndExplain().

◆ FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

◆ ForEach()

template<class Container , typename Functor >

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

Referenced by testing::internal::UnitTestImpl::ClearNonAdHocTestResult().

◆ 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
	)

Referenced by testing::internal::ExpectationBase::DescribeLocationTo().

◆ FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >

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

Referenced by CmpHelperEQ().

◆ FormatMatcherDescription()

GTEST_API_ string testing::internal::FormatMatcherDescription	(	bool	negation,
		const char *	matcher_name,
		const Strings &	param_values
	)

◆ FormatTimeInMillisAsSeconds()

GTEST_API_ std::string testing::internal::FormatTimeInMillisAsSeconds ( TimeInMillis ms )

◆ GetBoolAssertionFailureMessage()

GTEST_API_ 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 ( )

◆ GetCurrentExecutableName()

GTEST_API_ FilePath testing::internal::GetCurrentExecutableName ( )

◆ GetCurrentOsStackTraceExceptTop()

GTEST_API_ std::string testing::internal::GetCurrentOsStackTraceExceptTop	(	UnitTest *	unit_test,
		int	skip_count
	)

◆ GetElementOr()

template<typename E >

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

inline

Referenced by testing::internal::UnitTestImpl::GetMutableTestCase(), and testing::internal::UnitTestImpl::GetTestCase().

◆ GetNextRandomSeed()

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

inline

References GTEST_CHECK_, and kMaxRandomSeed.

◆ GetRandomSeedFromFlag()

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

inline

References GetTimeInMillis(), and kMaxRandomSeed.

◆ GetRawPointer() [1/2]

template<typename Pointer >

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

inline

Referenced by testing::internal::IsNullMatcher::MatchAndExplain(), and testing::internal::NotNullMatcher::MatchAndExplain().

◆ GetRawPointer() [2/2]

template<typename Element >

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

inline

◆ GetTestTypeId()

GTEST_API_ TypeId testing::internal::GetTestTypeId ( )

◆ GetThreadCount()

GTEST_API_ size_t testing::internal::GetThreadCount ( )

◆ GetTimeInMillis()

GTEST_API_ TimeInMillis testing::internal::GetTimeInMillis ( )

Referenced by GetRandomSeedFromFlag().

◆ GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId ( )

◆ GetTypeName()

template<typename T >

std::string testing::internal::GetTypeName ( )

◆ GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

References testing::UnitTest::GetInstance().

◆ GMOCK_DECLARE_KIND_() [1/13]

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

◆ GMOCK_DECLARE_KIND_() [2/13]

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

◆ GMOCK_DECLARE_KIND_() [3/13]

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

◆ GMOCK_DECLARE_KIND_() [4/13]

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

◆ GMOCK_DECLARE_KIND_() [5/13]

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

◆ GMOCK_DECLARE_KIND_() [6/13]

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

◆ GMOCK_DECLARE_KIND_() [7/13]

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

◆ GMOCK_DECLARE_KIND_() [8/13]

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

◆ GMOCK_DECLARE_KIND_() [9/13]

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

◆ GMOCK_DECLARE_KIND_() [10/13]

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

◆ GMOCK_DECLARE_KIND_() [11/13]

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

◆ GMOCK_DECLARE_KIND_() [12/13]

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

◆ GMOCK_DECLARE_KIND_() [13/13]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/14]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ ( void )

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/14]

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

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [1/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(	Eq	,
		"an equal pair"
	)

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [2/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(	Ge	,
		>=	,
		"a pair where the first >= the second"
	)

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [3/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(	Gt	,
		"a pair where the	first,
		the second"
	)

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [4/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(	Le	,
		<=	,
		"a pair where the first <= the second"
	)

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [5/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ ( Lt )

◆ GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [6/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(	Ne	,
		!	,
		"an unequal pair"
	)

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [1/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(	Eq	,
		"is equal to"	,
		"isn't equal to"
	)

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [2/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(	Ge	,
		>=	,
		"is >="	,
		"isn't >="
	)

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [3/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(	Gt	,
		"	is,
		"	,
		"isn'	t,
		"
	)

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [4/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(	Le	,
		<=	,
		"is <="	,
		"isn't <="
	)

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [5/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ ( Lt )

◆ GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [6/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(	Ne	,
		!	,
		"isn't equal to"	,
		"is equal to"
	)

◆ GTEST_DECLARE_STATIC_MUTEX_() [1/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_linked_ptr_mutex )

◆ GTEST_DECLARE_STATIC_MUTEX_() [2/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_gmock_mutex )

◆ GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_ ( internal_run_death_test )

◆ GTEST_IMPL_CMP_HELPER_() [1/5]

testing::internal::GTEST_IMPL_CMP_HELPER_	(	NE	,
		!
	)

◆ GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_	(	LE	,
		<=
	)

◆ GTEST_IMPL_CMP_HELPER_() [3/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( LT )

◆ GTEST_IMPL_CMP_HELPER_() [4/5]

testing::internal::GTEST_IMPL_CMP_HELPER_	(	GE	,
		>=
	)

◆ GTEST_IMPL_CMP_HELPER_() [5/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( GT )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( wchar_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_()

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

◆ ImplicitCast_()

template<typename To >

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

inline

◆ Int32FromEnvOrDie()

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

◆ Int32FromGTestEnv()

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

◆ Invalid()

template<typename T >

T testing::internal::Invalid ( )

inline

◆ Invalid< void >()

template<>

void testing::internal::Invalid< void > ( )

inline

◆ IsAlNum()

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

inline

◆ IsAlpha()

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

inline

◆ IsContainerTest() [1/2]

template<class C >

IsContainer testing::internal::IsContainerTest	(	int	,
		typename C::iterator *	= `NULL`,
		typename C::const_iterator *	= `NULL`
	)

◆ 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

◆ IsNullLiteralHelper() [1/2]

char testing::internal::IsNullLiteralHelper ( Secret * p )

◆ IsNullLiteralHelper() [2/2]

char(& testing::internal::IsNullLiteralHelper ( ... ) )[2]

◆ IsReadableTypeName()

bool testing::internal::IsReadableTypeName ( const string & type_name )

inline

Referenced by MatchPrintAndExplain().

◆ IsSpace()

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

inline

◆ IsTrue()

GTEST_API_ bool testing::internal::IsTrue ( bool condition )

Referenced by DefaultPrintTo(), and testing::internal::scoped_ptr< const ::std::string >::reset().

◆ IsUpper()

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

inline

◆ IsXDigit() [1/2]

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

inline

◆ IsXDigit() [2/2]

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

inline

◆ Log()

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

◆ 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 string &	message
	)

Referenced by testing::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7, A8, A9) >::InternalDefaultActionSetAt(), and testing::internal::MockSpec< R(A1, A2, A3, A4, A5, A6, A7, A8, A9) >::InternalExpectedAt().

◆ make_linked_ptr()

template<typename T >

linked_ptr< T > testing::internal::make_linked_ptr ( T * ptr )

◆ MakeAndRegisterTestInfo()

GTEST_API_ TestInfo * testing::internal::MakeAndRegisterTestInfo	(	const char *	test_case_name,
		const char *	name,
		const char *	type_param,
		const char *	value_param,
		TypeId	fixture_class_id,
		SetUpTestCaseFunc	set_up_tc,
		TearDownTestCaseFunc	tear_down_tc,
		TestFactoryBase *	factory
	)

◆ MakePredicateFormatterFromMatcher()

template<typename M >

PredicateFormatterFromMatcher< M > testing::internal::MakePredicateFormatterFromMatcher ( const M & matcher )

inline

◆ MatchPrintAndExplain()

template<typename Value , typename T >

bool testing::internal::MatchPrintAndExplain	(	Value &	value,
		const Matcher< T > &	matcher,
		MatchResultListener *	listener
	)

References testing::MatchResultListener::IsInterested(), IsReadableTypeName(), testing::internal::MatcherBase< T >::MatchAndExplain(), testing::internal::MatcherBase< T >::Matches(), PrintIfNotEmpty(), testing::StringMatchResultListener::str(), testing::MatchResultListener::stream(), and UniversalPrint().

Referenced by testing::internal::PredicateFormatterFromMatcher< M >::operator()().

◆ operator!=()

template<typename T >

bool testing::internal::operator!=	(	T *	ptr,
		const linked_ptr< T > &	x
	)

inline

References testing::internal::linked_ptr< T >::get().

◆ operator==()

template<typename T >

bool testing::internal::operator==	(	T *	ptr,
		const linked_ptr< T > &	x
	)

inline

References testing::internal::linked_ptr< T >::get().

◆ ParseGoogleTestFlagsOnly() [1/2]

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

◆ ParseGoogleTestFlagsOnly() [2/2]

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

◆ ParseInt32()

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

◆ ParseInt32Flag()

GTEST_API_ bool testing::internal::ParseInt32Flag	(	const char *	str,
		const char *	flag,
		Int32 *	value
	)

◆ PrintIfNotEmpty()

void testing::internal::PrintIfNotEmpty	(	const internal::string &	explanation,
		::std::ostream *	os
	)

inline

Referenced by testing::internal::TuplePrefix< N >::ExplainMatchFailuresTo(), testing::internal::ArgsMatcherImpl< ArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >::MatchAndExplain(), testing::internal::SizeIsMatcher< SizeMatcher >::Impl< Container >::MatchAndExplain(), testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >::Impl< LhsContainer >::MatchAndExplain(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::MatchAndExplain(), testing::internal::PairMatcherImpl< PairType >::MatchAndExplain(), testing::internal::ElementsAreMatcherImpl< Container >::MatchAndExplain(), testing::internal::QuantifierMatcherImpl< Container >::MatchAndExplainImpl(), and MatchPrintAndExplain().

◆ PrintRawArrayTo()

template<typename T >

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

References UniversalPrint().

Referenced by UniversalPrintArray().

◆ PrintStringTo()

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

Referenced by PrintTo().

◆ PrintTo() [1/17]

template<typename T >

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

References DefaultPrintTo().

◆ PrintTo() [2/17]

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

◆ PrintTo() [3/17]

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

◆ PrintTo() [4/17]

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

inline

References PrintTo().

◆ PrintTo() [5/17]

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

inline

◆ PrintTo() [6/17]

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

◆ PrintTo() [7/17]

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

◆ PrintTo() [8/17]

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

inline

References PrintTo().

◆ PrintTo() [9/17]

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

inline

References PrintTo().

◆ PrintTo() [10/17]

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

inline

References PrintTo().

◆ PrintTo() [11/17]

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

inline

References PrintTo().

◆ PrintTo() [12/17]

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

inline

References PrintTo().

◆ PrintTo() [13/17]

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

◆ PrintTo() [14/17]

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

inline

References PrintTo().

◆ PrintTo() [15/17]

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

inline

References PrintStringTo().

◆ PrintTo() [16/17]

template<typename T1 , typename T2 >

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

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

◆ PrintTo() [17/17]

template<typename T >

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

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

Referenced by testing::internal::UniversalPrinter< T >::Print(), and PrintTo().

◆ ReportFailureInUnknownLocation()

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

◆ ReportUninterestingCall()

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

◆ ShouldRunTestOnShard()

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

◆ ShouldShard()

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

◆ ShouldUseColor()

GTEST_API_ bool testing::internal::ShouldUseColor ( bool stdout_is_tty )

◆ Shuffle()

template<typename E >

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

inline

References ShuffleRange().

◆ ShuffleRange()

template<typename E >

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

References testing::internal::Random::Generate(), and GTEST_CHECK_.

Referenced by Shuffle().

◆ SkipPrefix()

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

◆ StreamableToString()

template<typename T >

std::string testing::internal::StreamableToString ( const T & streamable )

◆ StringFromGTestEnv()

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

◆ StringStreamToString()

GTEST_API_ std::string testing::internal::StringStreamToString ( ::std::stringstream * stream )

Referenced by CmpHelperFloatingPointEQ().

◆ ToLower()

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

inline

◆ ToUpper()

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

inline

◆ TransformTupleValues()

template<typename Tuple , typename Func , typename OutIter >

OutIter testing::internal::TransformTupleValues	(	Func	f,
		const Tuple &	t,
		OutIter	out
	)

References testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >::Run().

Referenced by testing::internal::UnorderedElementsAreMatcher< MatcherTuple >::operator Matcher< Container >(), and testing::internal::ElementsAreMatcher< MatcherTuple >::operator Matcher< Container >().

◆ TupleMatches()

template<typename MatcherTuple , typename ValueTuple >

bool testing::internal::TupleMatches	(	const MatcherTuple &	matcher_tuple,
		const ValueTuple &	value_tuple
	)

References GTEST_COMPILE_ASSERT_, and testing::Matches().

Referenced by testing::internal::OnCallSpec< F >::Matches().

◆ UniversalPrint()

template<typename T >

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

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

◆ UniversalPrintArray() [1/3]

template<typename T >

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

References PrintRawArrayTo().

Referenced by testing::internal::UniversalPrinter< T[N]>::Print().

◆ UniversalPrintArray() [2/3]

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

◆ UniversalPrintArray() [3/3]

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

◆ UniversalTersePrint()

template<typename T >

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

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

◆ WideStringToUtf8()

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

◆ WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Variable Documentation

◆ g_gmock_implicit_sequence

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

Referenced by testing::internal::FunctionMockerBase< R(A1, A2)>::AddNewExpectation().

◆ g_help_flag

GTEST_API_ bool testing::internal::g_help_flag

◆ g_init_gtest_count

GTEST_API_ int testing::internal::g_init_gtest_count

◆ GTEST_ATTRIBUTE_UNUSED_

class testing::internal::GTestFlagSaver testing::internal::GTEST_ATTRIBUTE_UNUSED_

◆ kAlsoRunDisabledTestsFlag

const char testing::internal::kAlsoRunDisabledTestsFlag = "also_run_disabled_tests"

◆ kBreakOnFailureFlag

const char testing::internal::kBreakOnFailureFlag = "break_on_failure"

◆ kCatchExceptionsFlag

const char testing::internal::kCatchExceptionsFlag = "catch_exceptions"

◆ kColorFlag

const char testing::internal::kColorFlag = "color"

◆ 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"

◆ kFilterFlag

const char testing::internal::kFilterFlag = "filter"

◆ kInfoVerbosity

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

◆ kInternalRunDeathTestFlag

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

◆ kListTestsFlag

const char testing::internal::kListTestsFlag = "list_tests"

◆ kMaxBiggestInt

const BiggestInt testing::internal::kMaxBiggestInt

Initial value:

=

~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1))

testing::internal::BiggestInt

long long BiggestInt

Definition: dsd/test/gtest/include/gtest/internal/gtest-port.h:1649

◆ kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

Referenced by GetNextRandomSeed(), and GetRandomSeedFromFlag().

◆ kOutputFlag

const char testing::internal::kOutputFlag = "output"

◆ kPrintTimeFlag

const char testing::internal::kPrintTimeFlag = "print_time"

◆ kRandomSeedFlag

const char testing::internal::kRandomSeedFlag = "random_seed"

◆ kRepeatFlag

const char testing::internal::kRepeatFlag = "repeat"

◆ kShuffleFlag

const char testing::internal::kShuffleFlag = "shuffle"

◆ kStackTraceDepthFlag

const char testing::internal::kStackTraceDepthFlag = "stack_trace_depth"

◆ kStackTraceMarker

GTEST_API_ const char testing::internal::kStackTraceMarker

◆ kStreamResultToFlag

const char testing::internal::kStreamResultToFlag = "stream_result_to"

◆ kTestTypeIdInGoogleTest

GTEST_API_ const TypeId testing::internal::kTestTypeIdInGoogleTest

◆ kThrowOnFailureFlag

const char testing::internal::kThrowOnFailureFlag = "throw_on_failure"

◆ kWarningVerbosity

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BiggestInt

◆ Double

◆ ElementMatcherPair

◆ ElementMatcherPairs

◆ false_type

◆ Float

◆ Int32

◆ Int64

◆ IsContainer

◆ IsNotContainer

◆ MutexLock

◆ SetUpTestCaseFunc

◆ string

◆ TearDownTestCaseFunc

◆ TimeInMillis

◆ true_type

◆ TypeId

◆ UInt32

◆ UInt64

◆ wstring

Enumeration Type Documentation

◆ CallReaction [1/2]

◆ CallReaction [2/2]

◆ GTestLogSeverity [1/2]

◆ GTestLogSeverity [2/2]

◆ LogSeverity [1/2]

◆ LogSeverity [2/2]

◆ RelationToSource [1/2]

◆ RelationToSource [2/2]

◆ TypeKind [1/2]

◆ TypeKind [2/2]

Function Documentation

◆ AlwaysFalse()

◆ AlwaysTrue()

◆ AppendUserMessage()

◆ ArrayAwareFind()

◆ ArrayEq() [1/3]

◆ ArrayEq() [2/3]

◆ ArrayEq() [3/3]

◆ Assert()

◆ BoolFromGTestEnv()

◆ CaptureStderr()

◆ CaptureStdout()

◆ CaseInsensitiveCStringEquals() [1/2]

◆ CaseInsensitiveCStringEquals() [2/2]

◆ CaseInsensitiveStringEquals()

◆ CheckedDowncastToActualType()

◆ CmpHelperEQ() [1/2]

◆ CmpHelperEQ() [2/2]

◆ CmpHelperFloatingPointEQ()

◆ CmpHelperSTRCASEEQ()

◆ CmpHelperSTRCASENE()

◆ CmpHelperSTREQ() [1/2]

◆ CmpHelperSTREQ() [2/2]

◆ CmpHelperSTRNE() [1/2]

◆ CmpHelperSTRNE() [2/2]

◆ CodePointToUtf8()

◆ ConvertIdentifierNameToWords()

◆ CopyArray() [1/3]

◆ CopyArray() [2/3]

◆ CopyArray() [3/3]

◆ CountIf()

◆ DefaultPrintTo() [1/3]

◆ DefaultPrintTo() [2/3]

◆ DefaultPrintTo() [3/3]

◆ Delete() [1/2]

◆ Delete() [2/2]

◆ DoubleNearPredFormat()

◆ DownCast_()

◆ EqFailure()

◆ Expect() [1/2]

◆ Expect() [2/2]

◆ ExplainMatchFailureTupleTo()