testing::internal Namespace Reference

Namespaces
namespace	posix

Classes
class	ActionAdaptor
class	BuiltInDefaultValue
class	BuiltInDefaultValue< const T >
class	BuiltInDefaultValue< T * >
class	ReturnAction
class	ReturnNullAction
class	ReturnVoidAction
class	ReturnRefAction
class	ReturnRefOfCopyAction
class	DoDefaultAction
class	AssignAction
class	SetErrnoAndReturnAction
class	SetArgumentPointeeAction
class	SetArgumentPointeeAction< N, Proto, true >
class	InvokeWithoutArgsAction
class	InvokeMethodWithoutArgsAction
class	IgnoreResultAction
class	ReferenceWrapper
class	DoBothAction
class	InvokeHelper
class	InvokeHelper< R, ::std::tr1::tuple<> >
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	CallableHelper
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	WithArgsAction
struct	ExcessiveArg
class	ActionHelper
class	FunctionMockerBase
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	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	ArgsMatcherImpl
class	ArgsMatcher
struct	AllOfResult1
struct	AllOfResult2
struct	AllOfResult3
struct	AllOfResult4
struct	AllOfResult5
struct	AllOfResult6
struct	AllOfResult7
struct	AllOfResult8
struct	AllOfResult9
struct	AllOfResult10
struct	AnyOfResult1
struct	AnyOfResult2
struct	AnyOfResult3
struct	AnyOfResult4
struct	AnyOfResult5
struct	AnyOfResult6
struct	AnyOfResult7
struct	AnyOfResult8
struct	AnyOfResult9
struct	AnyOfResult10
class	DummyMatchResultListener
class	StreamMatchResultListener
class	MatcherBase
class	MatcherCastImpl
class	MatcherCastImpl< T, Matcher< U > >
class	MatcherCastImpl< T, Matcher< T > >
class	TuplePrefix
class	TuplePrefix< 0 >
class	TransformTupleValuesHelper
class	AnyMatcherImpl
class	AnythingMatcher
class	IsNullMatcher
class	NotNullMatcher
class	RefMatcher
class	RefMatcher< T & >
class	StrEqualityMatcher
class	HasSubstrMatcher
class	StartsWithMatcher
class	EndsWithMatcher
class	MatchesRegexMatcher
class	NotMatcherImpl
class	NotMatcher
class	BothOfMatcherImpl
class	BothOfMatcher
class	EitherOfMatcherImpl
class	EitherOfMatcher
class	TrulyMatcher
class	MatcherAsPredicate
class	PredicateFormatterFromMatcher
class	FloatingEqMatcher
class	PointeeMatcher
class	FieldMatcher
class	PropertyMatcher
struct	CallableTraits
struct	CallableTraits< ResType(*)(ArgType)>
class	ResultOfMatcher
class	SizeIsMatcher
class	ContainerEqMatcher
struct	LessComparator
class	WhenSortedByMatcher
class	PointwiseMatcher
class	QuantifierMatcherImpl
class	ContainsMatcherImpl
class	EachMatcherImpl
class	ContainsMatcher
class	EachMatcher
class	KeyMatcherImpl
class	KeyMatcher
class	PairMatcherImpl
class	PairMatcher
class	ElementsAreMatcherImpl
class	MatchMatrix
class	UnorderedElementsAreMatcherImplBase
class	UnorderedElementsAreMatcherImpl
struct	CastAndAppendTransform
class	UnorderedElementsAreMatcher
class	ElementsAreMatcher
class	UnorderedElementsAreArrayMatcher
class	ElementsAreArrayMatcher
class	InvokeAction
class	InvokeMethodAction
class	TypedExpectation
class	UntypedFunctionMockerBase
class	UntypedOnCallSpecBase
class	OnCallSpec
class	ExpectationBase
class	MockSpec
class	UntypedActionResultHolderBase
class	ActionResultHolder
class	ActionResultHolder< void >
class	IgnoredValue
struct	MatcherTuple
struct	MatcherTuple< ::std::tr1::tuple<> >
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	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)>
struct	PointeeOf
struct	PointeeOf< T * >
struct	LinkedPtrLessThan
struct	KindOf
struct	LosslessArithmeticConvertibleImpl
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To >
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To >
struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To >
struct	is_reference
struct	is_reference< T & >
struct	type_equals
struct	type_equals< T, T >
struct	remove_reference
struct	remove_reference< T & >
struct	DecayArray
struct	DecayArray< T[N]>
struct	DecayArray< T[]>
class	StlContainerView
class	StlContainerView< Element[N]>
class	StlContainerView< ::std::tr1::tuple< ElementPointer, Size > >
struct	RemoveConstFromKey
struct	RemoveConstFromKey< std::pair< const K, V > >
struct	BooleanConstant
class	UniversalPrinter
class	UniversalPrinter< T[N]>
class	UniversalPrinter< T & >
class	UniversalTersePrinter
class	UniversalTersePrinter< T & >
class	UniversalTersePrinter< T[N]>
class	UniversalTersePrinter< const char * >
class	UniversalTersePrinter< char * >
class	UniversalTersePrinter< wchar_t * >
class	SingleFailureChecker
class	HasNewFatalFailureHelper
class	FormatForComparison
class	FormatForComparison< ToPrint[N], OtherOperand >
class	EqHelper
class	EqHelper< true >
class	AssertHelper
class	FilePath
class	ScopedTrace
class	FloatingPoint
class	TypeIdHelper
class	TestFactoryBase
class	TestFactoryImpl
struct	ConstCharPtr
class	Random
struct	CompileAssertTypesEqual
struct	CompileAssertTypesEqual< T, T >
struct	RemoveReference
struct	RemoveReference< T & >
struct	RemoveConst
struct	RemoveConst< const T >
struct	RemoveConst< const T[N]>
struct	AddReference
struct	AddReference< T & >
class	ImplicitlyConvertible
struct	IsAProtocolMessage
struct	EnableIf
struct	EnableIf< true >
class	NativeArray
class	linked_ptr_internal
class	linked_ptr
struct	CompileAssert
struct	StaticAssertTypeEqHelper
struct	StaticAssertTypeEqHelper< T, T >
class	scoped_ptr
class	RE
class	GTestLog
class	Mutex
class	GTestMutexLock
class	ThreadLocal
struct	bool_constant
struct	is_pointer
struct	is_pointer< T * >
struct	IteratorTraits
struct	IteratorTraits< T * >
struct	IteratorTraits< const T * >
class	TypeWithSize
class	TypeWithSize< 4 >
class	TypeWithSize< 8 >
class	String
class	GTestFlagSaver
class	TestPropertyKeyIs
class	UnitTestOptions
class	OsStackTraceGetterInterface
class	OsStackTraceGetter
struct	TraceInfo
class	DefaultGlobalTestPartResultReporter
class	DefaultPerThreadTestPartResultReporter
class	UnitTestImpl
class	TestResultAccessor

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 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_ (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_ (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_ (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<>
void	Invalid< void > ()
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_
template<typename T>
bool	TypeIdHelper< T >::dummy_ = false
template<typename From, typename To>
const bool	ImplicitlyConvertible< From, To >::value
template<bool bool_value>
const bool	bool_constant< bool_value >::value
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

(

)

References GTEST_API_.

Referenced by AlwaysFalse().

AppendUserMessage()

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

References GTEST_API_.

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

References ArrayEq().

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

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::ExpectationBase::AssertSpecProperty(), testing::internal::UntypedOnCallSpecBase::AssertSpecProperty(), testing::internal::BuiltInDefaultValue< T >::Get(), testing::Action< F >::Perform(), and testing::internal::FunctionMockerBase< F >::PerformDefaultAction().

BoolFromGTestEnv()

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

CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr

(

)

References GTEST_API_.

CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout

(

)

References GTEST_API_.

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(), and CaseInsensitiveStringEquals().

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

CheckedDowncastToActualType()

template<class Derived, class Base>

Derived * testing::internal::CheckedDowncastToActualType

(

Base *

base

)

References GTEST_CHECK_.

CmpHelperEQ() [1/2]

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

References CmpHelperEQ(), and GTEST_API_.

CmpHelperEQ() [2/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(), CmpHelperEQ(), EqFailure(), and FormatForComparisonFailureMessage().

Referenced by CmpHelperEQ(), CmpHelperEQ(), testing::internal::EqHelper< lhs_is_null_literal >::Compare(), testing::internal::EqHelper< lhs_is_null_literal >::Compare(), testing::internal::EqHelper< true >::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(), CmpHelperFloatingPointEQ(), EqFailure(), and StringStreamToString().

Referenced by CmpHelperFloatingPointEQ().

CmpHelperSTRCASEEQ()

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

References CmpHelperSTRCASEEQ(), and GTEST_API_.

Referenced by CmpHelperSTRCASEEQ().

CmpHelperSTRCASENE()

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

References CmpHelperSTRCASENE(), and GTEST_API_.

Referenced by CmpHelperSTRCASENE().

CmpHelperSTREQ() [1/2]

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

References CmpHelperSTREQ(), and GTEST_API_.

Referenced by CmpHelperSTREQ(), and CmpHelperSTREQ().

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 )

References CmpHelperSTREQ(), and GTEST_API_.

CmpHelperSTRNE() [1/2]

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

References CmpHelperSTRNE(), and GTEST_API_.

Referenced by CmpHelperSTRNE(), and CmpHelperSTRNE().

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 )

References CmpHelperSTRNE(), and GTEST_API_.

CodePointToUtf8()

GTEST_API_ std::string testing::internal::CodePointToUtf8

(

UInt32

code_point

)

References GTEST_API_.

ConvertIdentifierNameToWords()

GTEST_API_ string testing::internal::ConvertIdentifierNameToWords

(

const char *

id_name

)

References GTEST_API_.

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 )

References CopyArray().

Referenced by CopyArray(), and CopyArray().

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	,
		false_type	,
		const T &	value,
		::std::ostream *	os )

References testing_internal::DefaultPrintNonContainerTo(), and ImplicitlyConvertible< From, To >::value.

DefaultPrintTo() [3/3]

template<typename T>

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

References IsTrue(), and testing::internal::ImplicitlyConvertible< From, To >::value.

Delete() [1/2]

template<typename T>

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

static

Delete() [2/2]

template<typename T>

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 )

References DoubleNearPredFormat(), and GTEST_API_.

Referenced by DoubleNearPredFormat().

DownCast_()

template<typename To, typename From>

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

inline

References GTEST_CHECK_, and ImplicitCast_().

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 )

References GTEST_API_.

Referenced by CmpHelperEQ(), and CmpHelperFloatingPointEQ().

Expect() [1/2]

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

inline

References Expect().

Expect() [2/2]

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

inline

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

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 )

References GTEST_API_.

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

)

References GTEST_API_.

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

References testing::internal::FormatForComparison< ToPrint, OtherOperand >::Format(), FormatForComparisonFailureMessage(), and ImplicitlyConvertible< From, To >::value.

Referenced by CmpHelperEQ(), and FormatForComparisonFailureMessage().

FormatMatcherDescription()

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

References GTEST_API_.

FormatTimeInMillisAsSeconds()

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

(

TimeInMillis

ms

)

References GTEST_API_.

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 )

References GTEST_API_.

GetCapturedStderr()

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

(

)

References GTEST_API_.

GetCapturedStdout()

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

(

)

References GTEST_API_.

GetCurrentExecutableName()

GTEST_API_ FilePath testing::internal::GetCurrentExecutableName

(

)

References GTEST_API_.

GetCurrentOsStackTraceExceptTop()

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

References GTEST_API_.

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

(

)

References GTEST_API_.

GetThreadCount()

GTEST_API_ size_t testing::internal::GetThreadCount

(

)

References GTEST_API_.

GetTimeInMillis()

GTEST_API_ TimeInMillis testing::internal::GetTimeInMillis

(

)

References GTEST_API_.

Referenced by GetRandomSeedFromFlag().

GetTypeId()

template<typename T>

TypeId testing::internal::GetTypeId

(

)

References testing::internal::TypeIdHelper< T >::dummy_.

GetTypeName()

template<typename T>

std::string testing::internal::GetTypeName

(

)

Referenced by MatchPrintAndExplain().

GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

References testing::UnitTest::GetInstance().

Referenced by testing::UnitTest::internal::GetUnitTestImpl.

GMOCK_DECLARE_KIND_() [1/16]

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

References kBool.

GMOCK_DECLARE_KIND_() [2/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [3/16]

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

References kFloatingPoint.

GMOCK_DECLARE_KIND_() [4/16]

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

References kFloatingPoint.

GMOCK_DECLARE_KIND_() [5/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [6/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [7/16]

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

References kFloatingPoint.

GMOCK_DECLARE_KIND_() [8/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [9/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [10/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [11/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [12/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [13/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [14/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [15/16]

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

References kInteger.

GMOCK_DECLARE_KIND_() [16/16]

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

References kInteger.

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [15/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [16/16]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_

(

void

)

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [1/6]

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

References testing::Eq().

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [2/6]

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

References testing::Ge().

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [3/6]

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

References testing::Gt().

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [4/6]

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

References testing::Le().

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [5/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_

(

Lt

)

References testing::Lt().

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_() [6/6]

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

References testing::Ne().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [1/6]

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

References testing::Eq().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [2/6]

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

References testing::Ge().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [3/6]

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

References testing::Gt().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [4/6]

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

References testing::Le().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [5/6]

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_

(

Lt

)

References testing::Lt().

GMOCK_IMPLEMENT_COMPARISON_MATCHER_() [6/6]

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

References testing::Ne().

GTEST_DECLARE_STATIC_MUTEX_() [1/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_gmock_mutex

)

References GTEST_API_.

GTEST_DECLARE_STATIC_MUTEX_() [2/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_linked_ptr_mutex

)

References GTEST_API_.

GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_

(

internal_run_death_test

)

GTEST_IMPL_CMP_HELPER_() [1/5]

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

GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

GT

)

GTEST_IMPL_CMP_HELPER_() [3/5]

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

GTEST_IMPL_CMP_HELPER_() [4/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

LT

)

GTEST_IMPL_CMP_HELPER_() [5/5]

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

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

Referenced by DownCast_(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NaggyMock< MockClass >::NaggyMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), testing::NiceMock< MockClass >::NiceMock(), PrintTo(), PrintTo(), PrintTo(), PrintTo(), PrintTo(), PrintTo(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::StrictMock< MockClass >::StrictMock(), testing::NaggyMock< MockClass >::~NaggyMock(), testing::NiceMock< MockClass >::~NiceMock(), and testing::StrictMock< MockClass >::~StrictMock().

Int32FromEnvOrDie()

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

References GTEST_API_.

Int32FromGTestEnv()

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

References GTEST_API_.

Invalid()

template<typename T>

T testing::internal::Invalid ( )

inline

Referenced by testing::internal::BuiltInDefaultValue< T >::Get().

Invalid< void >() [1/2]

template<>

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

inline

Invalid< void >() [2/2]

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 )

Referenced by PrintTo().

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

(

...

)

)[2]

IsNullLiteralHelper() [2/2]

char testing::internal::IsNullLiteralHelper

(

Secret *

p

)

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

)

References GTEST_API_.

Referenced by DefaultPrintTo(), and testing::internal::scoped_ptr< T >::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 )

References GTEST_API_.

LogIsVisible()

GTEST_API_ bool testing::internal::LogIsVisible

(

LogSeverity

severity

)

References GTEST_API_.

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 )

References GTEST_API_, and LogWithLocation().

Referenced by testing::internal::MockSpec< F >::InternalDefaultActionSetAt(), testing::internal::MockSpec< F >::InternalExpectedAt(), and LogWithLocation().

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 )

References GTEST_API_.

Referenced by testing::TestInfo::internal::MakeAndRegisterTestInfo.

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 GetTypeName(), ImplicitlyConvertible< From, To >::value, testing::MatchResultListener::IsInterested(), IsReadableTypeName(), testing::internal::MatcherBase< T >::MatchAndExplain(), testing::internal::MatcherBase< T >::Matches(), PrintIfNotEmpty(), testing::StringMatchResultListener::str(), testing::MatchResultListener::stream(), UniversalPrint(), and testing::Value().

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 )

References GTEST_API_.

ParseGoogleTestFlagsOnly() [2/2]

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

References GTEST_API_.

ParseInt32()

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

References ImplicitlyConvertible< From, To >::value.

ParseInt32Flag()

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

References GTEST_API_, and ImplicitlyConvertible< From, To >::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::ElementsAreMatcherImpl< Container >::MatchAndExplain(), testing::internal::PairMatcherImpl< PairType >::MatchAndExplain(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::MatchAndExplain(), testing::internal::SizeIsMatcher< SizeMatcher >::Impl< Container >::MatchAndExplain(), testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >::Impl< LhsContainer >::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 )

References GTEST_API_.

Referenced by PrintTo().

PrintTo() [1/17]

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

inline

PrintTo() [2/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [3/17]

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

inline

References PrintTo().

PrintTo() [4/17]

template<typename T1, typename T2>

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

References ImplicitlyConvertible< From, To >::value, and testing::internal::UniversalPrinter< T >::Print().

PrintTo() [5/17]

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

inline

References PrintStringTo().

PrintTo() [6/17]

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

References GTEST_API_.

PrintTo() [7/17]

template<typename T>

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

References ImplicitlyConvertible< From, To >::value, and testing::internal::UniversalPrinter< T >::Print().

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

PrintTo() [8/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [9/17]

template<typename T>

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

References DefaultPrintTo(), ImplicitlyConvertible< From, To >::value, and IsContainerTest().

PrintTo() [10/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [11/17]

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

References GTEST_API_.

PrintTo() [12/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [13/17]

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

References GTEST_API_.

PrintTo() [14/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [15/17]

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

References GTEST_API_.

PrintTo() [16/17]

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

inline

References ImplicitCast_(), and PrintTo().

PrintTo() [17/17]

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

References GTEST_API_.

ReportFailureInUnknownLocation()

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

Referenced by testing::UnitTest::internal::ReportFailureInUnknownLocation.

ReportUninterestingCall()

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

References ReportUninterestingCall().

Referenced by ReportUninterestingCall().

ShouldRunTestOnShard()

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

References GTEST_API_.

ShouldShard()

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

References GTEST_API_.

ShouldUseColor()

GTEST_API_ bool testing::internal::ShouldUseColor

(

bool

stdout_is_tty

)

References GTEST_API_.

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 )

References GTEST_API_.

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

)

References GTEST_API_.

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::ElementsAreMatcher< MatcherTuple >::operator Matcher< Container >(), and testing::internal::UnorderedElementsAreMatcher< 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 ImplicitlyConvertible< From, To >::value, and testing::internal::UniversalPrinter< T >::Print().

Referenced by DefaultPrintTo(), testing::internal::ContainerEqMatcher< Container >::DescribeNegationTo(), testing::internal::EndsWithMatcher< StringType >::DescribeNegationTo(), testing::internal::HasSubstrMatcher< StringType >::DescribeNegationTo(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::DescribeNegationTo(), testing::internal::StartsWithMatcher< StringType >::DescribeNegationTo(), testing::internal::ContainerEqMatcher< Container >::DescribeTo(), testing::internal::EndsWithMatcher< StringType >::DescribeTo(), testing::internal::HasSubstrMatcher< StringType >::DescribeTo(), testing::internal::StartsWithMatcher< StringType >::DescribeTo(), testing::internal::TuplePrefix< N >::ExplainMatchFailuresTo(), testing::internal::ContainerEqMatcher< Container >::MatchAndExplain(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::MatchAndExplain(), testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >::Impl< LhsContainer >::MatchAndExplain(), MatchPrintAndExplain(), testing::internal::UniversalPrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T >::Print(), testing::internal::UniversalTersePrinter< const char * >::Print(), testing::internal::UniversalTersePrinter< T & >::Print(), and PrintRawArrayTo().

UniversalPrintArray() [1/3]

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

References GTEST_API_.

UniversalPrintArray() [2/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() [3/3]

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

References GTEST_API_.

UniversalTersePrint()

template<typename T>

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

References ImplicitlyConvertible< From, To >::value, and testing::internal::UniversalTersePrinter< T >::Print().

WideStringToUtf8()

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

References GTEST_API_.

WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded

(

)

Variable Documentation

bool_constant< bool_value >::value

template<bool bool_value>

const bool testing::internal::bool_constant< bool_value >::value

g_gmock_implicit_sequence

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

extern

Referenced by testing::internal::FunctionMockerBase< F >::AddNewExpectation().

g_help_flag

GTEST_API_ bool testing::internal::g_help_flag

extern

g_init_gtest_count

GTEST_API_ int testing::internal::g_init_gtest_count

extern

GTEST_ATTRIBUTE_UNUSED_

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

ImplicitlyConvertible< From, To >::value

template<typename From, typename To>

const bool testing::internal::ImplicitlyConvertible< From, To >::value

Referenced by testing::internal::UnitTestImpl::::testing::UnitTest, testing::internal::AssignAction< T1, T2 >::AssignAction(), testing::internal::MatcherCastImpl< T, M >::Cast(), DefaultPrintTo(), testing::internal::TuplePrefix< N >::ExplainMatchFailuresTo(), testing::internal::FormatForComparison< ToPrint, OtherOperand >::Format(), testing::internal::FormatForComparison< ToPrint[N], OtherOperand >::Format(), testing::internal::String::FormatByte(), FormatForComparisonFailureMessage(), testing::internal::String::FormatHexInt(), testing::internal::String::FormatIntWidth2(), testing::internal::FieldMatcher< Class, FieldType >::MatchAndExplain(), testing::internal::FloatingEqMatcher< FloatType >::Impl< T >::MatchAndExplain(), testing::internal::PropertyMatcher< Class, PropertyType >::MatchAndExplain(), MatchPrintAndExplain(), ParseInt32(), ParseInt32Flag(), testing::internal::UniversalPrinter< T >::Print(), testing::internal::UniversalPrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T >::Print(), testing::internal::UniversalTersePrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T[N]>::Print(), PrintTo(), PrintTo(), PrintTo(), testing::internal::ReturnAction< R >::ReturnAction(), testing::internal::ReturnRefOfCopyAction< T >::ReturnRefOfCopyAction(), testing::internal::ThreadLocal< T >::set(), testing::internal::SetArgumentPointeeAction< N, A, kIsProto >::SetArgumentPointeeAction(), testing::internal::ThreadLocal< T >::ThreadLocal(), UniversalPrint(), and UniversalTersePrint().

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

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

extern

kStreamResultToFlag

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

kTestTypeIdInGoogleTest

GTEST_API_ const TypeId testing::internal::kTestTypeIdInGoogleTest

extern

kThrowOnFailureFlag

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

kWarningVerbosity

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

TypeIdHelper< T >::dummy_

template<typename T>

bool testing::internal::TypeIdHelper< T >::dummy_ = false