testing::internal Namespace Reference

Namespaces
	edit_distance
	invoke_argument
	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
struct	AnyEq
struct	AnyGe
struct	AnyGt
struct	AnyLe
struct	AnyLt
class	AnyMatcherImpl
struct	AnyNe
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
class	Base
class	BeginEndDistanceIsMatcher
struct	bool_constant
struct	BooleanConstant
class	BothOfMatcher
class	BothOfMatcherImpl
class	BoundSecondMatcher
class	BuiltInDefaultValue
class	BuiltInDefaultValue< ::std::string >
class	BuiltInDefaultValue< bool >
class	BuiltInDefaultValue< char >
class	BuiltInDefaultValue< const T >
class	BuiltInDefaultValue< double >
class	BuiltInDefaultValue< float >
class	BuiltInDefaultValue< Int64 >
class	BuiltInDefaultValue< signed char >
class	BuiltInDefaultValue< signed int >
class	BuiltInDefaultValue< signed long >
class	BuiltInDefaultValue< signed short >
class	BuiltInDefaultValue< T * >
class	BuiltInDefaultValue< UInt64 >
class	BuiltInDefaultValue< unsigned char >
class	BuiltInDefaultValue< unsigned int >
class	BuiltInDefaultValue< unsigned long >
class	BuiltInDefaultValue< unsigned short >
class	BuiltInDefaultValue< void >
struct	BuiltInDefaultValueGetter
struct	BuiltInDefaultValueGetter< T, false >
struct	ByMoveWrapper
struct	CallableTraits
struct	CallableTraits< ResType(*)(ArgType)>
class	Castable
struct	CastAndAppendTransform
struct	CodeLocation
class	ComparisonBase
struct	CompileAssert
struct	CompileAssertTypesEqual
struct	CompileAssertTypesEqual< T, T >
class	ConstAndNonConstCastable
class	ConstCastable
struct	ConstCharPtr
class	ContainerEqMatcher
class	ContainsMatcher
class	ContainsMatcherImpl
struct	DecayArray
struct	DecayArray< T[]>
struct	DecayArray< T[N]>
class	DefaultGlobalTestPartResultReporter
class	DefaultPerThreadTestPartResultReporter
class	Derived
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	EnvironmentInvocationCatcher
class	Eq2Matcher
class	EqHelper
class	EqHelper< true >
class	EqMatcher
class	EventRecordingListener
struct	ExcessiveArg
class	ExpectationBase
class	ExpectationTester
class	FieldMatcher
class	FilePath
class	FinalSuccessChecker
class	FloatingEqMatcher
class	FloatingPoint
class	FormatForComparison
class	FormatForComparison< char *, OtherOperand >
class	FormatForComparison< char *,::std::string >
class	FormatForComparison< const char *, OtherOperand >
class	FormatForComparison< const char *,::std::string >
class	FormatForComparison< const wchar_t *, OtherOperand >
class	FormatForComparison< ToPrint[N], OtherOperand >
class	FormatForComparison< wchar_t *, 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	Ge2Matcher
class	GeMatcher
class	GoogleTestFailureReporter
class	Gt2Matcher
class	GTestFlagSaver
class	GTestLog
class	GTestMutexLock
class	GtMatcher
class	HasNewFatalFailureHelper
class	HasSubstrMatcher
class	IgnoredValue
class	IgnoreResultAction
class	ImplicitlyConvertible
class	InvokeAction
class	InvokeHelper
class	InvokeHelper< R,::testing::tuple< A1 > >
class	InvokeHelper< R,::testing::tuple< A1, A2 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >
class	InvokeHelper< R,::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > >
class	InvokeHelper< R,::testing::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	KindOf< bool >
struct	KindOf< char >
struct	KindOf< double >
struct	KindOf< float >
struct	KindOf< int >
struct	KindOf< Int64 >
struct	KindOf< long >
struct	KindOf< long double >
struct	KindOf< short >
struct	KindOf< signed char >
struct	KindOf< UInt64 >
struct	KindOf< unsigned char >
struct	KindOf< unsigned int >
struct	KindOf< unsigned long >
struct	KindOf< unsigned short >
struct	KindOf< wchar_t >
class	Le2Matcher
class	LeMatcher
struct	LessByName
struct	LessComparator
class	linked_ptr
class	linked_ptr_internal
struct	LinkedPtrLessThan
class	ListenerTest
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	Lt2Matcher
class	LtMatcher
class	MatcherAsPredicate
class	MatcherBase
class	MatcherCastImpl
class	MatcherCastImpl< T, Matcher< T > >
class	MatcherCastImpl< T, Matcher< U > >
struct	MatcherTuple
struct	MatcherTuple< ::testing::tuple< A1 > >
struct	MatcherTuple< ::testing::tuple< A1, A2 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >
struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > >
struct	MatcherTuple< ::testing::tuple<> >
class	MatchesRegexMatcher
class	MatchMatrix
class	MaxBipartiteMatchState
class	MockSpec
class	Mutex
class	NativeArray
class	Ne2Matcher
class	NeMatcher
class	NoDefaultContructor
class	NotMatcher
class	NotMatcherImpl
class	NotNullMatcher
class	OnCallSpec
class	OsStackTraceGetter
class	OsStackTraceGetterInterface
class	PairMatchBase
class	PairMatcher
class	PairMatcherImpl
class	PointeeMatcher
struct	PointeeOf
struct	PointeeOf< T * >
class	PointwiseMatcher
class	PredicateFormatterFromMatcher
class	PrettyUnitTestResultPrinter
class	PropertyMatcher
class	QuantifierMatcherImpl
class	Random
class	RE
class	ReferenceOrValueWrapper
class	ReferenceOrValueWrapper< T & >
class	ReferenceWrapper
class	RefMatcher
class	RefMatcher< T & >
struct	RelationToSourceCopy
struct	RelationToSourceReference
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	ScopedPrematureExitFile
class	ScopedTrace
class	SelectArgs
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9,-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,-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,-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,-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,-1,-1,-1,-1,-1,-1,-1,-1,-1 >
class	SelectArgs< Result, ArgumentTuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-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< ::testing::tuple< ElementPointer, Size > >
class	StlContainerView< Element[N]>
class	StreamMatchResultListener
class	StrEqualityMatcher
class	String
class	TestCaseNameIs
class	TestEventListenersAccessor
class	TestEventRepeater
class	TestFactoryBase
class	TestFactoryImpl
class	TestPropertyKeyIs
class	TestResultAccessor
class	ThreadLocal
class	To
struct	TraceInfo
class	TransformTupleValuesHelper
class	TrulyMatcher
class	TupleFields
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8,-1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7,-1,-1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6,-1,-1,-1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5,-1,-1,-1,-1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4,-1,-1,-1,-1,-1 >
class	TupleFields< Tuple, k0, k1, k2, k3,-1,-1,-1,-1,-1,-1 >
class	TupleFields< Tuple, k0, k1, k2,-1,-1,-1,-1,-1,-1,-1 >
class	TupleFields< Tuple, k0, k1,-1,-1,-1,-1,-1,-1,-1,-1 >
class	TupleFields< Tuple, k0,-1,-1,-1,-1,-1,-1,-1,-1,-1 >
class	TupleFields< Tuple,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 >
struct	TuplePolicy
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	UnitTestHelper
class	UnitTestImpl
class	UnitTestOptions
class	UnitTestRecordPropertyTestHelper
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	WhenDynamicCastToMatcher
class	WhenDynamicCastToMatcher< To & >
class	WhenDynamicCastToMatcherBase
class	WhenSortedByMatcher
class	WithArgsAction
class	XmlUnitTestResultPrinter

Typedefs
typedef ::std::pair< size_t, size_t >	ElementMatcherPair
typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs
typedef ::std::vector< string >	Strings
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,   kAllow, kWarn, kFail, kDefault = kWarn }
enum	TypeKind {   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther }
enum	LogSeverity {   kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1,   kInfo = 0, kWarning = 1 }
enum	GTestLogSeverity {   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }
enum	CharFormat {   kAsIs, kHexEscape, kSpecialEscape, kAsIs,   kHexEscape, kSpecialEscape, kAsIs, kHexEscape,   kSpecialEscape }
enum	GTestColor {   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }
enum	CallReaction {   kAllow, kWarn, kFail, kDefault = kWarn,   kAllow, kWarn, kFail, kDefault = kWarn,   kAllow, kWarn, kFail, kDefault = kWarn }
enum	TypeKind {   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther }
enum	LogSeverity {   kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1,   kInfo = 0, kWarning = 1 }
enum	GTestLogSeverity {   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }
enum	CharFormat {   kAsIs, kHexEscape, kSpecialEscape, kAsIs,   kHexEscape, kSpecialEscape, kAsIs, kHexEscape,   kSpecialEscape }
enum	GTestColor {   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }
enum	CallReaction {   kAllow, kWarn, kFail, kDefault = kWarn,   kAllow, kWarn, kFail, kDefault = kWarn,   kAllow, kWarn, kFail, kDefault = kWarn }
enum	TypeKind {   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther,   kBool, kInteger, kFloatingPoint, kOther }
enum	LogSeverity {   kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1,   kInfo = 0, kWarning = 1 }
enum	GTestLogSeverity {   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL,   GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }
enum	CharFormat {   kAsIs, kHexEscape, kSpecialEscape, kAsIs,   kHexEscape, kSpecialEscape, kAsIs, kHexEscape,   kSpecialEscape }
enum	GTestColor {   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,   COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

Functions
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)
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)
template<typename M >
PredicateFormatterFromMatcher< M >	MakePredicateFormatterFromMatcher (M matcher)
GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)
GTEST_API_ bool	FindPairing (const MatchMatrix &matrix, MatchResultListener *listener)
template<typename Tuple2Matcher , typename Second >
BoundSecondMatcher< Tuple2Matcher, Second >	MatcherBindSecond (const Tuple2Matcher &tm, const Second &second)
GTEST_API_ string	FormatMatcherDescription (bool negation, const char *matcher_name, const Strings &param_values)
template<typename InputIterator , typename OutputIterator >
OutputIterator	CopyElements (InputIterator first, InputIterator last, OutputIterator output)
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)
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 ()
GTEST_API_ FailureReporterInterface *	GetFailureReporter ()
static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)
GTEST_API_ string	JoinAsTuple (const Strings &fields)
static void	LogElementMatcherPairVec (const ElementMatcherPairs &pairs,::std::ostream *stream)
GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)
static const char *	ParseGoogleMockFlagValue (const char *str, const char *flag, bool def_optional)
static bool	ParseGoogleMockBoolFlag (const char *str, const char *flag, bool *value)
template<typename String >
static bool	ParseGoogleMockStringFlag (const char *str, const char *flag, String *value)
template<typename CharType >
void	InitGoogleMockImpl (int *argc, CharType **argv)
template<typename T >
std::string	StreamableToString (const T &streamable)
template<typename T1 , typename T2 >
std::string	FormatForComparisonFailureMessage (const T1 &value, const T2 &)
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)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQFailure (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
GTEST_API_ AssertionResult	CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, BiggestInt lhs, BiggestInt rhs)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperOpFailure (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperNE (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2)
GTEST_API_ AssertionResult	CmpHelperNE (const char *expr1, const char *expr2, BiggestInt val1, BiggestInt val2)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperLE (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2)
GTEST_API_ AssertionResult	CmpHelperLE (const char *expr1, const char *expr2, BiggestInt val1, BiggestInt val2)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperLT (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2)
GTEST_API_ AssertionResult	CmpHelperLT (const char *expr1, const char *expr2, BiggestInt val1, BiggestInt val2)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperGE (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2)
GTEST_API_ AssertionResult	CmpHelperGE (const char *expr1, const char *expr2, BiggestInt val1, BiggestInt val2)
template<typename T1 , typename T2 >
AssertionResult	CmpHelperGT (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2)
GTEST_API_ AssertionResult	CmpHelperGT (const char *expr1, const char *expr2, BiggestInt val1, BiggestInt val2)
GTEST_API_ AssertionResult	CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRCASEEQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ AssertionResult	CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
template<typename RawType >
AssertionResult	CmpHelperFloatingPointEQ (const char *lhs_expression, const char *rhs_expression, RawType lhs_value, RawType rhs_value)
GTEST_API_ AssertionResult	DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
	GTEST_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_ std::string	DiffStrings (const std::string &left, const std::string &right, size_t *total_line_count)
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, CodeLocation code_location, 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)
bool	IsTrue (bool condition)
::std::string	FormatFileLocation (const char *file, int line)
::std::string	FormatCompilerIndependentFileLocation (const char *file, int line)
void	LogToStderr ()
void	FlushInfoLog ()
template<typename T >
const T &	move (const T &t)
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)
void	CaptureStdout ()
std::string	GetCapturedStdout ()
void	CaptureStderr ()
std::string	GetCapturedStderr ()
std::string	TempDir ()
size_t	GetFileSize (FILE *file)
std::string	ReadEntireFile (FILE *file)
const ::std::vector< testing::internal::string > &	GetArgvs ()
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)
std::string	StripTrailingSpaces (std::string str)
bool	ParseInt32 (const Message &src_text, const char *str, Int32 *value)
bool	BoolFromGTestEnv (const char *flag, bool default_val)
Int32	Int32FromGTestEnv (const char *flag, Int32 default_val)
std::string	StringFromGTestEnv (const char *flag, const char *default_val)
GTEST_API_ std::string	StringStreamToString (::std::stringstream *stream)
template<typename T >
std::string	GetTypeName ()
	GTEST_DEFINE_string_ (internal_run_death_test,"","Indicates the file, line number, temporal index of ""the single death test to run, and a file descriptor to ""which a success code may be sent, all separated by ""the '|' characters. This flag is specified if and only if the current ""process is a sub-process launched for running a thread-safe ""death test. FOR INTERNAL USE ONLY.")
static bool	IsPathSeparator (char c)
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)
static std::string	FlagToEnvVar (const char *flag)
bool	IsPrintableAscii (wchar_t c)
template<typename UnsignedChar , typename Char >
static CharFormat	PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)
template<typename UnsignedChar , typename Char >
void	PrintCharAndCodeTo (Char c, ostream *os)
void	PrintTo (wchar_t wc, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
void	UniversalPrintArray (const char *begin, size_t len, ostream *os)
void	UniversalPrintArray (const wchar_t *begin, size_t len, ostream *os)
void	PrintTo (const char *s, ostream *os)
void	PrintTo (const wchar_t *s, ostream *os)
void	PrintStringTo (const ::std::string &s, ostream *os)
static bool	GTestIsInitialized ()
static int	SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)
static bool	TestCasePassed (const TestCase *test_case)
static bool	TestCaseFailed (const TestCase *test_case)
static bool	ShouldRunTestCase (const TestCase *test_case)
GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)
AssertionResult	HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const string &substr)
void	SplitString (const ::std::string &str, char delimiter,::std::vector< ::std::string > *dest)
template<typename RawType >
AssertionResult	FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
UInt32	ChopLowBits (UInt32 *bits, int n)
bool	IsUtf16SurrogatePair (wchar_t first, wchar_t second)
UInt32	CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
template<class T , typename Result >
Result	HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
template<class T , typename Result >
Result	HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
static std::string	PrintTestPartResultToString (const TestPartResult &test_part_result)
static void	PrintTestPartResult (const TestPartResult &test_part_result)
const char *	GetAnsiColorCode (GTestColor color)
void	ColoredPrintf (GTestColor color, const char *fmt,...)
void	PrintFullTestCommentIfPresent (const TestInfo &test_info)
static bool	PortableLocaltime (time_t seconds, struct tm *out)
static void	SetUpEnvironment (Environment *env)
static void	TearDownEnvironment (Environment *env)
static void	PrintOnOneLine (const char *str, int max_length)
const char *	ParseFlagValue (const char *str, const char *flag, bool def_optional)
bool	ParseBoolFlag (const char *str, const char *flag, bool *value)
bool	ParseStringFlag (const char *str, const char *flag, std::string *value)
static bool	HasGoogleTestFlagPrefix (const char *str)
static void	PrintColorEncoded (const char *str)
bool	ParseGoogleTestFlag (const char *const arg)
template<typename CharType >
void	ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
template<typename CharType >
void	InitGoogleTestImpl (int *argc, CharType **argv)
	TEST_F (ListenerTest, DoesFoo)
	TEST_F (ListenerTest, DoesBar)
	TEST (IsXDigitTest, WorksForNarrowAscii)
	TEST (IsXDigitTest, ReturnsFalseForNarrowNonAscii)
	TEST (IsXDigitTest, WorksForWideAscii)
	TEST (IsXDigitTest, ReturnsFalseForWideNonAscii)
	TEST (ImplicitCastTest, ConvertsPointers)
	TEST (ImplicitCastTest, CanUseInheritance)
	TEST (ImplicitCastTest, CanUseNonConstCastOperator)
	TEST (ImplicitCastTest, CanUseConstCastOperatorOnConstValues)
	TEST (ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately)
	TEST (ImplicitCastTest, CanUseImplicitConstructor)
	TEST (IteratorTraitsTest, WorksForSTLContainerIterators)
	TEST (IteratorTraitsTest, WorksForPointerToNonConst)
	TEST (IteratorTraitsTest, WorksForPointerToConst)
	TEST (ScopedPtrTest, DefinesElementType)
	TEST (GtestCheckSyntaxTest, BehavesLikeASingleStatement)
	TEST (GtestCheckSyntaxTest, WorksWithSwitch)
	TEST (FormatFileLocationTest, FormatsFileLocation)
	TEST (FormatFileLocationTest, FormatsUnknownFile)
	TEST (FormatFileLocationTest, FormatsUknownLine)
	TEST (FormatFileLocationTest, FormatsUknownFileAndLine)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsFileLocation)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFile)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownLine)
	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine)
	TEST (GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads)
	TEST (GtestCheckDeathTest, DiesWithCorrectOutputOnFailure)
	TEST (RegexEngineSelectionTest, SelectsCorrectRegexEngine)
	TEST (CaptureTest, CapturesStdout)
	TEST (CaptureTest, CapturesStderr)
	TEST (CaptureTest, CapturesStdoutAndStderr)
	TEST (CaptureDeathTest, CannotReenterStdoutCapture)
	TEST (ThreadLocalTest, DefaultConstructorInitializesToDefaultValues)
	TEST (ThreadLocalTest, SingleParamConstructorInitializesToParam)
	TEST (ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion)
	TEST (ThreadLocalTest, GetAndPointerReturnSameValue)
	TEST (ThreadLocalTest, PointerAndConstPointerReturnSameValue)
	TEST (ApiTest, UnitTestImmutableAccessorsWork)
AssertionResult	IsNull (const char *str)
	TEST (ApiTest, TestCaseImmutableAccessorsWork)
	TEST (ApiTest, TestCaseDisabledAccessorsWork)
	TEST (ApiTest, DISABLED_Dummy1)
	TEST (DISABLED_Test, Dummy2)
static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)
static void	LogElementMatcherPairVec (const ElementMatcherPairs &pairs,::std::ostream *stream)
static const char *	ParseGoogleMockFlagValue (const char *str, const char *flag, bool def_optional)
static bool	ParseGoogleMockBoolFlag (const char *str, const char *flag, bool *value)
template<typename String >
static bool	ParseGoogleMockStringFlag (const char *str, const char *flag, String *value)
static bool	IsPathSeparator (char c)
template<typename T >
static void	Delete (T *x)
static std::string	FlagToEnvVar (const char *flag)
template<typename UnsignedChar , typename Char >
static CharFormat	PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
static bool	GTestIsInitialized ()
static int	SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)
static bool	TestCasePassed (const TestCase *test_case)
static bool	TestCaseFailed (const TestCase *test_case)
static bool	ShouldRunTestCase (const TestCase *test_case)
static std::string	PrintTestPartResultToString (const TestPartResult &test_part_result)
static void	PrintTestPartResult (const TestPartResult &test_part_result)
static bool	PortableLocaltime (time_t seconds, struct tm *out)
static void	SetUpEnvironment (Environment *env)
static void	TearDownEnvironment (Environment *env)
static void	PrintOnOneLine (const char *str, int max_length)
static bool	HasGoogleTestFlagPrefix (const char *str)
static void	PrintColorEncoded (const char *str)
static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)
static void	LogElementMatcherPairVec (const ElementMatcherPairs &pairs,::std::ostream *stream)
static const char *	ParseGoogleMockFlagValue (const char *str, const char *flag, bool def_optional)
static bool	ParseGoogleMockBoolFlag (const char *str, const char *flag, bool *value)
template<typename String >
static bool	ParseGoogleMockStringFlag (const char *str, const char *flag, String *value)
static bool	IsPathSeparator (char c)
template<typename T >
static void	Delete (T *x)
static std::string	FlagToEnvVar (const char *flag)
template<typename UnsignedChar , typename Char >
static CharFormat	PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)
static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
static bool	GTestIsInitialized ()
static int	SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)
static bool	TestCasePassed (const TestCase *test_case)
static bool	TestCaseFailed (const TestCase *test_case)
static bool	ShouldRunTestCase (const TestCase *test_case)
static std::string	PrintTestPartResultToString (const TestPartResult &test_part_result)
static void	PrintTestPartResult (const TestPartResult &test_part_result)
static bool	PortableLocaltime (time_t seconds, struct tm *out)
static void	SetUpEnvironment (Environment *env)
static void	TearDownEnvironment (Environment *env)
static void	PrintOnOneLine (const char *str, int max_length)
static bool	HasGoogleTestFlagPrefix (const char *str)
static void	PrintColorEncoded (const char *str)

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_ const char	kStackTraceMarker [] = "\nStack trace:\n"
class GTEST_API_ testing::internal::ScopedTrace	GTEST_ATTRIBUTE_UNUSED_
const BiggestInt	kMaxBiggestInt
const char	kPathSeparator = '/'
const char	kCurrentDirectoryString [] = "./"
GTEST_API_ const TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()
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 char	kFlagfileFlag [] = "flagfile"
const int	kMaxRandomSeed = 99999
GTEST_API_ bool	g_help_flag = false
const int	kStdOutFileno = STDOUT_FILENO
const int	kStdErrFileno = STDERR_FILENO
const char	kUnknownFile [] = "unknown file"
::std::vector< testing::internal::string >	g_argvs
const UInt32	kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1
const UInt32	kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1
const UInt32	kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1
const UInt32	kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1
static const char	kTypeParamLabel [] = "TypeParam"
static const char	kValueParamLabel [] = "GetParam()"
static const char	kColorEncodedHelpMessage []
const int	kTypedTestCases = 0
const int	kTypedTests = 0
static const char	kTypeParamLabel [] = "TypeParam"
static const char	kValueParamLabel [] = "GetParam()"
static const char	kColorEncodedHelpMessage []
static const char	kTypeParamLabel [] = "TypeParam"
static const char	kValueParamLabel [] = "GetParam()"
static const char	kColorEncodedHelpMessage []

Typedef Documentation

typedef long long testing::internal::BiggestInt

Definition at line 2241 of file gtest-port.h.

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

Definition at line 421 of file gtest-internal.h.

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

Definition at line 3297 of file gmock-matchers.h.

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

Definition at line 3298 of file gmock-matchers.h.

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

Definition at line 2209 of file gtest-port.h.

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

Definition at line 420 of file gtest-internal.h.

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

Definition at line 2494 of file gtest-port.h.

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

Definition at line 2496 of file gtest-port.h.

typedef int testing::internal::IsContainer

Definition at line 930 of file gtest-internal.h.

typedef char testing::internal::IsNotContainer

Definition at line 938 of file gtest-internal.h.

typedef GTestMutexLock testing::internal::MutexLock

Definition at line 2159 of file gtest-port.h.

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

Definition at line 501 of file gtest-internal.h.

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

Definition at line 1097 of file gtest-port.h.

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

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

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

Definition at line 502 of file gtest-internal.h.

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

Definition at line 2498 of file gtest-port.h.

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

Definition at line 2210 of file gtest-port.h.

typedef const void * testing::internal::TypeId

Definition at line 429 of file gtest-internal.h.

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

Definition at line 2495 of file gtest-port.h.

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

Definition at line 2497 of file gtest-port.h.

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

Definition at line 1103 of file gtest-port.h.

Enumeration Type Documentation

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault

Definition at line 361 of file gmock-spec-builders.h.

                  {
  kAllow,
  kWarn,
  kFail,
  kDefault = kWarn  // By default, warn about uninteresting calls.
};

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault

Definition at line 361 of file gmock-spec-builders.h.

                  {
  kAllow,
  kWarn,
  kFail,
  kDefault = kWarn  // By default, warn about uninteresting calls.
};

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault
kAllow
kWarn
kFail
kDefault

Definition at line 361 of file gmock-spec-builders.h.

                  {
  kAllow,
  kWarn,
  kFail,
  kDefault = kWarn  // By default, warn about uninteresting calls.
};

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 128 of file gtest-printers.cc.

                {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 128 of file gtest-printers.cc.

                {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 128 of file gtest-printers.cc.

                {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

Definition at line 2880 of file gtest.cc.

                {
  COLOR_DEFAULT,
  COLOR_RED,
  COLOR_GREEN,
  COLOR_YELLOW
};

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

Definition at line 2880 of file gtest.cc.

                {
  COLOR_DEFAULT,
  COLOR_RED,
  COLOR_GREEN,
  COLOR_YELLOW
};

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

Definition at line 2880 of file gtest.cc.

                {
  COLOR_DEFAULT,
  COLOR_RED,
  COLOR_GREEN,
  COLOR_YELLOW
};

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

Definition at line 1244 of file gtest-port.h.

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

Definition at line 1244 of file gtest-port.h.

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

Definition at line 1244 of file gtest-port.h.

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 306 of file gmock-internal-utils.h.

                 {
  kInfo = 0,
  kWarning = 1
};

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 306 of file gmock-internal-utils.h.

                 {
  kInfo = 0,
  kWarning = 1
};

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 306 of file gmock-internal-utils.h.

                 {
  kInfo = 0,
  kWarning = 1
};

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther

Definition at line 126 of file gmock-internal-utils.h.

              {
  kBool, kInteger, kFloatingPoint, kOther
};

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther

Definition at line 126 of file gmock-internal-utils.h.

              {
  kBool, kInteger, kFloatingPoint, kOther
};

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther
kBool
kInteger
kFloatingPoint
kOther

Definition at line 126 of file gmock-internal-utils.h.

              {
  kBool, kInteger, kFloatingPoint, kOther
};

Function Documentation

bool testing::internal::AlwaysFalse ( )

inline

Definition at line 736 of file gtest-internal.h.

References AlwaysTrue().

Referenced by testing::internal::CodeLocation::CodeLocation(), ColoredPrintf(), TEST(), TEST(), testing::internal::To::To(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

{ return !AlwaysTrue(); }

bool testing::internal::AlwaysTrue

(

)

Definition at line 4988 of file gtest.cc.

References IsTrue().

Referenced by AlwaysFalse(), testing::internal::CodeLocation::CodeLocation(), PrintOnOneLine(), ShouldRunTestCase(), SplitString(), TEST(), TEST(), testing::internal::To::To(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                  {
#if GTEST_HAS_EXCEPTIONS
  // This condition is always false so AlwaysTrue() never actually throws,
  // but it makes the compiler think that it may throw.
  if (IsTrue(false))
    throw ClassUniqueToAlwaysTrue();
#endif  // GTEST_HAS_EXCEPTIONS
  return true;
}

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

Definition at line 2001 of file gtest.cc.

References testing::Message::GetString(), and string.

Referenced by testing::internal::AssertHelper::operator=(), ShouldRunTestCase(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                       {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }

  return gtest_msg + "\n" + user_msg_string;
}

template<typename Iter , typename Element >

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

Definition at line 983 of file gtest-internal.h.

References ArrayEq(), CopyArray(), folly::test::end(), folly::pushmi::operators::from, gen_gtest_pred_impl::Iter(), and folly::to().

Referenced by testing::internal::ContainerEqMatcher< Container >::MatchAndExplain(), TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                               {
  for (Iter it = begin; it != end; ++it) {
    if (internal::ArrayEq(*it, elem))
      return it;
  }
  return end;
}

template<typename T , typename U >

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

Definition at line 972 of file gtest-internal.h.

References ArrayEq(), i, and folly::size().

Referenced by TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                      {
  for (size_t i = 0; i != size; i++) {
    if (!internal::ArrayEq(lhs[i], rhs[i]))
      return false;
  }
  return true;
}

template<typename T , typename U >

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

inline

Definition at line 960 of file gtest-internal.h.

References folly::detail::rhs.

{ return lhs == rhs; }

template<typename T , typename U , size_t N>

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

inline

Definition at line 964 of file gtest-internal.h.

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

                                                        {
  return internal::ArrayEq(lhs, N, rhs);
}

template<typename From , typename To >

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

inline

Definition at line 288 of file gmock-internal-utils.h.

Referenced by testing::internal::UntypedOnCallSpecBase::AssertSpecProperty(), testing::internal::ExpectationBase::AssertSpecProperty(), testing::internal::BuiltInDefaultValueGetter< T, false >::Get(), testing::internal::TypedExpectation< F >::GetCurrentAction(), testing::internal::UntypedFunctionMockerBase::GetHandleOf(), Invalid(), testing::internal::UntypedFunctionMockerBase::MockObject(), testing::internal::UntypedFunctionMockerBase::Name(), testing::Action< InnerFunctionType >::Perform(), and testing::internal::FunctionMockerBase< R(A1, A2)>::PerformDefaultAction().

                                                               {
  Assert(condition, file, line, "Assertion failed.");
}

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

Definition at line 1191 of file gtest-port.cc.

References FlagToEnvVar(), testing::internal::posix::GetEnv(), and string.

Referenced by FlagToEnvVar(), and testing::GetDefaultFilter().

                                                            {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
}

void testing::internal::CaptureStderr

(

)

Referenced by CheckedDowncastToActualType(), TEST(), TEST(), testing::internal::To::To(), and testing::internal::GTestLog::~GTestLog().

void testing::internal::CaptureStdout

(

)

Referenced by CheckedDowncastToActualType(), Mock::Mock(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_nice_strict_test::MockBar::str(), testing::gmock_nice_strict_test::TEST(), TEST(), testing::InitGoogleTestTest::TestParsingFlags(), testing::internal::To::To(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestLog::~GTestLog().

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

inline

Definition at line 1090 of file gmock-matchers.h.

References CaseInsensitiveCStringEquals().

Referenced by CmpHelperSTRCASEEQ(), CmpHelperSTRCASENE(), testing::internal::String::EndsWithCaseInsensitive(), and ShouldUseColor().

                                                                           {
  return String::CaseInsensitiveCStringEquals(lhs, rhs);
}

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

inline

Definition at line 1094 of file gmock-matchers.h.

Referenced by CaseInsensitiveCStringEquals(), CaseInsensitiveStringEquals(), and testing::internal::RefMatcher< T & >::Impl< Super >::DescribeNegationTo().

                                                             {
  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
}

template<typename StringType >

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

Definition at line 1102 of file gmock-matchers.h.

References CaseInsensitiveCStringEquals().

Referenced by testing::internal::RefMatcher< T & >::Impl< Super >::DescribeNegationTo(), and testing::internal::StrEqualityMatcher< StringType >::MatchAndExplain().

                                                       {
  // Are the heads equal?
  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
    return false;
  }

  // Skip the equal heads.
  const typename StringType::value_type nul = 0;
  const size_t i1 = s1.find(nul), i2 = s2.find(nul);

  // Are we at the end of either s1 or s2?
  if (i1 == StringType::npos || i2 == StringType::npos) {
    return i1 == i2;
  }

  // Are the tails equal?
  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
}

template<class Derived , class Base >

Derived * testing::internal::CheckedDowncastToActualType

(

Base *

base

)

Definition at line 1392 of file gtest-port.h.

References CaptureStderr(), CaptureStdout(), FILE, GetArgvs(), GetCapturedStderr(), GetCapturedStdout(), GetFileSize(), GTEST_API_, GTEST_CHECK_, GTEST_CHECK_POSIX_SUCCESS_, GTEST_DISALLOW_COPY_AND_ASSIGN_, mutex, Mutex, mutex_, ReadEntireFile(), Run(), string, T, TempDir(), folly::detail::distributed_mutex::time(), type_, and value.

                                                 {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

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

inline

Definition at line 1747 of file gtest.cc.

Referenced by CodePointToUtf8().

                                               {
  const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1);
  *bits >>= n;
  return low_bits;
}

template<typename T1 , typename T2 >

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

Definition at line 1387 of file gtest.h.

References testing::AssertionSuccess(), CmpHelperEQFailure(), GTEST_API_, GTEST_DISABLE_MSC_WARNINGS_POP_, GTEST_DISABLE_MSC_WARNINGS_PUSH_, and folly::detail::rhs.

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

                                           {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
  if (lhs == rhs) {
    return AssertionSuccess();
  }
GTEST_DISABLE_MSC_WARNINGS_POP_()

  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}

AssertionResult testing::internal::CmpHelperEQ	(	const char *	lhs_expression,
		const char *	rhs_expression,
		BiggestInt	lhs,
		BiggestInt	rhs
	)

Definition at line 1437 of file gtest.cc.

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

                                            {
  if (lhs == rhs) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

template<typename T1 , typename T2 >

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

Definition at line 1375 of file gtest.h.

References EqFailure(), and FormatForComparisonFailureMessage().

Referenced by CmpHelperEQ(), and testing::UnitTest::impl().

                                                                 {
  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

template<typename RawType >

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

Definition at line 1631 of file gtest.h.

References testing::AssertionSuccess(), folly::digits10(), DoubleNearPredFormat(), EqFailure(), GTEST_API_, folly::detail::rhs, and StringStreamToString().

                                                            {
  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);

  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  ::std::stringstream lhs_ss;
  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << lhs_value;

  ::std::stringstream rhs_ss;
  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << rhs_value;

  return EqFailure(lhs_expression,
                   rhs_expression,
                   StringStreamToString(&lhs_ss),
                   StringStreamToString(&rhs_ss),
                   false);
}

template<typename T1 , typename T2 >

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

Definition at line 1528 of file gtest.h.

AssertionResult testing::internal::CmpHelperGE	(	const char *	expr1,
		const char *	expr2,
		BiggestInt	val1,
		BiggestInt	val2
	)

Definition at line 1479 of file gtest.cc.

{

template<typename T1 , typename T2 >

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

Definition at line 1530 of file gtest.h.

AssertionResult testing::internal::CmpHelperGT	(	const char *	expr1,
		const char *	expr2,
		BiggestInt	val1,
		BiggestInt	val2
	)

Definition at line 1482 of file gtest.cc.

{

AssertionResult testing::internal::CmpHelperLE	(	const char *	expr1,
		const char *	expr2,
		BiggestInt	val1,
		BiggestInt	val2
	)

Definition at line 1473 of file gtest.cc.

{

template<typename T1 , typename T2 >

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

Definition at line 1524 of file gtest.h.

AssertionResult testing::internal::CmpHelperLT	(	const char *	expr1,
		const char *	expr2,
		BiggestInt	val1,
		BiggestInt	val2
	)

Definition at line 1476 of file gtest.cc.

{

template<typename T1 , typename T2 >

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

Definition at line 1526 of file gtest.h.

template<typename T1 , typename T2 >

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

Definition at line 1522 of file gtest.h.

AssertionResult testing::internal::CmpHelperNE	(	const char *	expr1,
		const char *	expr2,
		BiggestInt	val1,
		BiggestInt	val2
	)

Definition at line 1470 of file gtest.cc.

{

template<typename T1 , typename T2 >

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

Definition at line 1486 of file gtest.h.

References testing::AssertionFailure(), and FormatForComparisonFailureMessage().

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

                                                   {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

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

Definition at line 1503 of file gtest.cc.

References testing::AssertionSuccess(), CaseInsensitiveCStringEquals(), EqFailure(), and testing::PrintToString().

                                                    {
  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   true);
}

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

Definition at line 1533 of file gtest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), CaseInsensitiveCStringEquals(), and needle.

                                                   {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

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

Definition at line 1487 of file gtest.cc.

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

                                                {
  if (String::CStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

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

Definition at line 1869 of file gtest.cc.

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

                                                   {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

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

Definition at line 1519 of file gtest.cc.

References testing::AssertionFailure(), and testing::AssertionSuccess().

                                               {
  if (!String::CStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                              << s2_expression << "), actual: \""
                              << s1 << "\" vs \"" << s2 << "\"";
  }
}

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

Definition at line 1885 of file gtest.cc.

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

                                                  {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }

  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

std::string testing::internal::CodePointToUtf8

(

UInt32

code_point

)

Definition at line 1759 of file gtest.cc.

References ChopLowBits().

Referenced by operator<<(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), WideStringToUtf8(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                             {
  if (code_point > kMaxCodePoint4) {
    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
  }

  char str[5];  // Big enough for the largest valid code point.
  if (code_point <= kMaxCodePoint1) {
    str[1] = '\0';
    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
  } else if (code_point <= kMaxCodePoint2) {
    str[2] = '\0';
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
  } else if (code_point <= kMaxCodePoint3) {
    str[3] = '\0';
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
  } else {  // code_point <= kMaxCodePoint4
    str[4] = '\0';
    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
  }
  return str;
}

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

Definition at line 2956 of file gtest.cc.

References AlwaysFalse(), COLOR_DEFAULT, testing::internal::posix::FileNo(), GetAnsiColorCode(), testing::internal::posix::IsATTY(), and ShouldUseColor().

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(), testing::internal::PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(), testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(), testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(), testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestStart(), PrintColorEncoded(), testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(), ShouldShard(), TearDownEnvironment(), and WriteToShardStatusFileIfNeeded().

                                                           {
  va_list args;
  va_start(args, fmt);

#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  const bool use_color = AlwaysFalse();
#else
  static const bool in_color_mode =
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.

  if (!use_color) {
    vprintf(fmt, args);
    va_end(args);
    return;
  }

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
  const WORD old_color_attrs = buffer_info.wAttributes;

  // We need to flush the stream buffers into the console before each
  // SetConsoleTextAttribute call lest it affect the text that is already
  // printed but has not yet reached the console.
  fflush(stdout);
  SetConsoleTextAttribute(stdout_handle,
                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
  vprintf(fmt, args);

  fflush(stdout);
  // Restores the text color.
  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
  printf("\033[0;3%sm", GetAnsiColorCode(color));
  vprintf(fmt, args);
  printf("\033[m");  // Resets the terminal to default.
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  va_end(args);
}

GTEST_API_ string testing::internal::ConvertIdentifierNameToWords

(

const char *

id_name

)

Definition at line 54 of file gmock-internal-utils.cc.

References IsAlNum(), IsAlpha(), IsDigit(), IsLower(), IsUpper(), and ToLower().

Referenced by FormatMatcherDescription().

                                                                    {
  string result;
  char prev_char = '\0';
  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
    // We don't care about the current locale as the input is
    // guaranteed to be a valid C++ identifier name.
    const bool starts_new_word = IsUpper(*p) ||
        (!IsAlpha(prev_char) && IsLower(*p)) ||
        (!IsDigit(prev_char) && IsDigit(*p));

    if (IsAlNum(*p)) {
      if (starts_new_word && result != "")
        result += ' ';
      result += ToLower(*p);
    }
  }
  return result;
}

template<typename T , typename U >

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

Definition at line 1012 of file gtest-internal.h.

References CopyArray(), i, and folly::size().

Referenced by TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                  {
  for (size_t i = 0; i != size; i++) {
    internal::CopyArray(from[i], to + i);
  }
}

template<typename T , typename U >

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

inline

Definition at line 1000 of file gtest-internal.h.

References folly::pushmi::operators::from.

{ *to = from; }

template<typename T , typename U , size_t N>

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

inline

Definition at line 1004 of file gtest-internal.h.

Referenced by ArrayAwareFind(), CopyArray(), and testing::internal::NativeArray< Element >::InitCopy().

                                                    {
  internal::CopyArray(from, N, *to);
}

template<typename InputIterator , typename OutputIterator >

OutputIterator testing::internal::CopyElements ( InputIterator  first, InputIterator  last, OutputIterator  output  )

inline

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

References folly::gen::first, and gmock_output_test::output.

Referenced by testing::ACTION_TEMPLATE(), and testing::internal::InvokeMethodAction< Class, MethodPtr >::Perform().

                                                          {
  for (; first != last; ++first, ++output) {
    *output = *first;
  }
  return output;
}

template<class Container , typename Predicate >

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

inline

Definition at line 283 of file gtest-internal-inl.h.

References count.

Referenced by testing::TestCase::disabled_test_count(), testing::internal::UnitTestImpl::failed_test_case_count(), testing::TestCase::failed_test_count(), testing::TestResult::HasFatalFailure(), testing::TestResult::HasNonfatalFailure(), operator<<(), testing::TestCase::reportable_disabled_test_count(), testing::TestCase::reportable_test_count(), ShouldRunTestCase(), testing::internal::UnitTestImpl::successful_test_case_count(), testing::TestCase::successful_test_count(), testing::internal::UnitTestImpl::test_case_to_run_count(), testing::TestCase::test_to_run_count(), testing::TestPartFatallyFailed(), testing::TestPartNonfatallyFailed(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                            {
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
    if (predicate(*it))
      ++count;
  }
  return count;
}

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

inline

Definition at line 1800 of file gtest.cc.

References folly::gen::first.

Referenced by WideStringToUtf8().

                                                                    {
  const UInt32 mask = (1 << 10) - 1;
  return (sizeof(wchar_t) == 2) ?
      (((first & mask) << 10) | (second & mask)) + 0x10000 :
      // This function should not be called when the condition is
      // false, but we provide a sensible default in case it is.
      static_cast<UInt32>(first);
}

template<typename C >

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

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

References count, and UniversalPrint().

                                                        {
  const size_t kMaxCount = 32;  // The maximum number of elements to print.
  *os << '{';
  size_t count = 0;
  for (typename C::const_iterator it = container.begin();
       it != container.end(); ++it, ++count) {
    if (count > 0) {
      *os << ',';
      if (count == kMaxCount) {  // Enough has been printed.
        *os << " ...";
        break;
      }
    }
    *os << ' ';
    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
    // handle *it being a native array.
    internal::UniversalPrint(*it, os);
  }

  if (count > 0) {
    *os << ' ';
  }
  *os << '}';
}

template<typename T >

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

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

References IsTrue().

                                          {
  if (p == NULL) {
    *os << "NULL";
  } else {
    // C++ doesn't allow casting from a function pointer to any object
    // pointer.
    //
    // IsTrue() silences warnings: "Condition is always true",
    // "unreachable code".
    if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
      // T is not a function type.  We just call << to print p,
      // relying on ADL to pick up user-defined << for their pointer
      // types, if any.
      *os << p;
    } else {
      // T is a function type, so '*os << p' doesn't do what we want
      // (it just prints p as bool).  We want to print p as a const
      // void*.  However, we cannot cast it to const void* directly,
      // even using reinterpret_cast, as earlier versions of gcc
      // (e.g. 3.4.5) cannot compile the cast when p is a function
      // pointer.  Casting to UInt64 first solves the problem.
      *os << reinterpret_cast<const void*>(
          reinterpret_cast<internal::UInt64>(p));
    }
  }
}

template<typename T >

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

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

References testing_internal::DefaultPrintNonContainerTo().

Referenced by PrintTo().

                                                    {
  ::testing_internal::DefaultPrintNonContainerTo(value, os);
}

template<typename T >

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

static

Definition at line 340 of file gtest-internal-inl.h.

References x.

                         {
  delete x;
}

template<typename T >

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

static

Definition at line 340 of file gtest-internal-inl.h.

References x.

                         {
  delete x;
}

template<typename T >

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

static

Definition at line 340 of file gtest-internal-inl.h.

References x.

Referenced by testing::gmock_nice_strict_test::MockBar::str(), and testing::gmock_nice_strict_test::TEST().

                         {
  delete x;
}

GTEST_API_ std::string testing::internal::DiffStrings	(	const std::string &	left,
		const std::string &	right,
		size_t *	total_line_count
	)

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

Definition at line 1362 of file gtest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), and diff().

Referenced by CmpHelperFloatingPointEQ().

                                                       {
  const double diff = fabs(val1 - val2);
  if (diff <= abs_error) return AssertionSuccess();

  // TODO(wan): do not print the value of an expression if it's
  // already a literal.
  return AssertionFailure()
      << "The difference between " << expr1 << " and " << expr2
      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
      << expr1 << " evaluates to " << val1 << ",\n"
      << expr2 << " evaluates to " << val2 << ", and\n"
      << abs_error_expr << " evaluates to " << abs_error << ".";
}

template<typename To , typename From >

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

inline

Definition at line 1367 of file gtest-port.h.

References f, GTEST_CHECK_, GTEST_INTENTIONAL_CONST_COND_POP_, GTEST_INTENTIONAL_CONST_COND_PUSH_, and folly::to().

                             {  // so we only accept pointers
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  GTEST_INTENTIONAL_CONST_COND_PUSH_()
  if (false) {
  GTEST_INTENTIONAL_CONST_COND_POP_()
    const To to = NULL;
    ::testing::internal::ImplicitCast_<From*>(to);
  }

#if GTEST_HAS_RTTI
  // RTTI: debug mode only!
  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
#endif
  return static_cast<To>(f);
}

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
	)

Definition at line 1312 of file gtest.cc.

References testing::AssertionFailure(), and testing::internal::edit_distance::CreateUnifiedDiff().

Referenced by CmpHelperEQ(), CmpHelperEQFailure(), CmpHelperFloatingPointEQ(), CmpHelperSTRCASEEQ(), CmpHelperSTREQ(), testing::UnitTest::impl(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                              {
  Message msg;
  msg << "      Expected: " << lhs_expression;
  if (lhs_value != lhs_expression) {
    msg << "\n      Which is: " << lhs_value;
  }
  msg << "\nTo be equal to: " << rhs_expression;
  if (rhs_value != rhs_expression) {
    msg << "\n      Which is: " << rhs_value;
  }

  if (ignoring_case) {
    msg << "\nIgnoring case";
  }

  if (!lhs_value.empty() && !rhs_value.empty()) {
    const std::vector<std::string> lhs_lines =
        SplitEscapedString(lhs_value);
    const std::vector<std::string> rhs_lines =
        SplitEscapedString(rhs_value);
    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
      msg << "\nWith diff:\n"
          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
    }
  }

  return AssertionFailure() << msg;
}

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

inline

Definition at line 294 of file gmock-internal-utils.h.

Referenced by Expect(), testing::internal::UntypedOnCallSpecBase::ExpectSpecProperty(), testing::internal::ExpectationBase::ExpectSpecProperty(), ReportUninterestingCall(), testing::internal::UntypedFunctionMockerBase::UntypedInvokeWith(), and testing::internal::UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked().

                                      {
  if (!condition) {
    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
                                        file, line, msg);
  }
}

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

inline

Definition at line 301 of file gmock-internal-utils.h.

References Expect().

                                                               {
  Expect(condition, file, line, "Expectation failed.");
}

template<typename MatcherTuple , typename ValueTuple >

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

Definition at line 810 of file gmock-matchers.h.

Referenced by testing::internal::TuplePrefix< 0 >::ExplainMatchFailuresTo(), testing::internal::TypedExpectation< F >::ExplainMatchResultTo(), and testing::gmock_matchers_test::TEST().

                                                {
  TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
      matchers, values, os);
}

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching

(

const MatchMatrix &

g

)

Definition at line 308 of file gmock-matchers.cc.

References testing::internal::MaxBipartiteMatchState::Compute().

Referenced by FindPairing(), LogElementMatcherPairVec(), testing::internal::MatchMatrix::SpaceIndex(), testing::gmock_matchers_test::TEST_P(), and testing::internal::MaxBipartiteMatchState::TryAugment().

                                               {
  return MaxBipartiteMatchState(g).Compute();
}

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

Definition at line 328 of file gmock-matchers.cc.

References FindMaxBipartiteMatching(), testing::MatchResultListener::IsInterested(), LogElementMatcherPairVec(), testing::internal::MatchMatrix::RhsSize(), and testing::MatchResultListener::stream().

Referenced by LogElementMatcherPairVec(), testing::internal::UnorderedElementsAreMatcherImpl< Container >::MatchAndExplain(), and testing::internal::MatchMatrix::SpaceIndex().

                                                           {
  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);

  size_t max_flow = matches.size();
  bool result = (max_flow == matrix.RhsSize());

  if (!result) {
    if (listener->IsInterested()) {
      *listener << "where no permutation of the elements can "
                   "satisfy all matchers, and the closest match is "
                << max_flow << " of " << matrix.RhsSize()
                << " matchers with the pairings:\n";
      LogElementMatcherPairVec(matches, listener->stream());
    }
    return false;
  }

  if (matches.size() > 1) {
    if (listener->IsInterested()) {
      const char *sep = "where:\n";
      for (size_t mi = 0; mi < matches.size(); ++mi) {
        *listener << sep << " - element #" << matches[mi].first
                  << " is matched by matcher #" << matches[mi].second;
        sep = ",\n";
      }
    }
  }
  return true;
}

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

static

Definition at line 1134 of file gtest-port.cc.

References BoolFromGTestEnv(), folly::test::end(), flag, FlagToEnvVar(), testing::internal::posix::GetEnv(), testing::Message::GetString(), GTEST_FLAG_PREFIX_, i, Int32FromGTestEnv(), ParseInt32(), string, StringFromGTestEnv(), ToUpper(), and value.

                                                {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

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

static

Definition at line 1134 of file gtest-port.cc.

References BoolFromGTestEnv(), folly::test::end(), flag, FlagToEnvVar(), testing::internal::posix::GetEnv(), testing::Message::GetString(), GTEST_FLAG_PREFIX_, i, Int32FromGTestEnv(), ParseInt32(), string, StringFromGTestEnv(), ToUpper(), and value.

                                                {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

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

static

Definition at line 1134 of file gtest-port.cc.

References flag, testing::Message::GetString(), GTEST_FLAG_PREFIX_, i, string, and ToUpper().

Referenced by BoolFromGTestEnv(), FlagToEnvVar(), Int32FromGTestEnv(), and StringFromGTestEnv().

                                                {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

template<typename RawType >

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

Definition at line 1384 of file gtest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), folly::digits10(), folly::detail::rhs, and StringStreamToString().

                                              {
  // Returns success if val1 is less than val2,
  if (val1 < val2) {
    return AssertionSuccess();
  }

  // or if val1 is almost equal to val2.
  const FloatingPoint<RawType> lhs(val1), rhs(val2);
  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  // Note that the above two checks will both fail if either val1 or
  // val2 is NaN, as the IEEE floating-point standard requires that
  // any predicate involving a NaN must return false.

  ::std::stringstream val1_ss;
  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val1;

  ::std::stringstream val2_ss;
  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val2;

  return AssertionFailure()
      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
      << StringStreamToString(&val2_ss);
}

void testing::internal::FlushInfoLog ( )

inline

Definition at line 1276 of file gtest-port.h.

{ fflush(NULL); }

template<class Container , typename Functor >

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

Definition at line 296 of file gtest-internal-inl.h.

References for_each().

Referenced by testing::internal::UnitTestImpl::ClearNonAdHocTestResult(), testing::TestCase::ClearResult(), operator<<(), testing::internal::UnitTestImpl::RunAllTests(), testing::internal::TestEventRepeater::set_forwarding_enabled(), TearDownEnvironment(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), testing::internal::GTestFlagSaver::~GTestFlagSaver(), testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile(), testing::TestCase::~TestCase(), testing::internal::TestEventRepeater::~TestEventRepeater(), and testing::internal::UnitTestImpl::~UnitTestImpl().

                                                  {
  std::for_each(c.begin(), c.end(), functor);
}

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

Definition at line 898 of file gtest-port.cc.

References StreamableToString(), and string.

Referenced by testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), testing::internal::RE::PartialMatch(), PortableLocaltime(), TEST(), and testing::internal::To::To().

                                {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

std::string testing::internal::FormatEpochTimeInMillisAsIso8601

(

TimeInMillis

ms

)

Definition at line 3574 of file gtest.cc.

References testing::internal::String::FormatIntWidth2(), PortableLocaltime(), and StreamableToString().

Referenced by operator<<(), testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), PortableLocaltime(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                            {
  struct tm time_struct;
  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
    return "";
  // YYYY-MM-DDThh:mm:ss
  return StreamableToString(time_struct.tm_year + 1900) + "-" +
      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
      String::FormatIntWidth2(time_struct.tm_min) + ":" +
      String::FormatIntWidth2(time_struct.tm_sec);
}

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

Definition at line 880 of file gtest-port.cc.

References StreamableToString(), and string.

Referenced by testing::UnitTest::AddTestPartResult(), testing::internal::CodeLocation::CodeLocation(), testing::internal::FunctionMockerBase< R(A1, A2)>::DescribeDefaultActionTo(), testing::internal::ExpectationBase::DescribeLocationTo(), testing::internal::GTestLog::GTestLog(), MakeAndRegisterTestInfo(), testing::internal::RE::PartialMatch(), PrintTestPartResultToString(), testing::internal::ExpectationTester::SetCallCount(), TEST(), testing::TestPartNonfatallyFailed(), testing::internal::To::To(), and testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile().

                                                                    {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

template<typename T1 , typename T2 >

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

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

Referenced by testing::gtest_printers_test::Big::Big(), CmpHelperEQ(), CmpHelperEQFailure(), CmpHelperOpFailure(), testing::internal::EqHelper< true >::Compare(), testing::UnitTest::impl(), testing::gtest_printers_test::TEST(), and foo::StreamableTemplateInFoo< T >::value().

                                  {
  return FormatForComparison<T1, T2>::Format(value);
}

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

Definition at line 127 of file gmock-matchers.cc.

References ConvertIdentifierNameToWords(), and JoinAsTuple().

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), MatcherBindSecond(), and testing::gmock_matchers_test::TEST().

                                                                        {
  string result = ConvertIdentifierNameToWords(matcher_name);
  if (param_values.size() >= 1)
    result += " " + JoinAsTuple(param_values);
  return negation ? "not (" + result + ")" : result;
}

std::string testing::internal::FormatTimeInMillisAsSeconds

(

TimeInMillis

ms

)

Definition at line 3550 of file gtest.cc.

Referenced by testing::internal::XmlUnitTestResultPrinter::EscapeXmlText(), operator<<(), testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), PortableLocaltime(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                       {
  ::std::stringstream ss;
  ss << (static_cast<double>(ms) * 1e-3);
  return ss.str();
}

const char * testing::internal::GetAnsiColorCode

(

GTestColor

color

)

Definition at line 2904 of file gtest.cc.

References COLOR_GREEN, COLOR_RED, and COLOR_YELLOW.

Referenced by ColoredPrintf().

                                               {
  switch (color) {
    case COLOR_RED:     return "1";
    case COLOR_GREEN:   return "2";
    case COLOR_YELLOW:  return "3";
    default:            return NULL;
  };
}

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

(

)

Definition at line 389 of file gtest.cc.

References g_argvs.

Referenced by CheckedDowncastToActualType(), GetCurrentExecutableName(), GTestIsInitialized(), ReadEntireFile(), and ShouldRunTestCase().

                                                   {
#if defined(GTEST_CUSTOM_GET_ARGVS_)
  return GTEST_CUSTOM_GET_ARGVS_();
#else  // defined(GTEST_CUSTOM_GET_ARGVS_)
  return g_argvs;
#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
}

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

Definition at line 1346 of file gtest.cc.

References testing::Message::GetString(), and testing::AssertionResult::message().

                                          {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

std::string testing::internal::GetCapturedStderr

(

)

Referenced by CheckedDowncastToActualType(), TEST(), TEST(), testing::internal::To::To(), and testing::internal::GTestLog::~GTestLog().

std::string testing::internal::GetCapturedStdout

(

)

Referenced by CheckedDowncastToActualType(), Mock::Mock(), testing::internal::ExpectationTester::SetCallCount(), testing::gmock_nice_strict_test::MockBar::str(), testing::gmock_nice_strict_test::TEST(), TEST(), testing::InitGoogleTestTest::TestParsingFlags(), testing::internal::To::To(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestLog::~GTestLog().

FilePath testing::internal::GetCurrentExecutableName

(

)

Definition at line 399 of file gtest.cc.

References GetArgvs(), testing::internal::FilePath::RemoveDirectoryName(), and testing::internal::FilePath::Set().

Referenced by testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(), testing::internal::TestPropertyKeyIs::operator()(), ShouldRunTestCase(), and testing::TEST_F().

                                    {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

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

Definition at line 4973 of file gtest.cc.

References testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop(), and GetUnitTestImpl().

Referenced by testing::internal::CodeLocation::CodeLocation(), Log(), PrintOnOneLine(), testing::internal::GoogleTestFailureReporter::ReportFailure(), TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                            {
  // We pass skip_count + 1 to skip this wrapper function in addition
  // to what the user really wants to skip.
  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
}

template<typename E >

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

inline

Definition at line 303 of file gtest-internal-inl.h.

References i.

Referenced by testing::internal::UnitTestImpl::GetMutableTestCase(), testing::TestCase::GetMutableTestInfo(), testing::internal::UnitTestImpl::GetTestCase(), testing::TestCase::GetTestInfo(), operator<<(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                                     {
  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
}

GTEST_API_ FailureReporterInterface * testing::internal::GetFailureReporter

(

)

Definition at line 94 of file gmock-internal-utils.cc.

References GTEST_DEFINE_STATIC_MUTEX_().

Referenced by testing::internal::GoogleTestFailureReporter::ReportFailure().

                                                          {
  // Points to the global failure reporter used by Google Mock.  gcc
  // guarantees that the following use of failure_reporter is
  // thread-safe.  We may need to add additional synchronization to
  // protect failure_reporter if we port Google Mock to other
  // compilers.
  static FailureReporterInterface* const failure_reporter =
      new GoogleTestFailureReporter();
  return failure_reporter;
}

size_t testing::internal::GetFileSize

(

FILE *

file

)

Definition at line 1076 of file gtest-port.cc.

Referenced by CheckedDowncastToActualType(), and ReadEntireFile().

                               {
  fseek(file, 0, SEEK_END);
  return static_cast<size_t>(ftell(file));
}

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

inline

Definition at line 152 of file gtest-internal-inl.h.

References GTEST_CHECK_.

Referenced by operator<<(), testing::internal::UnitTestImpl::RunAllTests(), TearDownEnvironment(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                       {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

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

inline

Definition at line 136 of file gtest-internal-inl.h.

References GetTimeInMillis().

Referenced by operator<<(), testing::internal::UnitTestImpl::RunAllTests(), TearDownEnvironment(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                         {
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
  return normalized_seed;
}

template<typename Pointer >

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

inline

Definition at line 76 of file gmock-internal-utils.h.

Referenced by testing::internal::IsNullMatcher::MatchAndExplain(), testing::internal::NotNullMatcher::MatchAndExplain(), and testing::internal::PointeeMatcher< InnerMatcher >::Impl< Pointer >::MatchAndExplain().

                                                                           {
  return p.get();
}

template<typename Element >

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

inline

Definition at line 81 of file gmock-internal-utils.h.

{ return p; }

TypeId testing::internal::GetTestTypeId

(

)

Definition at line 620 of file gtest.cc.

Referenced by GetTypeId(), testing::Test::HasSameFixtureClass(), testing::internal::FloatingPoint< RawType >::Max(), operator<<(), ShouldRunTestCase(), testing::TestPartNonfatallyFailed(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                       {
  return GetTypeId<Test>();
}

size_t testing::internal::GetThreadCount

(

)

Definition at line 169 of file gtest-port.cc.

References ADD_FAILURE, testing::internal::Mutex::AssertHeld(), buffer(), c, ch, EXPECT_TRUE, FALSE, folly::gen::first, bm::free(), testing::internal::RE::full_regex_, testing::internal::RE::FullMatch(), GTEST_CHECK_, GTEST_DISALLOW_COPY_AND_ASSIGN_, i, testing::internal::RE::Init(), testing::internal::RE::is_valid_, folly::detail::lock(), testing::internal::Mutex::Lock(), map(), testing::internal::Mutex::Mutex(), mutex_, testing::internal::RE::partial_regex_, testing::internal::RE::PartialMatch(), testing::internal::RE::pattern_, ptr, regex, repeat(), testing::internal::posix::StrDup(), string, TRUE, type_, testing::internal::Mutex::Unlock(), and testing::internal::RE::~RE().

Referenced by testing::internal::ThreadLocal< testing::TestPartResultReporterInterface * >::set(), TEST(), and testing::internal::To::To().

                        {
  // There's no portable way to detect the number of threads, so we just
  // return 0 to indicate that we cannot detect it.
  return 0;
}

TimeInMillis testing::internal::GetTimeInMillis

(

)

Definition at line 806 of file gtest.cc.

References folly::pushmi::operators::error(), GTEST_DISABLE_MSC_WARNINGS_POP_, GTEST_DISABLE_MSC_WARNINGS_PUSH_, GTEST_HAS_GETTIMEOFDAY_, and now().

Referenced by GetRandomSeedFromFlag(), testing::TestInfo::Run(), testing::TestCase::Run(), testing::internal::UnitTestImpl::RunAllTests(), ShouldRunTestCase(), TearDownEnvironment(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                               {
#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
  // Difference between 1970-01-01 and 1601-01-01 in milliseconds.
  // http://analogous.blogspot.com/2005/04/epoch.html
  const TimeInMillis kJavaEpochToWinFileTimeDelta =
    static_cast<TimeInMillis>(116444736UL) * 100000UL;
  const DWORD kTenthMicrosInMilliSecond = 10000;

  SYSTEMTIME now_systime;
  FILETIME now_filetime;
  ULARGE_INTEGER now_int64;
  // TODO(kenton@google.com): Shouldn't this just use
  //   GetSystemTimeAsFileTime()?
  GetSystemTime(&now_systime);
  if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
    now_int64.LowPart = now_filetime.dwLowDateTime;
    now_int64.HighPart = now_filetime.dwHighDateTime;
    now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
      kJavaEpochToWinFileTimeDelta;
    return now_int64.QuadPart;
  }
  return 0;
#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
  __timeb64 now;

  // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
  // (deprecated function) there.
  // TODO(kenton@google.com): Use GetTickCount()?  Or use
  //   SystemTimeToFileTime()
  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
  _ftime64(&now);
  GTEST_DISABLE_MSC_WARNINGS_POP_()

  return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
#elif GTEST_HAS_GETTIMEOFDAY_
  struct timeval now;
  gettimeofday(&now, NULL);
  return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
#else
# error "Don't know how to get the current time on your system."
#endif
}

template<typename T >

TypeId testing::internal::GetTypeId

(

)

Definition at line 447 of file gtest-internal.h.

References GetTestTypeId(), and GTEST_API_.

Referenced by testing::internal::FloatingPoint< RawType >::Max(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                   {
  // The compiler is required to allocate a different
  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  // the template.  Therefore, the address of dummy_ is guaranteed to
  // be unique.
  return &(TypeIdHelper<T>::dummy_);
}

template<typename T >

std::string testing::internal::GetTypeName

(

)

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

References bm::free(), name, string, T, and type.

                        {
# if GTEST_HAS_RTTI

  const char* const name = typeid(T).name();
#  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
  int status = 0;
  // gcc's implementation of typeid(T).name() mangles the type name,
  // so we have to demangle it.
#   if GTEST_HAS_CXXABI_H_
  using abi::__cxa_demangle;
#   endif  // GTEST_HAS_CXXABI_H_
  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
  const std::string name_str(status == 0 ? readable_name : name);
  free(readable_name);
  return name_str;
#  else
  return name;
#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC

# else

  return "<type>";

# endif  // GTEST_HAS_RTTI
}

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

Definition at line 927 of file gtest-internal-inl.h.

References argv, ch, folly::test::end(), testing::UnitTest::GetInstance(), GTEST_API_, GTEST_CHECK_, testing::UnitTest::impl(), IsDigit(), number, ParseGoogleTestFlagsOnly(), regex, repeat(), and string.

Referenced by GetCurrentOsStackTraceExceptTop(), testing::TestInfoTest::GetTestInfo(), HandleExceptionsInMethodIfSupported(), testing::Test::HasFatalFailure(), testing::internal::HasNewFatalFailureHelper::HasNewFatalFailureHelper(), testing::Test::HasNonfatalFailure(), testing::Test::HasSameFixtureClass(), testing::UnitTest::impl(), testing::ScopedFakeTestPartResultReporter::Init(), InitGoogleTestImpl(), MakeAndRegisterTestInfo(), operator<<(), PrintOnOneLine(), testing::Test::Run(), testing::TestInfo::Run(), testing::TestCase::Run(), testing::internal::UnitTestImpl::set_catch_exceptions(), ShouldRunTestCase(), testing::TEST(), TEST(), testing::TestPartNonfatallyFailed(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper(), and testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter().

                                       {
  return UnitTest::GetInstance()->impl();
}

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_linked_ptr_mutex

)

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_gmock_mutex

)

testing::internal::GTEST_DECLARE_string_

(

internal_run_death_test

)

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_

(

g_gmock_mutex

)

static testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_log_mutex  )

static

static testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_log_mutex  )

static

static testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_log_mutex  )

static

Referenced by GetFailureReporter(), testing::internal::AssertHelper::operator=(), testing::internal::GoogleTestFailureReporter::ReportFailure(), and ShouldRunTestCase().

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_

(

g_linked_ptr_mutex

)

testing::internal::GTEST_DEFINE_string_	(	internal_run_death_test	,
		""	,
		"Indicates the	file,
		line	number,
		temporal index of""the single death test to	run,
		and a file descriptor to""which a success code may be	sent,
		all separated by""the '|'characters.This flag is specified if and only if the current""process is a sub-process launched for running a thread-safe""death test.FOR INTERNAL USE ONLY."
	)

Referenced by testing::GetDefaultFilter().

static bool testing::internal::GTestIsInitialized ( )

static

Definition at line 330 of file gtest.cc.

References GetArgvs().

{ return GetArgvs().size() > 0; }

static bool testing::internal::GTestIsInitialized ( )

static

Definition at line 330 of file gtest.cc.

References GetArgvs().

{ return GetArgvs().size() > 0; }

static bool testing::internal::GTestIsInitialized ( )

static

Definition at line 330 of file gtest.cc.

References GetArgvs().

Referenced by InitGoogleTestImpl(), testing::internal::UnitTestImpl::RunAllTests(), and TearDownEnvironment().

{ return GetArgvs().size() > 0; }

template<class T , typename Result >

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

Definition at line 2410 of file gtest.cc.

References GetUnitTestImpl(), HandleSehExceptionsInMethodIfSupported(), testing::TestPartResult::kFatalFailure, and ReportFailureInUnknownLocation().

Referenced by testing::Test::Run(), testing::TestInfo::Run(), testing::TestCase::Run(), testing::UnitTest::Run(), testing::TestPartNonfatallyFailed(), and testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile().

                                                          {
  // NOTE: The user code can affect the way in which Google Test handles
  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
  // after the exception is caught and either report or re-throw the
  // exception based on the flag's value:
  //
  // try {
  //   // Perform the test method.
  // } catch (...) {
  //   if (GTEST_FLAG(catch_exceptions))
  //     // Report the exception as failure.
  //   else
  //     throw;  // Re-throws the original exception.
  // }
  //
  // However, the purpose of this flag is to allow the program to drop into
  // the debugger when the exception is thrown. On most platforms, once the
  // control enters the catch block, the exception origin information is
  // lost and the debugger will stop the program at the point of the
  // re-throw in this function -- instead of at the point of the original
  // throw statement in the code under test.  For this reason, we perform
  // the check early, sacrificing the ability to affect Google Test's
  // exception handling in the method where the exception is thrown.
  if (internal::GetUnitTestImpl()->catch_exceptions()) {
#if GTEST_HAS_EXCEPTIONS
    try {
      return HandleSehExceptionsInMethodIfSupported(object, method, location);
    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
      // This exception type can only be thrown by a failed Google
      // Test assertion with the intention of letting another testing
      // framework catch it.  Therefore we just re-throw it.
      throw;
    } catch (const std::exception& e) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(e.what(), location));
    } catch (...) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(NULL, location));
    }
    return static_cast<Result>(0);
#else
    return HandleSehExceptionsInMethodIfSupported(object, method, location);
#endif  // GTEST_HAS_EXCEPTIONS
  } else {
    return (object->*method)();
  }
}

template<class T , typename Result >

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

Definition at line 2383 of file gtest.cc.

References testing::TestPartResult::kFatalFailure, ReportFailureInUnknownLocation(), and string.

Referenced by HandleExceptionsInMethodIfSupported(), and testing::TestPartNonfatallyFailed().

                                                          {
#if GTEST_HAS_SEH
  __try {
    return (object->*method)();
  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
      GetExceptionCode())) {
    // We create the exception message on the heap because VC++ prohibits
    // creation of objects with destructors on stack in functions using __try
    // (see error C2712).
    std::string* exception_message = FormatSehExceptionMessage(
        GetExceptionCode(), location);
    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                             *exception_message);
    delete exception_message;
    return static_cast<Result>(0);
  }
#else
  (void)location;
  return (object->*method)();
#endif  // GTEST_HAS_SEH
}

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

static

Definition at line 5105 of file gtest.cc.

References GTEST_FLAG_PREFIX_, GTEST_FLAG_PREFIX_DASH_, and SkipPrefix().

                                                     {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

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

static

Definition at line 5105 of file gtest.cc.

References GTEST_FLAG_PREFIX_, GTEST_FLAG_PREFIX_DASH_, and SkipPrefix().

                                                     {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

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

static

Definition at line 5105 of file gtest.cc.

References GTEST_FLAG_PREFIX_, GTEST_FLAG_PREFIX_DASH_, and SkipPrefix().

Referenced by ParseGoogleTestFlagsOnlyImpl().

                                                     {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

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

Definition at line 631 of file gtest.cc.

References testing::AssertionFailure(), testing::AssertionSuccess(), testing::TestPartResultArray::GetTestPartResult(), i, testing::TestPartResult::kFatalFailure, testing::TestPartResult::message(), testing::TestPartResultArray::size(), string, testing::TestPartResult::type(), and type.

Referenced by ShouldRunTestCase(), and testing::internal::SingleFailureChecker::~SingleFailureChecker().

                                                    {
  const std::string expected(type == TestPartResult::kFatalFailure ?
                        "1 fatal failure" :
                        "1 non-fatal failure");
  Message msg;
  if (results.size() != 1) {
    msg << "Expected: " << expected << "\n"
        << "  Actual: " << results.size() << " failures";
    for (int i = 0; i < results.size(); i++) {
      msg << "\n" << results.GetTestPartResult(i);
    }
    return AssertionFailure() << msg;
  }

  const TestPartResult& r = results.GetTestPartResult(0);
  if (r.type() != type) {
    return AssertionFailure() << "Expected: " << expected << "\n"
                              << "  Actual:\n"
                              << r;
  }

  if (strstr(r.message(), substr.c_str()) == NULL) {
    return AssertionFailure() << "Expected: " << expected << " containing \""
                              << substr << "\"\n"
                              << "  Actual:\n"
                              << r;
  }

  return AssertionSuccess();
}

template<typename To >

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

inline

Definition at line 1343 of file gtest-port.h.

References x.

Referenced by foo::StreamableTemplateInFoo< T >::value().

{ return x; }

template<typename CharType >

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

Definition at line 128 of file gmock.cc.

References GMOCK_FLAG, i, testing::InitGoogleTest(), ParseGoogleMockBoolFlag(), ParseGoogleMockStringFlag(), StreamableToString(), and string.

Referenced by testing::InitGoogleMock(), and ParseGoogleMockStringFlag().

                                                    {
  // Makes sure Google Test is initialized.  InitGoogleTest() is
  // idempotent, so it's fine if the user has already called it.
  InitGoogleTest(argc, argv);
  if (*argc <= 0) return;

  for (int i = 1; i != *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();

    // Do we see a Google Mock flag?
    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
                                &GMOCK_FLAG(catch_leaked_mocks)) ||
        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
      // Yes.  Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }

      // Decrements the argument count.
      (*argc)--;

      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }
}

template<typename CharType >

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

Definition at line 5344 of file gtest.cc.

References g_argvs, GetUnitTestImpl(), GTestIsInitialized(), i, ParseGoogleTestFlagsOnly(), testing::internal::UnitTestImpl::PostFlagParsingInit(), and StreamableToString().

Referenced by testing::InitGoogleTest().

                                                    {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

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

Definition at line 4760 of file gtest.cc.

References testing::internal::posix::GetEnv(), and ParseInt32().

Referenced by testing::internal::UnitTestImpl::FilterTests(), testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(), testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd(), ShouldShard(), TearDownEnvironment(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                            {
  const char* str_val = posix::GetEnv(var);
  if (str_val == NULL) {
    return default_val;
  }

  Int32 result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

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

Definition at line 1204 of file gtest-port.cc.

References FlagToEnvVar(), testing::internal::posix::GetEnv(), ParseInt32(), and string.

Referenced by FlagToEnvVar(), and testing::GetDefaultFilter().

                                                               {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == NULL) {
    // The environment variable is not set.
    return default_value;
  }

  Int32 result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
}

template<typename T >

T testing::internal::Invalid ( )

inline

Definition at line 377 of file gmock-internal-utils.h.

References Assert().

Referenced by wangle::EvbHandshakeHelper::start().

                   {
  Assert(false, "", -1, "Internal error: attempt to return invalid value");
  // This statement is unreachable, and would never terminate even if it
  // could be reached. It is provided only to placate compiler warnings
  // about missing return statements.
  return Invalid<T>();
}

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

inline

Definition at line 2254 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords().

                             {
  return isalnum(static_cast<unsigned char>(ch)) != 0;
}

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

inline

Definition at line 2251 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords().

                             {
  return isalpha(static_cast<unsigned char>(ch)) != 0;
}

template<class C >

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

Definition at line 932 of file gtest-internal.h.

Referenced by TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                                {
  return 0;
}

template<class C >

IsNotContainer testing::internal::IsContainerTest

(

long

)

Definition at line 940 of file gtest-internal.h.

{ return '\0'; }

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

inline

Definition at line 2257 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords(), GetUnitTestImpl(), and testing::internal::UnitTestImpl::set_catch_exceptions().

                             {
  return isdigit(static_cast<unsigned char>(ch)) != 0;
}

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

inline

Definition at line 2260 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords().

                             {
  return islower(static_cast<unsigned char>(ch)) != 0;
}

AssertionResult testing::internal::IsNull

(

const char *

str

)

Definition at line 140 of file gtest-unittest-api_test.cc.

References testing::AssertionFailure(), and testing::AssertionSuccess().

Referenced by testing::internal::UnitTestHelper::GetSortedTests(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::MATCHER_P(), testing::internal::FinalSuccessChecker::TearDown(), TEST(), testing::gmock_matchers_test::TEST(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                        {
  if (str != NULL) {
    return testing::AssertionFailure() << "argument is " << str;
  }
  return AssertionSuccess();
}

char testing::internal::IsNullLiteralHelper

(

Secret *

p

)

char(& testing::internal::IsNullLiteralHelper

(

...

)

)[2]

static bool testing::internal::IsPathSeparator ( char  c )

static

Definition at line 90 of file gtest-filepath.cc.

References testing::internal::FilePath::c_str(), testing::internal::FilePath::ConcatPaths(), testing::internal::FilePath::CreateDirectoriesRecursively(), testing::internal::FilePath::CreateFolder(), upload::dest, testing::internal::FilePath::DirectoryExists(), testing::internal::String::EndsWithCaseInsensitive(), testing::internal::FilePath::FileOrDirectoryExists(), testing::internal::FilePath::FilePath(), testing::internal::FilePath::FindLastPathSeparator(), testing::internal::FilePath::GenerateUniqueFileName(), testing::internal::FilePath::GetCurrentDir(), GTEST_PATH_MAX_, testing::internal::FilePath::IsAbsolutePath(), testing::internal::posix::IsDir(), testing::internal::FilePath::IsDirectory(), testing::internal::FilePath::IsEmpty(), IsPathSeparator(), testing::internal::FilePath::IsRootDirectory(), kCurrentDirectoryString, kPathSeparator, testing::internal::FilePath::MakeFileName(), name, testing::internal::FilePath::Normalize(), number, parent, testing::internal::FilePath::pathname_, testing::internal::FilePath::RemoveDirectoryName(), testing::internal::FilePath::RemoveExtension(), testing::internal::FilePath::RemoveFileName(), testing::internal::FilePath::RemoveTrailingPathSeparator(), testing::internal::FilePath::Set(), testing::internal::posix::Stat(), StreamableToString(), testing::internal::FilePath::string(), and string.

                                    {
#if GTEST_HAS_ALT_PATH_SEP_
  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
#else
  return c == kPathSeparator;
#endif
}

static bool testing::internal::IsPathSeparator ( char  c )

static

Definition at line 90 of file gtest-filepath.cc.

References kPathSeparator.

Referenced by testing::internal::FilePath::IsAbsolutePath(), testing::internal::FilePath::IsDirectory(), IsPathSeparator(), testing::internal::FilePath::IsRootDirectory(), and testing::internal::FilePath::Normalize().

                                    {
#if GTEST_HAS_ALT_PATH_SEP_
  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
#else
  return c == kPathSeparator;
#endif
}

static bool testing::internal::IsPathSeparator ( char  c )

static

Definition at line 90 of file gtest-filepath.cc.

References testing::internal::FilePath::c_str(), testing::internal::FilePath::ConcatPaths(), testing::internal::FilePath::CreateDirectoriesRecursively(), testing::internal::FilePath::CreateFolder(), upload::dest, testing::internal::FilePath::DirectoryExists(), testing::internal::String::EndsWithCaseInsensitive(), testing::internal::FilePath::FileOrDirectoryExists(), testing::internal::FilePath::FilePath(), testing::internal::FilePath::FindLastPathSeparator(), testing::internal::FilePath::GenerateUniqueFileName(), testing::internal::FilePath::GetCurrentDir(), GTEST_PATH_MAX_, testing::internal::FilePath::IsAbsolutePath(), testing::internal::posix::IsDir(), testing::internal::FilePath::IsDirectory(), testing::internal::FilePath::IsEmpty(), IsPathSeparator(), testing::internal::FilePath::IsRootDirectory(), kCurrentDirectoryString, kPathSeparator, testing::internal::FilePath::MakeFileName(), name, testing::internal::FilePath::Normalize(), number, parent, testing::internal::FilePath::pathname_, testing::internal::FilePath::RemoveDirectoryName(), testing::internal::FilePath::RemoveExtension(), testing::internal::FilePath::RemoveFileName(), testing::internal::FilePath::RemoveTrailingPathSeparator(), testing::internal::FilePath::Set(), testing::internal::posix::Stat(), StreamableToString(), testing::internal::FilePath::string(), and string.

                                    {
#if GTEST_HAS_ALT_PATH_SEP_
  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
#else
  return c == kPathSeparator;
#endif
}

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

inline

Definition at line 137 of file gtest-printers.cc.

Referenced by PrintAsCharLiteralTo().

                                        {
  return 0x20 <= c && c <= 0x7E;
}

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

inline

Definition at line 688 of file gmock-matchers.h.

Referenced by testing::SafeMatcherCastImpl< T >::Cast(), MatchPrintAndExplain(), and testing::gmock_matchers_test::TEST().

                                                        {
  // We consider a type name readable if it's short or doesn't contain
  // a template or function type.
  return (type_name.length() <= 20 ||
          type_name.find_first_of("<(") == string::npos);
}

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

inline

Definition at line 2263 of file gtest-port.h.

Referenced by testing::internal::CodeLocation::CodeLocation(), testing::IsNotSubstring(), and StripTrailingSpaces().

                             {
  return isspace(static_cast<unsigned char>(ch)) != 0;
}

bool testing::internal::IsTrue

(

bool

condition

)

Definition at line 4986 of file gtest.cc.

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

{ return condition; }

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

inline

Definition at line 2266 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords().

                             {
  return isupper(static_cast<unsigned char>(ch)) != 0;
}

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

inline

Definition at line 1794 of file gtest.cc.

Referenced by WideStringToUtf8().

                                                                {
  return sizeof(wchar_t) == 2 &&
      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
}

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

inline

Definition at line 2269 of file gtest-port.h.

Referenced by PrintCharsAsStringTo(), and TEST().

                              {
  return isxdigit(static_cast<unsigned char>(ch)) != 0;
}

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

inline

Definition at line 2272 of file gtest-port.h.

References ch.

                                 {
  const unsigned char low_byte = static_cast<unsigned char>(ch);
  return ch == low_byte && isxdigit(low_byte) != 0;
}

GTEST_API_ string testing::internal::JoinAsTuple

(

const Strings &

fields

)

Definition at line 105 of file gmock-matchers.cc.

References i.

Referenced by FormatMatcherDescription(), and testing::gmock_matchers_test::TEST().

                                                     {
  switch (fields.size()) {
    case 0:
      return "";
    case 1:
      return fields[0];
    default:
      string result = "(" + fields[0];
      for (size_t i = 1; i < fields.size(); i++) {
        result += ", ";
        result += fields[i];
      }
      result += ")";
      return result;
  }
}

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

Definition at line 131 of file gmock-internal-utils.cc.

References GetCurrentOsStackTraceExceptTop(), testing::UnitTest::GetInstance(), kWarning, LogIsVisible(), and message.

Referenced by testing::internal::ExpectationBase::CheckActionCountIfNotDone(), testing::internal::TypedExpectation< F >::GetCurrentAction(), LogWithLocation(), testing::internal::GoogleTestFailureReporter::ReportFailure(), ReportUninterestingCall(), and testing::internal::UntypedFunctionMockerBase::UntypedInvokeWith().

                                              {
  if (!LogIsVisible(severity))
    return;

  // Ensures that logs from different threads don't interleave.
  MutexLock l(&g_log_mutex);

  // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is a
  // macro.

  if (severity == kWarning) {
    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
    std::cout << "\nGMOCK WARNING:";
  }
  // Pre-pends a new-line to message if it doesn't start with one.
  if (message.empty() || message[0] != '\n') {
    std::cout << "\n";
  }
  std::cout << message;
  if (stack_frames_to_skip >= 0) {
#ifdef NDEBUG
    // In opt mode, we have to be conservative and skip no stack frame.
    const int actual_to_skip = 0;
#else
    // In dbg mode, we can do what the caller tell us to do (plus one
    // for skipping this function's stack frame).
    const int actual_to_skip = stack_frames_to_skip + 1;
#endif  // NDEBUG

    // Appends a new-line to message if it doesn't end with one.
    if (!message.empty() && *message.rbegin() != '\n') {
      std::cout << "\n";
    }
    std::cout << "Stack trace:\n"
         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
             ::testing::UnitTest::GetInstance(), actual_to_skip);
  }
  std::cout << ::std::flush;
}

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

static

Definition at line 312 of file gmock-matchers.cc.

References gen_gtest_pred_impl::Iter(), and stream.

                                                         {
  typedef ElementMatcherPairs::const_iterator Iter;
  ::std::ostream& os = *stream;
  os << "{";
  const char *sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
    os << sep << "\n  ("
       << "element #" << it->first << ", "
       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
}

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

static

Definition at line 312 of file gmock-matchers.cc.

References b, FindMaxBipartiteMatching(), FindPairing(), GTEST_API_, testing::internal::MatchMatrix::HasEdge(), i, testing::MatchResultListener::IsInterested(), gen_gtest_pred_impl::Iter(), testing::internal::MatchMatrix::LhsSize(), testing::internal::MatchMatrix::RhsSize(), testing::MatchResultListener::stream(), and stream.

Referenced by FindPairing(), and LogElementMatcherPairVec().

                                                         {
  typedef ElementMatcherPairs::const_iterator Iter;
  ::std::ostream& os = *stream;
  os << "{";
  const char *sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
    os << sep << "\n  ("
       << "element #" << it->first << ", "
       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
}

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

static

Definition at line 312 of file gmock-matchers.cc.

References b, FindMaxBipartiteMatching(), FindPairing(), GTEST_API_, testing::internal::MatchMatrix::HasEdge(), i, testing::MatchResultListener::IsInterested(), gen_gtest_pred_impl::Iter(), testing::internal::MatchMatrix::LhsSize(), LogElementMatcherPairVec(), testing::internal::MatchMatrix::RhsSize(), testing::MatchResultListener::stream(), and stream.

                                                         {
  typedef ElementMatcherPairs::const_iterator Iter;
  ::std::ostream& os = *stream;
  os << "{";
  const char *sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
    os << sep << "\n  ("
       << "element #" << it->first << ", "
       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
}

GTEST_API_ bool testing::internal::LogIsVisible

(

LogSeverity

severity

)

Definition at line 110 of file gmock-internal-utils.cc.

References GMOCK_FLAG, kErrorVerbosity, kInfoVerbosity, and kWarning.

Referenced by Log(), testing::internal::GoogleTestFailureReporter::ReportFailure(), and testing::internal::UntypedFunctionMockerBase::UntypedInvokeWith().

                                                   {
  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
    // Always show the log if --gmock_verbose=info.
    return true;
  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
    // Always hide it if --gmock_verbose=error.
    return false;
  } else {
    // If --gmock_verbose is neither "info" nor "error", we treat it
    // as "warning" (its default value).
    return severity == kWarning;
  }
}

void testing::internal::LogToStderr ( )

inline

Definition at line 1275 of file gtest-port.h.

{}

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

Definition at line 59 of file gmock-spec-builders.cc.

References Log(), and s.

Referenced by testing::internal::TypedExpectation< F >::GetActionForArguments(), 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().

                                                       {
  ::std::ostringstream s;
  s << file << ":" << line << ": " << message << ::std::endl;
  Log(severity, s.str(), 0);
}

template<typename T >

linked_ptr< T > testing::internal::make_linked_ptr

(

T *

ptr

)

Definition at line 236 of file gtest-linked_ptr.h.

References ptr.

Referenced by testing::internal::linked_ptr< const testing::MatcherInterface< const internal::string & > >::copy().

                                      {
  return linked_ptr<T>(ptr);
}

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

Definition at line 2543 of file gtest.cc.

References testing::internal::UnitTestImpl::AddTestInfo(), testing::internal::CodeLocation::file, FormatFileLocation(), testing::Message::GetString(), GetUnitTestImpl(), testing::internal::CodeLocation::line, testing::TestInfo::name(), testing::TestInfo::name_, testing::TestInfo::test_case_name(), and testing::TestInfo::TestInfo().

Referenced by testing::internal::CodeLocation::CodeLocation(), testing::TestInfo::result(), and testing::TestPartNonfatallyFailed().

                              {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

template<typename M >

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

inline

Definition at line 1879 of file gmock-matchers.h.

References move().

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

                                             {
  return PredicateFormatterFromMatcher<M>(internal::move(matcher));
}

template<typename Tuple2Matcher , typename Second >

BoundSecondMatcher< Tuple2Matcher, Second > testing::internal::MatcherBindSecond	(	const Tuple2Matcher &	tm,
		const Second &	second
	)

Definition at line 3612 of file gmock-matchers.h.

References FormatMatcherDescription(), and GTEST_API_.

Referenced by testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::MatchAndExplain(), and testing::UnorderedPointwise().

                                                   {
  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
}

template<typename Value , typename T >

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

Definition at line 701 of file gmock-matchers.h.

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::SafeMatcherCastImpl< T >::Cast(), testing::internal::PointeeMatcher< InnerMatcher >::Impl< Pointer >::MatchAndExplain(), testing::internal::WhenDynamicCastToMatcher< To >::MatchAndExplain(), testing::internal::WhenDynamicCastToMatcher< To & >::MatchAndExplain(), testing::internal::ResultOfMatcher< Callable >::Impl< T >::MatchAndExplain(), testing::internal::FieldMatcher< Class, FieldType >::MatchAndExplainImpl(), testing::internal::PropertyMatcher< Class, PropertyType >::MatchAndExplainImpl(), and testing::internal::PredicateFormatterFromMatcher< M >::operator()().

                                                         {
  if (!listener->IsInterested()) {
    // If the listener is not interested, we do not need to construct the
    // inner explanation.
    return matcher.Matches(value);
  }

  StringMatchResultListener inner_listener;
  const bool match = matcher.MatchAndExplain(value, &inner_listener);

  UniversalPrint(value, listener->stream());
#if GTEST_HAS_RTTI
  const string& type_name = GetTypeName<Value>();
  if (IsReadableTypeName(type_name))
    *listener->stream() << " (of type " << type_name << ")";
#endif
  PrintIfNotEmpty(inner_listener.str(), listener->stream());

  return match;
}

template<typename T >

const T & testing::internal::move

(

const T &

t

)

Definition at line 1317 of file gtest-port.h.

References folly::pushmi::detail::t.

Referenced by testing::ByMove(), MakePredicateFormatterFromMatcher(), testing::internal::PredicateFormatterFromMatcher< M >::operator()(), testing::internal::ReturnAction< R >::Impl< ByMoveWrapper< R_ >, F >::Perform(), testing::internal::DoBothAction< Action1, Action2 >::Impl< F >::Perform(), testing::Return(), and ShouldRunTestCase().

                          {
  return t;
}

template<typename T >

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

inline

Definition at line 228 of file gtest-linked_ptr.h.

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

Referenced by testing::internal::linked_ptr< const testing::MatcherInterface< const internal::string & > >::copy(), and testing::TEST().

                                                {
  return ptr != x.get();
}

template<typename T >

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

inline

Definition at line 223 of file gtest-linked_ptr.h.

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

Referenced by testing::gmock_matchers_test::ConvertibleFromAny::ConvertibleFromAny(), testing::internal::linked_ptr< const testing::MatcherInterface< const internal::string & > >::copy(), testing::gmock_matchers_test::IntReferenceWrapper::IntReferenceWrapper(), testing::TEST(), and testing::gmock_matchers_test::Unprintable::Unprintable().

                                                {
  return ptr == x.get();
}

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

Definition at line 5053 of file gtest.cc.

References ParseFlagValue().

Referenced by ParseGoogleTestFlag(), ParseGoogleTestFlagsOnlyImpl(), and PrintOnOneLine().

                                                                   {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

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

Definition at line 5015 of file gtest.cc.

References flag, GTEST_FLAG_PREFIX_, and string.

Referenced by ParseBoolFlag(), ParseInt32Flag(), ParseStringFlag(), and PrintOnOneLine().

                                              {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

static bool testing::internal::ParseGoogleMockBoolFlag ( const char *  str, const char *  flag, bool *  value  )

static

Definition at line 91 of file gmock.cc.

References ParseGoogleMockFlagValue().

                                                 {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

static bool testing::internal::ParseGoogleMockBoolFlag ( const char *  str, const char *  flag, bool *  value  )

static

Definition at line 91 of file gmock.cc.

References ParseGoogleMockFlagValue().

Referenced by InitGoogleMockImpl(), and ParseGoogleMockStringFlag().

                                                 {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

static bool testing::internal::ParseGoogleMockBoolFlag ( const char *  str, const char *  flag, bool *  value  )

static

Definition at line 91 of file gmock.cc.

References ParseGoogleMockFlagValue().

                                                 {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

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

static

Definition at line 58 of file gmock.cc.

References flag, and string.

Referenced by ParseGoogleMockBoolFlag(), and ParseGoogleMockStringFlag().

                                                               {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--gmock_".
  const std::string flag_str = std::string("--gmock_") + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

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

static

Definition at line 58 of file gmock.cc.

References flag, and string.

                                                               {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--gmock_".
  const std::string flag_str = std::string("--gmock_") + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

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

static

Definition at line 58 of file gmock.cc.

References flag, and string.

                                                               {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--gmock_".
  const std::string flag_str = std::string("--gmock_") + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

template<typename String >

static bool testing::internal::ParseGoogleMockStringFlag ( const char *  str, const char *  flag, String *  value  )

static

Definition at line 110 of file gmock.cc.

References ParseGoogleMockFlagValue().

Referenced by InitGoogleMockImpl(), and ParseGoogleMockStringFlag().

                                                     {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

template<typename String >

static bool testing::internal::ParseGoogleMockStringFlag ( const char *  str, const char *  flag, String *  value  )

static

Definition at line 110 of file gmock.cc.

References argv, GMOCK_FLAG, GTEST_API_, i, testing::InitGoogleMock(), InitGoogleMockImpl(), testing::InitGoogleTest(), ParseGoogleMockBoolFlag(), ParseGoogleMockFlagValue(), ParseGoogleMockStringFlag(), StreamableToString(), and string.

                                                     {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

template<typename String >

static bool testing::internal::ParseGoogleMockStringFlag ( const char *  str, const char *  flag, String *  value  )

static

Definition at line 110 of file gmock.cc.

References argv, GMOCK_FLAG, GTEST_API_, i, testing::InitGoogleMock(), InitGoogleMockImpl(), testing::InitGoogleTest(), ParseGoogleMockBoolFlag(), ParseGoogleMockFlagValue(), ParseGoogleMockStringFlag(), StreamableToString(), and string.

                                                     {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

bool testing::internal::ParseGoogleTestFlag

(

const char *const

arg

)

Definition at line 5223 of file gtest.cc.

References testing::internal::UnitTestImpl::catch_exceptions(), folly::empty(), testing::internal::posix::FClose(), FILE, folly::pushmi::operators::filter, testing::internal::posix::FOpen(), g_help_flag, GTEST_FLAG, i, kAlsoRunDisabledTestsFlag, kBreakOnFailureFlag, kCatchExceptionsFlag, kColorFlag, kDeathTestStyleFlag, kDeathTestUseFork, kFilterFlag, kInternalRunDeathTestFlag, kListTestsFlag, kOutputFlag, kPrintTimeFlag, kRandomSeedFlag, kRepeatFlag, kShuffleFlag, kStackTraceDepthFlag, kStreamResultToFlag, kThrowOnFailureFlag, folly::gen::lines(), gmock_output_test::output, ParseBoolFlag(), ParseInt32Flag(), ParseStringFlag(), testing::internal::UnitTestImpl::random_seed(), ReadEntireFile(), repeat(), SplitString(), and string.

Referenced by ParseGoogleTestFlagsOnlyImpl().

                                                {
  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
                       &GTEST_FLAG(also_run_disabled_tests)) ||
      ParseBoolFlag(arg, kBreakOnFailureFlag,
                    &GTEST_FLAG(break_on_failure)) ||
      ParseBoolFlag(arg, kCatchExceptionsFlag,
                    &GTEST_FLAG(catch_exceptions)) ||
      ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
      ParseStringFlag(arg, kDeathTestStyleFlag,
                      &GTEST_FLAG(death_test_style)) ||
      ParseBoolFlag(arg, kDeathTestUseFork,
                    &GTEST_FLAG(death_test_use_fork)) ||
      ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
      ParseStringFlag(arg, kInternalRunDeathTestFlag,
                      &GTEST_FLAG(internal_run_death_test)) ||
      ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
      ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
      ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
      ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
      ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
      ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
      ParseInt32Flag(arg, kStackTraceDepthFlag,
                     &GTEST_FLAG(stack_trace_depth)) ||
      ParseStringFlag(arg, kStreamResultToFlag,
                      &GTEST_FLAG(stream_result_to)) ||
      ParseBoolFlag(arg, kThrowOnFailureFlag,
                    &GTEST_FLAG(throw_on_failure));
}

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

Definition at line 5332 of file gtest.cc.

References ParseGoogleTestFlagsOnlyImpl().

Referenced by GetUnitTestImpl(), InitGoogleTestImpl(), testing::internal::UnitTestImpl::set_catch_exceptions(), and testing::InitGoogleTestTest::TestParsingFlags().

                                                      {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

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

Definition at line 5335 of file gtest.cc.

References ParseGoogleTestFlagsOnlyImpl().

                                                         {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

template<typename CharType >

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

Definition at line 5279 of file gtest.cc.

References g_help_flag, GTEST_FLAG, HasGoogleTestFlagPrefix(), i, kFlagfileFlag, ParseBoolFlag(), ParseGoogleTestFlag(), ParseInt32Flag(), ParseStringFlag(), PrintColorEncoded(), StreamableToString(), and string.

Referenced by ParseGoogleTestFlagsOnly().

                                                              {
  for (int i = 1; i < *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();

    using internal::ParseBoolFlag;
    using internal::ParseInt32Flag;
    using internal::ParseStringFlag;

    bool remove_flag = false;
    if (ParseGoogleTestFlag(arg)) {
      remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
      LoadFlagsFromFile(GTEST_FLAG(flagfile));
      remove_flag = true;
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (arg_string == "--help" || arg_string == "-h" ||
               arg_string == "-?" || arg_string == "/?" ||
               HasGoogleTestFlagPrefix(arg)) {
      // Both help flag and unrecognized Google Test flags (excluding
      // internal ones) trigger help display.
      g_help_flag = true;
    }

    if (remove_flag) {
      // Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }

      // Decrements the argument count.
      (*argc)--;

      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }

  if (g_help_flag) {
    // We print the help here instead of in RUN_ALL_TESTS(), as the
    // latter may not be called at all if the user is using Google
    // Test with another testing framework.
    PrintColorEncoded(kColorEncodedHelpMessage);
  }
}

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

Definition at line 1149 of file gtest-port.cc.

References folly::test::end(), and testing::Message::GetString().

Referenced by FlagToEnvVar(), Int32FromEnvOrDie(), Int32FromGTestEnv(), ParseInt32Flag(), PrintOnOneLine(), and TearDownEnvironment().

                                                                        {
  // Parses the environment variable as a decimal integer.
  char* end = NULL;
  const long long_value = strtol(str, &end, 10);  // NOLINT

  // Has strtol() consumed all characters in the string?
  if (*end != '\0') {
    // No - an invalid character was encountered.
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value \"" << str << "\".\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  // Is the parsed value in the range of an Int32?
  const Int32 result = static_cast<Int32>(long_value);
  if (long_value == LONG_MAX || long_value == LONG_MIN ||
      // The parsed value overflows as a long.  (strtol() returns
      // LONG_MAX or LONG_MIN when the input overflows.)
      result != long_value
      // The parsed value overflows as an Int32.
      ) {
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }

  *value = result;
  return true;
}

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

Definition at line 5070 of file gtest.cc.

References ParseFlagValue(), and ParseInt32().

Referenced by ParseGoogleTestFlag(), ParseGoogleTestFlagsOnlyImpl(), PrintOnOneLine(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                                     {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag,
                    value_str, value);
}

bool testing::internal::ParseStringFlag	(	const char *	str,
		const char *	flag,
		std::string *	value
	)

Definition at line 5087 of file gtest.cc.

References ParseFlagValue().

Referenced by ParseGoogleTestFlag(), ParseGoogleTestFlagsOnlyImpl(), and PrintOnOneLine().

                                                                          {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

static bool testing::internal::PortableLocaltime ( time_t  seconds, struct tm *  out  )

static

Definition at line 3556 of file gtest.cc.

References testing::TestCase::ad_hoc_test_result(), testing::UnitTest::ad_hoc_test_result(), ch, folly::netops::close(), folly::netops::connect(), testing::internal::OsStackTraceGetter::CurrentStackTrace(), data, testing::TestResult::elapsed_time(), testing::TestCase::elapsed_time(), testing::UnitTest::elapsed_time(), testing::TestPartResult::failed(), testing::TestCase::failed_test_count(), testing::UnitTest::failed_test_count(), testing::internal::TraceInfo::file, testing::TestPartResult::file_name(), testing::internal::String::FormatByte(), FormatCompilerIndependentFileLocation(), FormatEpochTimeInMillisAsIso8601(), testing::internal::String::FormatIntWidth2(), FormatTimeInMillisAsSeconds(), testing::UnitTest::GetInstance(), testing::GetReservedAttributesForElement(), testing::Message::GetString(), testing::UnitTest::GetTestCase(), testing::TestCase::GetTestInfo(), testing::TestResult::GetTestPartResult(), testing::TestResult::GetTestProperty(), GTEST_CHECK_, GTEST_FLAG, GTEST_LOCK_EXCLUDED_, GTEST_LOG_, GTEST_NAME_, i, testing::TestInfo::is_reportable(), testing::internal::OsStackTraceGetterInterface::kElidedFramesMarker, testing::internal::TraceInfo::line, testing::TestPartResult::line_number(), testing::TestPartResult::message(), testing::internal::TraceInfo::message, testing::UnitTest::mutex_, name, testing::TestInfo::name(), testing::TestCase::name(), testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(), testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(), testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), testing::UnitTest::PopGTestTrace(), PortableLocaltime(), testing::internal::XmlUnitTestResultPrinter::PrintXmlTestCase(), testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(), testing::UnitTest::PushGTestTrace(), testing::UnitTest::random_seed(), testing::TestCase::reportable_disabled_test_count(), testing::UnitTest::reportable_disabled_test_count(), testing::TestCase::reportable_test_count(), testing::UnitTest::reportable_test_count(), testing::TestInfo::result(), testing::internal::ScopedTrace::ScopedTrace(), testing::TestInfo::should_run(), folly::netops::socket(), testing::UnitTest::start_timestamp(), StreamableToString(), string, testing::TestPartResult::summary(), testing::TestResult::test_property_count(), testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(), testing::TestResult::total_part_count(), testing::UnitTest::total_test_case_count(), testing::TestCase::total_test_count(), testing::TestInfo::type_param(), testing::internal::OsStackTraceGetter::UponLeavingGTest(), testing::TestInfo::value_param(), and testing::internal::ScopedTrace::~ScopedTrace().

                                                              {
#if defined(_MSC_VER)
  return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
  // Windows' localtime(), which has a thread-local tm buffer.
  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
  if (tm_ptr == NULL)
    return false;
  *out = *tm_ptr;
  return true;
#else
  return localtime_r(&seconds, out) != NULL;
#endif
}

static bool testing::internal::PortableLocaltime ( time_t  seconds, struct tm *  out  )

static

Definition at line 3556 of file gtest.cc.

References testing::TestCase::ad_hoc_test_result(), testing::UnitTest::ad_hoc_test_result(), ch, folly::netops::close(), folly::netops::connect(), testing::internal::OsStackTraceGetter::CurrentStackTrace(), data, testing::TestResult::elapsed_time(), testing::TestCase::elapsed_time(), testing::UnitTest::elapsed_time(), testing::TestPartResult::failed(), testing::TestCase::failed_test_count(), testing::UnitTest::failed_test_count(), testing::internal::TraceInfo::file, testing::TestPartResult::file_name(), testing::internal::String::FormatByte(), FormatCompilerIndependentFileLocation(), FormatEpochTimeInMillisAsIso8601(), testing::internal::String::FormatIntWidth2(), FormatTimeInMillisAsSeconds(), testing::UnitTest::GetInstance(), testing::GetReservedAttributesForElement(), testing::Message::GetString(), testing::UnitTest::GetTestCase(), testing::TestCase::GetTestInfo(), testing::TestResult::GetTestPartResult(), testing::TestResult::GetTestProperty(), GTEST_CHECK_, GTEST_FLAG, GTEST_LOCK_EXCLUDED_, GTEST_LOG_, GTEST_NAME_, i, testing::TestInfo::is_reportable(), testing::internal::OsStackTraceGetterInterface::kElidedFramesMarker, testing::internal::TraceInfo::line, testing::TestPartResult::line_number(), testing::TestPartResult::message(), testing::internal::TraceInfo::message, testing::UnitTest::mutex_, name, testing::TestInfo::name(), testing::TestCase::name(), testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(), testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(), testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), testing::UnitTest::PopGTestTrace(), PortableLocaltime(), testing::internal::XmlUnitTestResultPrinter::PrintXmlTestCase(), testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(), testing::UnitTest::PushGTestTrace(), testing::UnitTest::random_seed(), testing::TestCase::reportable_disabled_test_count(), testing::UnitTest::reportable_disabled_test_count(), testing::TestCase::reportable_test_count(), testing::UnitTest::reportable_test_count(), testing::TestInfo::result(), testing::internal::ScopedTrace::ScopedTrace(), testing::TestInfo::should_run(), folly::netops::socket(), testing::UnitTest::start_timestamp(), StreamableToString(), string, testing::TestPartResult::summary(), testing::TestResult::test_property_count(), testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(), testing::TestResult::total_part_count(), testing::UnitTest::total_test_case_count(), testing::TestCase::total_test_count(), testing::TestInfo::type_param(), testing::internal::OsStackTraceGetter::UponLeavingGTest(), testing::TestInfo::value_param(), and testing::internal::ScopedTrace::~ScopedTrace().

                                                              {
#if defined(_MSC_VER)
  return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
  // Windows' localtime(), which has a thread-local tm buffer.
  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
  if (tm_ptr == NULL)
    return false;
  *out = *tm_ptr;
  return true;
#else
  return localtime_r(&seconds, out) != NULL;
#endif
}

static bool testing::internal::PortableLocaltime ( time_t  seconds, struct tm *  out  )

static

Definition at line 3556 of file gtest.cc.

Referenced by FormatEpochTimeInMillisAsIso8601(), and PortableLocaltime().

                                                              {
#if defined(_MSC_VER)
  return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
  // Windows' localtime(), which has a thread-local tm buffer.
  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
  if (tm_ptr == NULL)
    return false;
  *out = *tm_ptr;
  return true;
#else
  return localtime_r(&seconds, out) != NULL;
#endif
}

template<typename UnsignedChar , typename Char >

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

static

Definition at line 146 of file gtest-printers.cc.

References c, IsPrintableAscii(), kAsIs, kHexEscape, and kSpecialEscape.

                                                            {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

template<typename UnsignedChar , typename Char >

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

static

Definition at line 146 of file gtest-printers.cc.

References c, IsPrintableAscii(), kAsIs, kHexEscape, and kSpecialEscape.

                                                            {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

template<typename UnsignedChar , typename Char >

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

static

Definition at line 146 of file gtest-printers.cc.

References c, IsPrintableAscii(), kAsIs, kHexEscape, and kSpecialEscape.

                                                            {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

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

static

Definition at line 192 of file gtest-printers.cc.

References c, kAsIs, and kSpecialEscape.

                                                                 {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

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

static

Definition at line 192 of file gtest-printers.cc.

References c, kAsIs, and kSpecialEscape.

                                                                 {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

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

static

Definition at line 192 of file gtest-printers.cc.

References c, kAsIs, and kSpecialEscape.

                                                                 {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

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

static

Definition at line 207 of file gtest-printers.cc.

References c, testing::gmock_generated_actions_test::Char(), folly::format(), GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_, kHexEscape, PrintCharAndCodeTo(), and PrintTo().

Referenced by PrintAsStringLiteralTo(), and PrintCharsAsStringTo().

                                                              {
  return PrintAsStringLiteralTo(
      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
}

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

static

Definition at line 207 of file gtest-printers.cc.

References PrintAsStringLiteralTo().

                                                              {
  return PrintAsStringLiteralTo(
      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
}

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

static

Definition at line 207 of file gtest-printers.cc.

References c, testing::gmock_generated_actions_test::Char(), folly::format(), GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_, kHexEscape, PrintAsStringLiteralTo(), PrintCharAndCodeTo(), and PrintTo().

                                                              {
  return PrintAsStringLiteralTo(
      static_cast<wchar_t>(static_cast<unsigned char>(c)), os);
}

template<typename UnsignedChar , typename Char >

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

Definition at line 217 of file gtest-printers.cc.

References c, folly::format(), and kHexEscape.

Referenced by PrintAsStringLiteralTo().

                                             {
  // First, print c as a literal in the most readable form we can find.
  *os << ((sizeof(c) > 1) ? "L'" : "'");
  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexidecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
  }
  *os << ")";
}

template<typename CharType >

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

static

Definition at line 262 of file gtest-printers.cc.

References GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_, IsXDigit(), kHexEscape, and PrintAsStringLiteralTo().

                                                    {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
  }
  *os << "\"";
}

template<typename CharType >

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

static

Definition at line 262 of file gtest-printers.cc.

References GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_, IsXDigit(), kHexEscape, and PrintAsStringLiteralTo().

Referenced by PrintStringTo(), PrintTo(), and UniversalPrintCharArray().

                                                    {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
  }
  *os << "\"";
}

template<typename CharType >

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

static

Definition at line 262 of file gtest-printers.cc.

References GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_, IsXDigit(), kHexEscape, and PrintAsStringLiteralTo().

                                                    {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
  }
  *os << "\"";
}

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

static

Definition at line 5125 of file gtest.cc.

References ch, COLOR_DEFAULT, COLOR_GREEN, COLOR_RED, COLOR_YELLOW, ColoredPrintf(), and string.

                                               {
  GTestColor color = COLOR_DEFAULT;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == NULL) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

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

static

Definition at line 5125 of file gtest.cc.

References ch, COLOR_DEFAULT, COLOR_GREEN, COLOR_RED, COLOR_YELLOW, ColoredPrintf(), and string.

Referenced by ParseGoogleTestFlagsOnlyImpl().

                                               {
  GTestColor color = COLOR_DEFAULT;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == NULL) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

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

static

Definition at line 5125 of file gtest.cc.

References ch, COLOR_DEFAULT, COLOR_GREEN, COLOR_RED, COLOR_YELLOW, ColoredPrintf(), and string.

                                               {
  GTestColor color = COLOR_DEFAULT;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == NULL) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

void testing::internal::PrintFullTestCommentIfPresent

(

const TestInfo &

test_info

)

Definition at line 3009 of file gtest.cc.

References testing::TestInfo::type_param(), testing::TestCase::type_param(), and testing::TestInfo::value_param().

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd(), and testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests().

                                                              {
  const char* const type_param = test_info.type_param();
  const char* const value_param = test_info.value_param();

  if (type_param != NULL || value_param != NULL) {
    printf(", where ");
    if (type_param != NULL) {
      printf("%s = %s", kTypeParamLabel, type_param);
      if (value_param != NULL)
        printf(" and ");
    }
    if (value_param != NULL) {
      printf("%s = %s", kValueParamLabel, value_param);
    }
  }
}

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

inline

Definition at line 678 of file gmock-matchers.h.

Referenced by testing::SafeMatcherCastImpl< T >::Cast(), testing::internal::TuplePrefix< N >::ExplainMatchFailuresTo(), testing::internal::TypedExpectation< F >::ExplainMatchResultTo(), testing::internal::ArgsMatcherImpl< ArgsTuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 >::MatchAndExplain(), testing::internal::SizeIsMatcher< SizeMatcher >::Impl< Container >::MatchAndExplain(), testing::internal::BeginEndDistanceIsMatcher< DistanceMatcher >::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().

                                            {
  if (explanation != "" && os != NULL) {
    *os << ", " << explanation;
  }
}

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

static

Definition at line 4846 of file gtest.cc.

References i.

Referenced by testing::internal::UnitTestImpl::ListTestsMatchingFilter(), and PrintOnOneLine().

                                                            {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

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

static

Definition at line 4846 of file gtest.cc.

References AlwaysTrue(), testing::internal::UnitTestImpl::current_test_result(), testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop(), flag, GetCurrentOsStackTraceExceptTop(), GetUnitTestImpl(), GTEST_FLAG_PREFIX_, i, IsTrue(), testing::internal::UnitTestImpl::ListTestsMatchingFilter(), testing::TestInfo::matches_filter_, testing::TestInfo::name(), testing::TestCase::name(), testing::internal::UnitTestImpl::os_stack_trace_getter(), ParseBoolFlag(), ParseFlagValue(), ParseInt32(), ParseInt32Flag(), ParseStringFlag(), prefix(), PrintOnOneLine(), random(), testing::internal::UnitTestImpl::set_os_stack_trace_getter(), ShuffleRange(), testing::internal::UnitTestImpl::ShuffleTests(), SkipPrefix(), string, testing::TestCase::test_info_list(), testing::TestCase::type_param(), testing::internal::UnitTestImpl::UnshuffleTests(), and testing::TestInfo::value_param().

                                                            {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

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

static

Definition at line 4846 of file gtest.cc.

References AlwaysTrue(), testing::internal::UnitTestImpl::current_test_result(), testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop(), flag, GetCurrentOsStackTraceExceptTop(), GetUnitTestImpl(), GTEST_FLAG_PREFIX_, i, IsTrue(), testing::internal::UnitTestImpl::ListTestsMatchingFilter(), testing::TestInfo::matches_filter_, testing::TestInfo::name(), testing::TestCase::name(), testing::internal::UnitTestImpl::os_stack_trace_getter(), ParseBoolFlag(), ParseFlagValue(), ParseInt32(), ParseInt32Flag(), ParseStringFlag(), prefix(), PrintOnOneLine(), random(), testing::internal::UnitTestImpl::set_os_stack_trace_getter(), ShuffleRange(), testing::internal::UnitTestImpl::ShuffleTests(), SkipPrefix(), string, testing::TestCase::test_info_list(), testing::TestCase::type_param(), testing::internal::UnitTestImpl::UnshuffleTests(), and testing::TestInfo::value_param().

                                                            {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

template<typename T >

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

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

References count, GTEST_API_, i, PrintStringTo(), PrintTo(), string, and UniversalPrint().

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

                                                                {
  UniversalPrint(a[0], os);
  for (size_t i = 1; i != count; i++) {
    *os << ", ";
    UniversalPrint(a[i], os);
  }
}

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

Definition at line 354 of file gtest-printers.cc.

References PrintCharsAsStringTo().

Referenced by PrintTo(), and UniversalPrintCharArray().

                                                    {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}

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

Referenced by PrintRawArrayTo(), and PrintTo().

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

static

Definition at line 2860 of file gtest.cc.

References PrintTestPartResultToString(), and string.

                                                                        {
  const std::string& result =
      PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

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

static

Definition at line 2860 of file gtest.cc.

References PrintTestPartResultToString(), and string.

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd().

                                                                        {
  const std::string& result =
      PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

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

static

Definition at line 2860 of file gtest.cc.

References PrintTestPartResultToString(), and string.

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult().

                                                                        {
  const std::string& result =
      PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

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

static

Definition at line 2850 of file gtest.cc.

References testing::TestPartResult::file_name(), FormatFileLocation(), testing::TestPartResult::line_number(), testing::TestPartResult::message(), testing::TestPartResultTypeToString(), and testing::TestPartResult::type().

                                            {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

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

static

Definition at line 2850 of file gtest.cc.

References testing::TestPartResult::file_name(), FormatFileLocation(), testing::TestPartResult::line_number(), testing::TestPartResult::message(), testing::TestPartResultTypeToString(), and testing::TestPartResult::type().

Referenced by testing::Test::HasSameFixtureClass(), and PrintTestPartResult().

                                            {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

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

static

Definition at line 2850 of file gtest.cc.

References testing::TestPartResult::file_name(), FormatFileLocation(), testing::TestPartResult::line_number(), testing::TestPartResult::message(), testing::TestPartResultTypeToString(), and testing::TestPartResult::type().

Referenced by PrintTestPartResult(), and testing::TestPartNonfatallyFailed().

                                            {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

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

Definition at line 250 of file gtest-printers.cc.

References GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_, GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_, and GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_.

                                      {
  PrintCharAndCodeTo<wchar_t>(wc, os);
}

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

Definition at line 320 of file gtest-printers.cc.

References PrintCharsAsStringTo(), and s.

                                         {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, strlen(s), os);
  }
}

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

Definition at line 337 of file gtest-printers.cc.

References PrintCharsAsStringTo(), PrintStringTo(), s, and string.

Referenced by PrintAsStringLiteralTo(), and UniversalPrintCharArray().

                                            {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, std::wcslen(s), os);
  }
}

template<typename T >

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

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

References c, DefaultPrintTo(), GTEST_API_, and PrintTo().

                                             {
  // DefaultPrintTo() is overloaded.  The type of its first two
  // arguments determine which version will be picked.  If T is an
  // STL-style container, the version for container will be called; if
  // T is a pointer, the pointer version will be called; otherwise the
  // generic version will be called.
  //
  // Note that we check for container types here, prior to we check
  // for protocol message types in our operator<<.  The rationale is:
  //
  // For protocol messages, we want to give people a chance to
  // override Google Mock's format by defining a PrintTo() or
  // operator<<.  For STL containers, other formats can be
  // incompatible with Google Mock's format for the container
  // elements; therefore we check for container types here to ensure
  // that our format is used.
  //
  // The second argument of DefaultPrintTo() is needed to bypass a bug
  // in Symbian's C++ compiler that prevents it from picking the right
  // overload between:
  //
  //   PrintTo(const T& x, ...);
  //   PrintTo(T* x, ...);
  DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
}

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

Definition at line 241 of file gtest-printers.cc.

References c.

                                              {
  PrintCharAndCodeTo<unsigned char>(c, os);
}

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

Definition at line 244 of file gtest-printers.cc.

References c.

                                            {
  PrintCharAndCodeTo<unsigned char>(c, os);
}

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

inline

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

References PrintTo().

                                            {
  // When printing a plain char, we always treat it as unsigned.  This
  // way, the output won't be affected by whether the compiler thinks
  // char is signed or not.
  PrintTo(static_cast<unsigned char>(c), os);
}

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

inline

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

References GTEST_API_, PrintTo(), and s.

                                            {
  *os << (x ? "true" : "false");
}

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

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

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

inline

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

References PrintTo().

                                             {
  PrintTo(ImplicitCast_<const char*>(s), os);
}

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

inline

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

References PrintTo().

                                                          {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

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

inline

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

References PrintTo().

                                                    {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

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

inline

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

References PrintTo().

                                                            {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

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

inline

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

References GTEST_API_, and PrintTo().

                                                      {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

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

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

inline

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

References PrintTo().

                                                {
  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
}

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

inline

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

References GTEST_API_, PrintStringTo(), PrintTo(), folly::pushmi::detail::t, and T.

                                                        {
  PrintStringTo(s, os);
}

template<typename T1 , typename T2 >

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

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

References GTEST_DISABLE_MSC_WARNINGS_PUSH_, and testing::gtest_printers_test::Print().

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

                                                           {
  *os << '(';
  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
  // a reference type.  The same for printing value.second.
  UniversalPrinter<T1>::Print(value.first, os);
  *os << ", ";
  UniversalPrinter<T2>::Print(value.second, os);
  *os << ')';
}

template<typename T >

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

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

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

Referenced by testing::internal::edit_distance::CalculateOptimalEdits(), testing::internal::ReferenceWrapper< T >::operator T &(), testing::internal::ExpectationTester::SetCallCount(), and TEST().

                                                             {
  T& value = ref;
  UniversalPrinter<T&>::Print(value, os);
}

std::string testing::internal::ReadEntireFile

(

FILE *

file

)

Definition at line 1081 of file gtest-port.cc.

References testing::internal::posix::Abort(), buffer(), GetArgvs(), GetFileSize(), and string.

Referenced by CheckedDowncastToActualType(), ParseGoogleTestFlag(), and testing::internal::GTestLog::~GTestLog().

                                     {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far

  fseek(file, 0, SEEK_SET);

  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);

  const std::string content(buffer, bytes_read);
  delete[] buffer;

  return content;
}

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

Definition at line 2250 of file gtest.cc.

References testing::UnitTest::AddTestPartResult(), and testing::UnitTest::GetInstance().

Referenced by HandleExceptionsInMethodIfSupported(), HandleSehExceptionsInMethodIfSupported(), testing::UnitTest::impl(), and testing::TestPartNonfatallyFailed().

                                                              {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      NULL,  // No info about the source file where the exception occurred.
      -1,    // We have no info on which line caused the exception.
      message,
      "");   // No stack trace, either.
}

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

Definition at line 247 of file gmock-spec-builders.cc.

References Expect(), GMOCK_FLAG, kAllow, kInfo, kInfoVerbosity, kWarn, kWarning, and Log().

Referenced by testing::internal::FunctionMockerBase< R(A1, A2)>::PrintTriedExpectationsLocked(), and testing::internal::UntypedFunctionMockerBase::UntypedInvokeWith().

                                                                       {
  // Include a stack trace only if --gmock_verbose=info is specified.
  const int stack_frames_to_skip =
      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
  switch (reaction) {
    case kAllow:
      Log(kInfo, msg, stack_frames_to_skip);
      break;
    case kWarn:
      Log(kWarning,
          msg +
          "\nNOTE: You can safely ignore the above warning unless this "
          "call should not happen.  Do not suppress it by blindly adding "
          "an EXPECT_CALL() if you don't mean to enforce the call.  "
          "See https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#"
          "knowing-when-to-expect for details.\n",
          stack_frames_to_skip);
      break;
    default:  // FAIL
      Expect(false, NULL, -1, msg);
  }
}

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

static

Definition at line 4539 of file gtest.cc.

References testing::Environment::SetUp().

{ env->SetUp(); }

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

static

Definition at line 4539 of file gtest.cc.

References testing::Environment::SetUp().

Referenced by testing::internal::UnitTestImpl::RunAllTests(), and TearDownEnvironment().

{ env->SetUp(); }

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

static

Definition at line 4539 of file gtest.cc.

References testing::Environment::SetUp().

{ env->SetUp(); }

static bool testing::internal::ShouldRunTestCase ( const TestCase *  test_case )

static

Definition at line 356 of file gtest.cc.

References add, AlwaysTrue(), AppendUserMessage(), testing::internal::AssertHelper::AssertHelper(), testing::AssertionFailure(), testing::AssertionResult::AssertionResult(), testing::AssertionSuccess(), testing::internal::edit_distance::CalculateOptimalEdits(), testing::internal::FilePath::ConcatPaths(), CountIf(), testing::internal::String::CStringEquals(), testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop(), data_, testing::internal::DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(), testing::internal::DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(), upload::dest, folly::digits10(), testing::internal::UnitTestImpl::disabled_test_count(), testing::TestCase::disabled_test_count(), folly::pushmi::operators::error(), EXPECT_PRED_FORMAT3, testing::internal::UnitTestImpl::failed_test_case_count(), testing::internal::UnitTestImpl::failed_test_count(), testing::TestCase::failed_test_count(), folly::pushmi::operators::filter, testing::internal::UnitTestOptions::FilterMatchesTest(), g_argvs, testing::internal::FilePath::GenerateUniqueFileName(), testing::internal::scoped_ptr< T >::get(), testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(), GetArgvs(), GetCurrentExecutableName(), testing::internal::UnitTestImpl::GetGlobalTestPartResultReporter(), testing::UnitTest::GetInstance(), testing::internal::UnitTestOptions::GetOutputFormat(), testing::Message::GetString(), testing::TestPartResultArray::GetTestPartResult(), testing::internal::UnitTestImpl::GetTestPartResultReporterForCurrentThread(), GetTestTypeId(), GetTimeInMillis(), GetUnitTestImpl(), GTEST_API_, GTEST_DEFINE_STATIC_MUTEX_(), GTEST_DISABLE_MSC_WARNINGS_POP_, GTEST_DISABLE_MSC_WARNINGS_PUSH_, GTEST_FLAG, GTEST_HAS_GETTIMEOFDAY_, HasOneFailure(), i, ids_, testing::UnitTest::impl(), testing::ScopedFakeTestPartResultReporter::Init(), testing::internal::FilePath::IsAbsolutePath(), testing::internal::FilePath::IsDirectory(), testing::internal::edit_distance::kAdd, testing::TestPartResult::kFatalFailure, testing::internal::edit_distance::kMatch, testing::internal::edit_distance::kRemove, testing::internal::edit_distance::kReplace, kTestTypeIdInGoogleTest, testing::kUniversalFilter, folly::detail::lock(), testing::internal::UnitTestOptions::MatchesFilter(), testing::TestPartResult::message(), testing::Message::Message(), message, testing::AssertionResult::message_, move(), name, now(), testing::AssertionResult::operator!(), testing::Message::operator<<(), testing::internal::AssertHelper::operator=(), gmock_output_test::output, testing::internal::UnitTestOptions::PatternMatchesString(), testing::internal::FilePath::RemoveDirectoryName(), replace(), testing::internal::UnitTestImpl::reportable_disabled_test_count(), testing::TestCase::reportable_disabled_test_count(), testing::internal::UnitTestImpl::reportable_test_count(), testing::TestCase::reportable_test_count(), testing::ScopedFakeTestPartResultReporter::ReportTestPartResult(), testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(), testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult(), folly::detail::rhs, testing::ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(), testing::internal::FilePath::Set(), testing::internal::UnitTestImpl::SetGlobalTestPartResultReporter(), testing::internal::UnitTestImpl::SetTestPartResultReporterForCurrentThread(), testing::TestCase::should_run(), ShouldRunTestCase(), testing::internal::String::ShowWideCString(), testing::internal::SingleFailureChecker::SingleFailureChecker(), testing::TestPartResultArray::size(), SplitString(), testing::internal::FilePath::string(), string, StringStreamToString(), testing::AssertionResult::success_, testing::internal::UnitTestImpl::successful_test_case_count(), testing::internal::UnitTestImpl::successful_test_count(), testing::TestCase::successful_test_count(), SumOverTestCaseList(), testing::AssertionResult::swap(), folly::f14::swap(), testing::internal::UnitTestImpl::test_case_to_run_count(), testing::internal::UnitTestImpl::test_to_run_count(), testing::TestCase::test_to_run_count(), TestCaseFailed(), TestCasePassed(), testing::internal::UnitTestImpl::total_test_case_count(), testing::internal::UnitTestImpl::total_test_count(), testing::TestCase::total_test_count(), testing::TestPartResult::type(), type, type_, testing::internal::AssertHelper::~AssertHelper(), testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter(), and testing::internal::SingleFailureChecker::~SingleFailureChecker().

                                                         {
  return test_case->should_run();
}

static bool testing::internal::ShouldRunTestCase ( const TestCase *  test_case )

static

Definition at line 356 of file gtest.cc.

References add, AlwaysTrue(), AppendUserMessage(), testing::internal::AssertHelper::AssertHelper(), testing::AssertionFailure(), testing::AssertionResult::AssertionResult(), testing::AssertionSuccess(), testing::internal::edit_distance::CalculateOptimalEdits(), testing::internal::FilePath::ConcatPaths(), CountIf(), testing::internal::String::CStringEquals(), testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop(), data_, testing::internal::DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(), testing::internal::DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(), upload::dest, folly::digits10(), testing::internal::UnitTestImpl::disabled_test_count(), testing::TestCase::disabled_test_count(), folly::pushmi::operators::error(), EXPECT_PRED_FORMAT3, testing::internal::UnitTestImpl::failed_test_case_count(), testing::internal::UnitTestImpl::failed_test_count(), testing::TestCase::failed_test_count(), folly::pushmi::operators::filter, testing::internal::UnitTestOptions::FilterMatchesTest(), g_argvs, testing::internal::FilePath::GenerateUniqueFileName(), testing::internal::scoped_ptr< T >::get(), testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(), GetArgvs(), GetCurrentExecutableName(), testing::internal::UnitTestImpl::GetGlobalTestPartResultReporter(), testing::UnitTest::GetInstance(), testing::internal::UnitTestOptions::GetOutputFormat(), testing::Message::GetString(), testing::TestPartResultArray::GetTestPartResult(), testing::internal::UnitTestImpl::GetTestPartResultReporterForCurrentThread(), GetTestTypeId(), GetTimeInMillis(), GetUnitTestImpl(), GTEST_API_, GTEST_DEFINE_STATIC_MUTEX_(), GTEST_DISABLE_MSC_WARNINGS_POP_, GTEST_DISABLE_MSC_WARNINGS_PUSH_, GTEST_FLAG, GTEST_HAS_GETTIMEOFDAY_, HasOneFailure(), i, ids_, testing::UnitTest::impl(), testing::ScopedFakeTestPartResultReporter::Init(), testing::internal::FilePath::IsAbsolutePath(), testing::internal::FilePath::IsDirectory(), testing::internal::edit_distance::kAdd, testing::TestPartResult::kFatalFailure, testing::internal::edit_distance::kMatch, testing::internal::edit_distance::kRemove, testing::internal::edit_distance::kReplace, kTestTypeIdInGoogleTest, testing::kUniversalFilter, folly::detail::lock(), testing::internal::UnitTestOptions::MatchesFilter(), testing::TestPartResult::message(), testing::Message::Message(), message, testing::AssertionResult::message_, move(), name, now(), testing::AssertionResult::operator!(), testing::Message::operator<<(), testing::internal::AssertHelper::operator=(), gmock_output_test::output, testing::internal::UnitTestOptions::PatternMatchesString(), testing::internal::FilePath::RemoveDirectoryName(), replace(), testing::internal::UnitTestImpl::reportable_disabled_test_count(), testing::TestCase::reportable_disabled_test_count(), testing::internal::UnitTestImpl::reportable_test_count(), testing::TestCase::reportable_test_count(), testing::ScopedFakeTestPartResultReporter::ReportTestPartResult(), testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(), testing::internal::DefaultPerThreadTestPartResultReporter::ReportTestPartResult(), folly::detail::rhs, testing::ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(), testing::internal::FilePath::Set(), testing::internal::UnitTestImpl::SetGlobalTestPartResultReporter(), testing::internal::UnitTestImpl::SetTestPartResultReporterForCurrentThread(), testing::TestCase::should_run(), ShouldRunTestCase(), testing::internal::String::ShowWideCString(), testing::internal::SingleFailureChecker::SingleFailureChecker(), testing::TestPartResultArray::size(), SplitString(), testing::internal::FilePath::string(), string, StringStreamToString(), testing::AssertionResult::success_, testing::internal::UnitTestImpl::successful_test_case_count(), testing::internal::UnitTestImpl::successful_test_count(), testing::TestCase::successful_test_count(), SumOverTestCaseList(), testing::AssertionResult::swap(), folly::f14::swap(), testing::internal::UnitTestImpl::test_case_to_run_count(), testing::internal::UnitTestImpl::test_to_run_count(), testing::TestCase::test_to_run_count(), TestCaseFailed(), TestCasePassed(), testing::internal::UnitTestImpl::total_test_case_count(), testing::internal::UnitTestImpl::total_test_count(), testing::TestCase::total_test_count(), testing::TestPartResult::type(), type, type_, testing::internal::AssertHelper::~AssertHelper(), testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter(), and testing::internal::SingleFailureChecker::~SingleFailureChecker().

                                                         {
  return test_case->should_run();
}

static bool testing::internal::ShouldRunTestCase ( const TestCase *  test_case )

static

Definition at line 356 of file gtest.cc.

References testing::TestCase::should_run().

Referenced by ShouldRunTestCase(), and testing::internal::UnitTestImpl::test_case_to_run_count().

                                                         {
  return test_case->should_run();
}

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

Definition at line 4778 of file gtest.cc.

Referenced by testing::internal::UnitTestImpl::FilterTests(), TearDownEnvironment(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                                          {
  return (test_id % total_shards) == shard_index;
}

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

Definition at line 4715 of file gtest.cc.

References COLOR_RED, ColoredPrintf(), testing::Message::GetString(), and Int32FromEnvOrDie().

Referenced by testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(), testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd(), testing::internal::UnitTestImpl::RunAllTests(), TearDownEnvironment(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                    {
  if (in_subprocess_for_death_test) {
    return false;
  }

  const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1);
  const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1);

  if (total_shards == -1 && shard_index == -1) {
    return false;
  } else if (total_shards == -1 && shard_index != -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestShardIndex << " = " << shard_index
      << ", but have left " << kTestTotalShards << " unset.\n";
    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (total_shards != -1 && shard_index == -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestTotalShards << " = " << total_shards
      << ", but have left " << kTestShardIndex << " unset.\n";
    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (shard_index < 0 || shard_index >= total_shards) {
    const Message msg = Message()
      << "Invalid environment variables: we require 0 <= "
      << kTestShardIndex << " < " << kTestTotalShards
      << ", but you have " << kTestShardIndex << "=" << shard_index
      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
    ColoredPrintf(COLOR_RED, msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  }

  return total_shards > 1;
}

bool testing::internal::ShouldUseColor

(

bool

stdout_is_tty

)

Definition at line 2916 of file gtest.cc.

References CaseInsensitiveCStringEquals(), testing::internal::posix::GetEnv(), and GTEST_FLAG.

Referenced by ColoredPrintf(), main(), TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                        {
  const char* const gtest_color = GTEST_FLAG(color).c_str();

  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS
    // On Windows the TERM variable is usually not set, but the
    // console there does support colors.
    return stdout_is_tty;
#else
    // On non-Windows platforms, we rely on the TERM variable.
    const char* const term = posix::GetEnv("TERM");
    const bool term_supports_color =
        String::CStringEquals(term, "xterm") ||
        String::CStringEquals(term, "xterm-color") ||
        String::CStringEquals(term, "xterm-256color") ||
        String::CStringEquals(term, "screen") ||
        String::CStringEquals(term, "screen-256color") ||
        String::CStringEquals(term, "tmux") ||
        String::CStringEquals(term, "tmux-256color") ||
        String::CStringEquals(term, "rxvt-unicode") ||
        String::CStringEquals(term, "rxvt-unicode-256color") ||
        String::CStringEquals(term, "linux") ||
        String::CStringEquals(term, "cygwin");
    return stdout_is_tty && term_supports_color;
#endif  // GTEST_OS_WINDOWS
  }

  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
      String::CStringEquals(gtest_color, "1");
  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
  // value is neither one of these nor "auto", we treat it as "no" to
  // be conservative.
}

template<typename E >

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

inline

Definition at line 333 of file gtest-internal-inl.h.

References ShuffleRange().

Referenced by operator<<(), testing::TestCase::ShuffleTests(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                             {
  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
}

template<typename E >

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

Definition at line 312 of file gtest-internal-inl.h.

References testing::internal::Random::Generate(), GTEST_CHECK_, folly::size(), and folly::f14::swap().

Referenced by operator<<(), PrintOnOneLine(), Shuffle(), testing::internal::UnitTestImpl::ShuffleTests(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                   {
  const int size = static_cast<int>(v->size());
  GTEST_CHECK_(0 <= begin && begin <= size)
      << "Invalid shuffle range start " << begin << ": must be in range [0, "
      << size << "].";
  GTEST_CHECK_(begin <= end && end <= size)
      << "Invalid shuffle range finish " << end << ": must be in range ["
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected = begin + random->Generate(range_width);
    std::swap((*v)[selected], (*v)[last_in_range]);
  }
}

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

Definition at line 5001 of file gtest.cc.

Referenced by testing::internal::CodeLocation::CodeLocation(), HasGoogleTestFlagPrefix(), PrintOnOneLine(), TEST(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                       {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

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

Definition at line 922 of file gtest.cc.

References AlwaysTrue().

Referenced by testing::internal::CodeLocation::CodeLocation(), ParseGoogleTestFlag(), and ShouldRunTestCase().

                                              {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

template<typename T >

std::string testing::internal::StreamableToString

(

const T &

streamable

)

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

Referenced by testing::internal::CodeLocation::CodeLocation(), FormatCompilerIndependentFileLocation(), testing::FormatCountableNoun(), FormatEpochTimeInMillisAsIso8601(), FormatFileLocation(), InitGoogleMockImpl(), InitGoogleTestImpl(), IsPathSeparator(), testing::internal::FilePath::MakeFileName(), testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(), testing::internal::PrettyUnitTestResultPrinter::OnTestProgramEnd(), testing::Message::operator<<(), testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(), ParseGoogleMockStringFlag(), ParseGoogleTestFlagsOnlyImpl(), PortableLocaltime(), testing::TEST(), testing::internal::TestResultAccessor::test_part_results(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

                                                  {
  return (Message() << streamable).GetString();
}

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

Definition at line 1229 of file gtest-port.cc.

References FlagToEnvVar(), testing::internal::posix::GetEnv(), string, and value.

Referenced by FlagToEnvVar(), and testing::GetDefaultFilter().

                                                                          {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* value = posix::GetEnv(env_var.c_str());
  if (value != NULL) {
    return value;
  }

  // As a special case for the 'output' flag, if GTEST_OUTPUT is not
  // set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
  // system.  The value of XML_OUTPUT_FILE is a filename without the
  // "xml:" prefix of GTEST_OUTPUT.
  //
  // The net priority order after flag processing is thus:
  //   --gtest_output command line flag
  //   GTEST_OUTPUT environment variable
  //   XML_OUTPUT_FILE environment variable
  //   'default_value'
  if (strcmp(flag, "output") == 0) {
    value = posix::GetEnv("XML_OUTPUT_FILE");
    if (value != NULL) {
      return std::string("xml:") + value;
    }
  }
  return default_value;
}

std::string testing::internal::StringStreamToString

(

::std::stringstream *

stream

)

Definition at line 1982 of file gtest.cc.

References ch, folly::test::end(), start, and string.

Referenced by CmpHelperFloatingPointEQ(), testing::internal::XmlUnitTestResultPrinter::EscapeXmlText(), FloatingPointLE(), testing::Message::GetString(), testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(), ShouldRunTestCase(), and WideStringToUtf8().

                                                    {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(2 * (end - start));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

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

inline

Definition at line 2284 of file gtest-port.h.

References IsSpace().

Referenced by testing::internal::CodeLocation::CodeLocation().

                                                    {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

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

static

Definition at line 335 of file gtest.cc.

References i, and sum().

                                                              {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

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

static

Definition at line 335 of file gtest.cc.

References i, and sum().

Referenced by testing::internal::UnitTestImpl::disabled_test_count(), testing::internal::UnitTestImpl::failed_test_count(), testing::internal::UnitTestImpl::reportable_disabled_test_count(), testing::internal::UnitTestImpl::reportable_test_count(), ShouldRunTestCase(), testing::internal::UnitTestImpl::successful_test_count(), testing::internal::UnitTestImpl::test_to_run_count(), and testing::internal::UnitTestImpl::total_test_count().

                                                              {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

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

static

Definition at line 335 of file gtest.cc.

References i, and sum().

                                                              {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

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

static

Definition at line 4540 of file gtest.cc.

References COLOR_RED, ColoredPrintf(), failed, FILE, testing::internal::UnitTestOptions::FilterMatchesTest(), testing::internal::UnitTestImpl::FilterTests(), testing::internal::posix::FOpen(), for_each(), ForEach(), forever, g_help_flag, testing::internal::posix::GetEnv(), GetNextRandomSeed(), GetRandomSeedFromFlag(), testing::Message::GetString(), GetTimeInMillis(), GTEST_FLAG, GTestIsInitialized(), testing::Test::HasFatalFailure(), i, Int32FromEnvOrDie(), testing::TestInfo::is_disabled_, testing::TestInfo::matches_filter_, testing::internal::UnitTestOptions::MatchesFilter(), testing::TestInfo::name(), testing::TestCase::name(), testing::TestEventListener::OnEnvironmentsSetUpEnd(), testing::TestEventListener::OnEnvironmentsSetUpStart(), testing::TestEventListener::OnEnvironmentsTearDownEnd(), testing::TestEventListener::OnEnvironmentsTearDownStart(), testing::TestEventListener::OnTestIterationEnd(), testing::TestEventListener::OnTestIterationStart(), testing::TestEventListener::OnTestProgramEnd(), testing::TestEventListener::OnTestProgramStart(), ParseInt32(), random(), repeat(), testing::internal::UnitTestImpl::RunAllTests(), testing::TestCase::set_should_run(), SetUpEnvironment(), testing::TestCase::should_run(), testing::TestInfo::should_run_, ShouldRunTestOnShard(), ShouldShard(), start, string, testing::Environment::TearDown(), TearDownEnvironment(), testing::TestCase::test_info_list(), and WriteToShardStatusFileIfNeeded().

{ env->TearDown(); }

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

static

Definition at line 4540 of file gtest.cc.

References COLOR_RED, ColoredPrintf(), failed, FILE, testing::internal::UnitTestOptions::FilterMatchesTest(), testing::internal::UnitTestImpl::FilterTests(), testing::internal::posix::FOpen(), for_each(), ForEach(), forever, g_help_flag, testing::internal::posix::GetEnv(), GetNextRandomSeed(), GetRandomSeedFromFlag(), testing::Message::GetString(), GetTimeInMillis(), GTEST_FLAG, GTestIsInitialized(), testing::Test::HasFatalFailure(), i, Int32FromEnvOrDie(), testing::TestInfo::is_disabled_, testing::TestInfo::matches_filter_, testing::internal::UnitTestOptions::MatchesFilter(), testing::TestInfo::name(), testing::TestCase::name(), testing::TestEventListener::OnEnvironmentsSetUpEnd(), testing::TestEventListener::OnEnvironmentsSetUpStart(), testing::TestEventListener::OnEnvironmentsTearDownEnd(), testing::TestEventListener::OnEnvironmentsTearDownStart(), testing::TestEventListener::OnTestIterationEnd(), testing::TestEventListener::OnTestIterationStart(), testing::TestEventListener::OnTestProgramEnd(), testing::TestEventListener::OnTestProgramStart(), ParseInt32(), random(), repeat(), testing::internal::UnitTestImpl::RunAllTests(), testing::TestCase::set_should_run(), SetUpEnvironment(), testing::TestCase::should_run(), testing::TestInfo::should_run_, ShouldRunTestOnShard(), ShouldShard(), start, string, testing::Environment::TearDown(), TearDownEnvironment(), testing::TestCase::test_info_list(), and WriteToShardStatusFileIfNeeded().

{ env->TearDown(); }

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

static

Definition at line 4540 of file gtest.cc.

References testing::Environment::TearDown().

Referenced by testing::internal::UnitTestImpl::RunAllTests(), and TearDownEnvironment().

{ env->TearDown(); }

std::string testing::internal::TempDir

(

)

Definition at line 1058 of file gtest-port.cc.

References testing::internal::posix::GetEnv(), and string.

Referenced by CheckedDowncastToActualType(), and testing::TEST_F().

                    {
#if GTEST_OS_WINDOWS_MOBILE
  return "\\temp\\";
#elif GTEST_OS_WINDOWS
  const char* temp_dir = posix::GetEnv("TEMP");
  if (temp_dir == NULL || temp_dir[0] == '\0')
    return "\\temp\\";
  else if (temp_dir[strlen(temp_dir) - 1] == '\\')
    return temp_dir;
  else
    return std::string(temp_dir) + "\\";
#elif GTEST_OS_LINUX_ANDROID
  return "/sdcard/";
#else
  return "/tmp/";
#endif  // GTEST_OS_WINDOWS_MOBILE
}

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

Definition at line 64 of file gtest-port_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and IsXDigit().

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::AStruct::AStruct(), testing::gmock_matchers_test::ConvertibleFromAny::ConvertibleFromAny(), testing::internal::Derived::Derived(), testing::gmock_matchers_test::Derived::Derived(), testing::gmock_matchers_test::ReferencesBarOrIsZeroImpl::DescribeNegationTo(), testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), testing::gmock_matchers_test::EvenMatcherImpl::DescribeTo(), testing::gmock_matchers_test::NewEvenMatcherImpl::DescribeTo(), testing::gmock_matchers_test::DivisibleByImpl::divider(), testing::internal::UnitTestHelper::GetSortedTests(), testing::gmock_matchers_test::IntReferenceWrapper::IntReferenceWrapper(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::DerivedClass::k(), testing::gmock_matchers_test::GreaterThanMatcher::MatchAndExplain(), testing::gmock_matchers_test::PolymorphicIsEvenImpl::MatchAndExplain(), testing::gmock_matchers_test::MATCHER_P(), testing::internal::NoDefaultContructor::NoDefaultContructor(), testing::internal::Castable::operator Base(), testing::internal::ConstCastable::operator Base(), testing::internal::ConstAndNonConstCastable::operator Base(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::IsGreaterThan::operator()(), testing::gmock_matchers_test::Functor::operator()(), testing::gmock_matchers_test::PolymorphicFunctor::operator()(), testing::gmock_matchers_test::ReferencingFunctor::operator()(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), operator<<(), testing::gmock_matchers_test::NotCopyable::operator>=(), testing::internal::ExpectationTester::SetCallCount(), testing::CurrentTestInfoTest::TearDownTestCase(), TEST(), testing::gmock_matchers_test::TEST(), testing::TEST(), TEST(), testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches(), testing::internal::To::To(), testing::gmock_matchers_test::Unprintable::Unprintable(), and testing::gmock_matchers_test::IntValue::value().

                                        {
  EXPECT_TRUE(IsXDigit('0'));
  EXPECT_TRUE(IsXDigit('9'));
  EXPECT_TRUE(IsXDigit('A'));
  EXPECT_TRUE(IsXDigit('F'));
  EXPECT_TRUE(IsXDigit('a'));
  EXPECT_TRUE(IsXDigit('f'));

  EXPECT_FALSE(IsXDigit('-'));
  EXPECT_FALSE(IsXDigit('g'));
  EXPECT_FALSE(IsXDigit('G'));
}

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

Definition at line 77 of file gtest-port_test.cc.

References EXPECT_FALSE, and IsXDigit().

                                                  {
  EXPECT_FALSE(IsXDigit('\x80'));
  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
}

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

Definition at line 82 of file gtest-port_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and IsXDigit().

                                      {
  EXPECT_TRUE(IsXDigit(L'0'));
  EXPECT_TRUE(IsXDigit(L'9'));
  EXPECT_TRUE(IsXDigit(L'A'));
  EXPECT_TRUE(IsXDigit(L'F'));
  EXPECT_TRUE(IsXDigit(L'a'));
  EXPECT_TRUE(IsXDigit(L'f'));

  EXPECT_FALSE(IsXDigit(L'-'));
  EXPECT_FALSE(IsXDigit(L'g'));
  EXPECT_FALSE(IsXDigit(L'G'));
}

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

Definition at line 95 of file gtest-port_test.cc.

References EXPECT_FALSE, and IsXDigit().

                                                {
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
}

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

Definition at line 114 of file gtest-unittest-api_test.cc.

References ASSERT_EQ, testing::UnitTest::disabled_test_count(), EXPECT_EQ, EXPECT_STREQ, testing::UnitTest::GetInstance(), testing::internal::UnitTestHelper::GetSortedTestCases(), name, testing::UnitTest::test_case_to_run_count(), testing::UnitTest::test_to_run_count(), testing::UnitTest::total_test_case_count(), and testing::UnitTest::total_test_count().

                                              {
  UnitTest* unit_test = UnitTest::GetInstance();

  ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
  EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
  EXPECT_EQ(2, unit_test->disabled_test_count());
  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());

  const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

  EXPECT_STREQ("ApiTest", test_cases[0]->name());
  EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
#if GTEST_HAS_TYPED_TEST
  EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
#endif  // GTEST_HAS_TYPED_TEST

  delete[] test_cases;

  // The following lines initiate actions to verify certain methods in
  // FinalSuccessChecker::TearDown.

  // Records a test property to verify TestResult::GetTestProperty().
  RecordProperty("key", "value");
}

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

Definition at line 119 of file gtest-port_test.cc.

References EXPECT_TRUE.

                                         {
  Derived derived(0);
  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
}

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

Definition at line 124 of file gtest-port_test.cc.

References EXPECT_EQ.

                                          {
  Derived derived(1);
  Base base = ::testing::internal::ImplicitCast_<Base>(derived);
  EXPECT_EQ(derived.member(), base.member());
}

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

Definition at line 142 of file gtest-port_test.cc.

References EXPECT_TRUE.

                                                   {
  bool converted = false;
  Castable castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
  EXPECT_TRUE(converted);
}

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

Definition at line 147 of file gtest-unittest-api_test.cc.

References ASSERT_EQ, ASSERT_TRUE, testing::TestCase::disabled_test_count(), EXPECT_EQ, EXPECT_FALSE, EXPECT_STREQ, EXPECT_TRUE, testing::internal::UnitTestHelper::FindTestCase(), testing::internal::UnitTestHelper::GetSortedTests(), IsNull(), name, testing::TestCase::name(), testing::TestCase::should_run(), testing::TestCase::test_to_run_count(), testing::TestCase::total_test_count(), and testing::TestCase::type_param().

                                              {
  const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
  ASSERT_TRUE(test_case != NULL);

  EXPECT_STREQ("ApiTest", test_case->name());
  EXPECT_TRUE(IsNull(test_case->type_param()));
  EXPECT_TRUE(test_case->should_run());
  EXPECT_EQ(1, test_case->disabled_test_count());
  EXPECT_EQ(3, test_case->test_to_run_count());
  ASSERT_EQ(4, test_case->total_test_count());

  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);

  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
  EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
  EXPECT_TRUE(IsNull(tests[0]->value_param()));
  EXPECT_TRUE(IsNull(tests[0]->type_param()));
  EXPECT_FALSE(tests[0]->should_run());

  EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
  EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
  EXPECT_TRUE(IsNull(tests[1]->value_param()));
  EXPECT_TRUE(IsNull(tests[1]->type_param()));
  EXPECT_TRUE(tests[1]->should_run());

  EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
  EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
  EXPECT_TRUE(IsNull(tests[2]->value_param()));
  EXPECT_TRUE(IsNull(tests[2]->type_param()));
  EXPECT_TRUE(tests[2]->should_run());

  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
  EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
  EXPECT_TRUE(IsNull(tests[3]->value_param()));
  EXPECT_TRUE(IsNull(tests[3]->type_param()));
  EXPECT_TRUE(tests[3]->should_run());

  delete[] tests;
  tests = NULL;

#if GTEST_HAS_TYPED_TEST
  test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
  ASSERT_TRUE(test_case != NULL);

  EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
  EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
  EXPECT_TRUE(test_case->should_run());
  EXPECT_EQ(0, test_case->disabled_test_count());
  EXPECT_EQ(1, test_case->test_to_run_count());
  ASSERT_EQ(1, test_case->total_test_count());

  tests = UnitTestHelper::GetSortedTests(test_case);

  EXPECT_STREQ("Dummy", tests[0]->name());
  EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
  EXPECT_TRUE(IsNull(tests[0]->value_param()));
  EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
  EXPECT_TRUE(tests[0]->should_run());

  delete[] tests;
#endif  // GTEST_HAS_TYPED_TEST
}

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

Definition at line 161 of file gtest-port_test.cc.

References EXPECT_TRUE.

                                                             {
  bool converted = false;
  const ConstCastable const_castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
  EXPECT_TRUE(converted);
}

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

Definition at line 186 of file gtest-port_test.cc.

References EXPECT_FALSE, and EXPECT_TRUE.

                                                                          {
  bool converted = false;
  bool const_converted = false;
  ConstAndNonConstCastable castable(&converted, &const_converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
  EXPECT_TRUE(converted);
  EXPECT_FALSE(const_converted);

  converted = false;
  const_converted = false;
  const ConstAndNonConstCastable const_castable(&converted, &const_converted);
  base = ::testing::internal::ImplicitCast_<Base>(const_castable);
  EXPECT_FALSE(converted);
  EXPECT_TRUE(const_converted);
}

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

Definition at line 207 of file gtest-port_test.cc.

References EXPECT_TRUE, and folly::to().

                                                  {
  bool converted = false;
  To to = ::testing::internal::ImplicitCast_<To>(&converted);
  (void)to;
  EXPECT_TRUE(converted);
}

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

Definition at line 210 of file gtest-unittest-api_test.cc.

References ASSERT_EQ, ASSERT_TRUE, testing::TestCase::disabled_test_count(), EXPECT_EQ, EXPECT_FALSE, EXPECT_STREQ, EXPECT_TRUE, testing::internal::UnitTestHelper::FindTestCase(), testing::TestCase::GetTestInfo(), IsNull(), testing::TestCase::name(), testing::TestCase::should_run(), testing::TestCase::test_to_run_count(), testing::TestCase::total_test_count(), and testing::TestCase::type_param().

                                             {
  const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
  ASSERT_TRUE(test_case != NULL);

  EXPECT_STREQ("DISABLED_Test", test_case->name());
  EXPECT_TRUE(IsNull(test_case->type_param()));
  EXPECT_FALSE(test_case->should_run());
  EXPECT_EQ(1, test_case->disabled_test_count());
  EXPECT_EQ(0, test_case->test_to_run_count());
  ASSERT_EQ(1, test_case->total_test_count());

  const TestInfo* const test_info = test_case->GetTestInfo(0);
  EXPECT_STREQ("Dummy2", test_info->name());
  EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
  EXPECT_TRUE(IsNull(test_info->value_param()));
  EXPECT_TRUE(IsNull(test_info->type_param()));
  EXPECT_FALSE(test_info->should_run());
}

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForSTLContainerIterators
	)

Definition at line 214 of file gtest-port_test.cc.

References testing::StaticAssertTypeEq().

                                                        {
  StaticAssertTypeEq<int,
      IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();
  StaticAssertTypeEq<bool,
      IteratorTraits< ::std::list<bool>::iterator>::value_type>();
}

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForPointerToNonConst
	)

Definition at line 221 of file gtest-port_test.cc.

                                                    {
  StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();
  StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();
}

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForPointerToConst
	)

Definition at line 226 of file gtest-port_test.cc.

References testing::StaticAssertTypeEq().

                                                 {
  StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();
  StaticAssertTypeEq<const void*,
      IteratorTraits<const void* const*>::value_type>();
}

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

Definition at line 231 of file gtest-unittest-api_test.cc.

{}

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

Definition at line 232 of file gtest-unittest-api_test.cc.

{}

testing::internal::TEST	(	ScopedPtrTest	,
		DefinesElementType
	)

Definition at line 234 of file gtest-port_test.cc.

                                        {
  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
}

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

Definition at line 240 of file gtest-port_test.cc.

References AlwaysFalse(), AlwaysTrue(), and GTEST_CHECK_.

                                                        {
  if (AlwaysFalse())
    GTEST_CHECK_(false) << "This should never be executed; "
                           "It's a compilation test only.";

  if (AlwaysTrue())
    GTEST_CHECK_(true);
  else
    ;  // NOLINT

  if (AlwaysFalse())
    ;  // NOLINT
  else
    GTEST_CHECK_(true) << "";
}

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

Definition at line 256 of file gtest-port_test.cc.

References GTEST_CHECK_.

                                            {
  switch (0) {
    case 1:
      break;
    default:
      GTEST_CHECK_(true);
  }

  switch (0)
    case 0:
      GTEST_CHECK_(true) << "Check failed in switch case";
}

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

Definition at line 270 of file gtest-port_test.cc.

References EXPECT_PRED_FORMAT2, FormatFileLocation(), and testing::IsSubstring().

                                                  {
  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
}

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

Definition at line 275 of file gtest-port_test.cc.

References EXPECT_PRED_FORMAT2, FormatFileLocation(), and testing::IsSubstring().

                                                 {
  EXPECT_PRED_FORMAT2(
      IsSubstring, "unknown file", FormatFileLocation(NULL, 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));
}

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

Definition at line 281 of file gtest-port_test.cc.

References EXPECT_EQ, and FormatFileLocation().

                                                {
  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
}

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

Definition at line 285 of file gtest-port_test.cc.

References EXPECT_EQ, and FormatFileLocation().

                                                       {
  EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));
}

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

Definition at line 290 of file gtest-port_test.cc.

References EXPECT_EQ, and FormatCompilerIndependentFileLocation().

                                                                     {
  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
}

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

Definition at line 294 of file gtest-port_test.cc.

References EXPECT_EQ, and FormatCompilerIndependentFileLocation().

                                                                   {
  EXPECT_EQ("unknown file:42",
            FormatCompilerIndependentFileLocation(NULL, 42));
}

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

Definition at line 299 of file gtest-port_test.cc.

References EXPECT_EQ, and FormatCompilerIndependentFileLocation().

                                                                   {
  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
}

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

Definition at line 303 of file gtest-port_test.cc.

References ASSERT_EQ, data, dummy(), EXPECT_EQ, FormatCompilerIndependentFileLocation(), GetThreadCount(), i, folly::detail::lock(), testing::internal::Mutex::Lock(), mutex, TEST(), and testing::internal::Mutex::Unlock().

                                                                          {
  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));
}

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

Definition at line 348 of file gtest-port_test.cc.

References EXPECT_EQ, and GetThreadCount().

                                                              {
  EXPECT_EQ(0U, GetThreadCount());
}

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

Definition at line 353 of file gtest-port_test.cc.

References EXPECT_DEATH_IF_SUPPORTED, GTEST_CHECK_, regex, and TEST().

                                                          {
  const bool a_false_condition = false;
  const char regex[] =
#ifdef _MSC_VER
     "gtest-port_test\\.cc\\(\\d+\\):"
#elif GTEST_USES_POSIX_RE
     "gtest-port_test\\.cc:[0-9]+"
#else
     "gtest-port_test\\.cc:\\d+"
#endif  // _MSC_VER
     ".*a_false_condition.*Extra info.*";

  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
                            regex);
}

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

Definition at line 384 of file gtest-port_test.cc.

References ASSERT_FALSE, folly::empty(), EXPECT_FALSE, EXPECT_NONFATAL_FAILURE, EXPECT_PRED1, EXPECT_STREQ, EXPECT_TRUE, testing::internal::RE::FullMatch(), GTEST_USES_POSIX_RE, testing::internal::RE::PartialMatch(), testing::internal::RE::pattern(), simple, string, TEST(), testing::TYPED_TEST(), and testing::TYPED_TEST_CASE().

                                                          {
#if !GTEST_USES_PCRE
# if GTEST_HAS_POSIX_RE

  EXPECT_TRUE(GTEST_USES_POSIX_RE);

# else

  EXPECT_TRUE(GTEST_USES_SIMPLE_RE);

# endif
#endif  // !GTEST_USES_PCRE
}

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

Definition at line 932 of file gtest-port_test.cc.

References CaptureStdout(), EXPECT_EQ, EXPECT_STREQ, GetCapturedStdout(), and string.

                                  {
  CaptureStdout();
  fprintf(stdout, "abc");
  EXPECT_STREQ("abc", GetCapturedStdout().c_str());

  CaptureStdout();
  fprintf(stdout, "def%cghi", '\0');
  EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
}

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

Definition at line 942 of file gtest-port_test.cc.

References CaptureStderr(), EXPECT_EQ, EXPECT_STREQ, GetCapturedStderr(), and string.

                                  {
  CaptureStderr();
  fprintf(stderr, "jkl");
  EXPECT_STREQ("jkl", GetCapturedStderr().c_str());

  CaptureStderr();
  fprintf(stderr, "jkl%cmno", '\0');
  EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
}

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

Definition at line 953 of file gtest-port_test.cc.

References CaptureStderr(), CaptureStdout(), EXPECT_STREQ, GetCapturedStderr(), and GetCapturedStdout().

                                           {
  CaptureStdout();
  CaptureStderr();
  fprintf(stdout, "pqr");
  fprintf(stderr, "stu");
  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
}

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

Definition at line 962 of file gtest-port_test.cc.

References CaptureStdout(), EXPECT_DEATH_IF_SUPPORTED, and GetCapturedStdout().

                                                   {
  CaptureStdout();
  EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(),
                            "Only one stdout capturer can exist at a time");
  GetCapturedStdout();

  // We cannot test stderr capturing using death tests as they use it
  // themselves.
}

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

Definition at line 974 of file gtest-port_test.cc.

References EXPECT_EQ, EXPECT_TRUE, and testing::internal::ThreadLocal< T >::get().

                                                                    {
  ThreadLocal<int> t1;
  EXPECT_EQ(0, t1.get());

  ThreadLocal<void*> t2;
  EXPECT_TRUE(t2.get() == NULL);
}

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

Definition at line 982 of file gtest-port_test.cc.

References EXPECT_EQ, testing::internal::ThreadLocal< T >::get(), and i.

                                                                {
  ThreadLocal<int> t1(123);
  EXPECT_EQ(123, t1.get());

  int i = 0;
  ThreadLocal<int*> t2(&i);
  EXPECT_EQ(&i, t2.get());
}

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

Definition at line 997 of file gtest-port_test.cc.

References bar, and testing::internal::ThreadLocal< T >::pointer().

                                                                          {
  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
  bar.pointer();
}

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

Definition at line 1002 of file gtest-port_test.cc.

References EXPECT_EQ, testing::internal::ThreadLocal< T >::get(), testing::internal::ThreadLocal< T >::pointer(), and testing::internal::ThreadLocal< T >::set().

                                                    {
  ThreadLocal<std::string> thread_local_string;

  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));

  // Verifies the condition still holds after calling set.
  thread_local_string.set("foo");
  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
}

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

Definition at line 1012 of file gtest-port_test.cc.

References ASSERT_EQ, ASSERT_FALSE, testing::internal::Mutex::AssertHeld(), dummy(), EXPECT_DEATH_IF_SUPPORTED, EXPECT_EQ, EXPECT_STREQ, EXPECT_TRUE, FALSE, testing::internal::ThreadLocal< T >::get(), GTEST_CHECK_, GTEST_CHECK_POSIX_SUCCESS_, GTEST_DISALLOW_ASSIGN_, GTEST_DISALLOW_COPY_AND_ASSIGN_, i, folly::detail::lock(), m, mutex, mutex_, testing::internal::ThreadLocal< T >::pointer(), testing::internal::scoped_ptr< T >::reset(), testing::internal::ThreadLocal< T >::set(), folly::size(), string, T, shell_builder::temp, TEST(), TRUE, and value.

                                                             {
  ThreadLocal<std::string> thread_local_string;
  const ThreadLocal<std::string>& const_thread_local_string =
      thread_local_string;

  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());

  thread_local_string.set("foo");
  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
}

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

Definition at line 158 of file gtest-listener_test.cc.

References SUCCEED.

Referenced by testing::gmock_matchers_test::EMString(), testing::TestInfoTest::GetTestResult(), operator<<(), testing::SetUpTestCaseTest::SetUp(), testing::internal::ListenerTest::TearDown(), testing::CurrentTestInfoTest::TearDownTestCase(), testing::TEST(), testing::TEST_F(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                              {
  // Test execution order within a test case is not guaranteed so we are not
  // recording the test name.
  g_events->push_back("ListenerTest::* Test Body");
  SUCCEED();  // Triggers OnTestPartResult.
}

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

Definition at line 165 of file gtest-listener_test.cc.

References SUCCEED.

                              {
  g_events->push_back("ListenerTest::* Test Body");
  SUCCEED();  // Triggers OnTestPartResult.
}

static bool testing::internal::TestCaseFailed ( const TestCase *  test_case )

static

Definition at line 350 of file gtest.cc.

References testing::TestCase::Failed(), and testing::TestCase::should_run().

Referenced by testing::internal::UnitTestImpl::failed_test_case_count(), and ShouldRunTestCase().

                                                      {
  return test_case->should_run() && test_case->Failed();
}

static bool testing::internal::TestCaseFailed ( const TestCase *  test_case )

static

Definition at line 350 of file gtest.cc.

References testing::TestCase::Failed(), and testing::TestCase::should_run().

                                                      {
  return test_case->should_run() && test_case->Failed();
}

static bool testing::internal::TestCaseFailed ( const TestCase *  test_case )

static

Definition at line 350 of file gtest.cc.

References testing::TestCase::Failed(), and testing::TestCase::should_run().

                                                      {
  return test_case->should_run() && test_case->Failed();
}

static bool testing::internal::TestCasePassed ( const TestCase *  test_case )

static

Definition at line 345 of file gtest.cc.

References testing::TestCase::Passed(), and testing::TestCase::should_run().

Referenced by ShouldRunTestCase(), and testing::internal::UnitTestImpl::successful_test_case_count().

                                                      {
  return test_case->should_run() && test_case->Passed();
}

static bool testing::internal::TestCasePassed ( const TestCase *  test_case )

static

Definition at line 345 of file gtest.cc.

References testing::TestCase::Passed(), and testing::TestCase::should_run().

                                                      {
  return test_case->should_run() && test_case->Passed();
}

static bool testing::internal::TestCasePassed ( const TestCase *  test_case )

static

Definition at line 345 of file gtest.cc.

References testing::TestCase::Passed(), and testing::TestCase::should_run().

                                                      {
  return test_case->should_run() && test_case->Passed();
}

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

inline

Definition at line 2277 of file gtest-port.h.

Referenced by ConvertIdentifierNameToWords().

                             {
  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
}

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

inline

Definition at line 2280 of file gtest-port.h.

Referenced by FlagToEnvVar().

                             {
  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
}

template<typename Tuple , typename Func , typename OutIter >

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

Definition at line 853 of file gmock-matchers.h.

References Run().

Referenced by testing::internal::UnorderedElementsAreMatcher< MatcherTuple >::operator Matcher< Container >(), testing::internal::ElementsAreMatcher< MatcherTuple >::operator Matcher< Container >(), and testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >::IterateOverTuple< Tup, 0 >::operator()().

                                                                  {
  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
}

template<typename MatcherTuple , typename ValueTuple >

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

Definition at line 796 of file gmock-matchers.h.

References GTEST_COMPILE_ASSERT_, testing::Matches(), and value.

Referenced by testing::internal::TuplePrefix< 0 >::ExplainMatchFailuresTo(), testing::internal::TypedExpectation< F >::ExplainMatchResultTo(), testing::internal::OnCallSpec< F >::Matches(), and testing::internal::TypedExpectation< F >::Matches().

                                                 {
  // Makes sure that matcher_tuple and value_tuple have the same
  // number of fields.
  GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
                        tuple_size<ValueTuple>::value,
                        matcher_and_value_have_different_numbers_of_fields);
  return TuplePrefix<tuple_size<ValueTuple>::value>::
      Matches(matcher_tuple, value_tuple);
}

template<typename T >

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

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

References testing::gtest_printers_test::Print(), and T.

Referenced by testing::SafeMatcherCastImpl< T >::Cast(), DefaultPrintTo(), testing::internal::ComparisonBase< D, Rhs, Op >::Impl< Lhs >::DescribeNegationTo(), testing::internal::HasSubstrMatcher< StringType >::DescribeNegationTo(), testing::internal::StartsWithMatcher< StringType >::DescribeNegationTo(), testing::internal::EndsWithMatcher< StringType >::DescribeNegationTo(), testing::internal::ContainerEqMatcher< Container >::DescribeNegationTo(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::DescribeNegationTo(), testing::internal::ComparisonBase< D, Rhs, Op >::Impl< Lhs >::DescribeTo(), testing::internal::HasSubstrMatcher< StringType >::DescribeTo(), testing::internal::StartsWithMatcher< StringType >::DescribeTo(), testing::internal::EndsWithMatcher< StringType >::DescribeTo(), testing::internal::ContainerEqMatcher< Container >::DescribeTo(), testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >::DescribeTo(), testing::internal::StrEqualityMatcher< StringType >::DescribeToHelper(), testing::internal::TuplePrefix< N >::ExplainMatchFailuresTo(), testing::internal::ContainerEqMatcher< Container >::MatchAndExplain(), testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >::Impl< LhsContainer >::MatchAndExplain(), testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >::MatchAndExplain(), MatchPrintAndExplain(), testing::internal::UniversalPrinter< T & >::Print(), testing::internal::UniversalTersePrinter< T >::Print(), testing::internal::UniversalTersePrinter< T & >::Print(), testing::internal::UniversalTersePrinter< const char * >::Print(), testing::internal::UniversalTersePrinter< char * >::Print(), testing::internal::UniversalTersePrinter< wchar_t * >::Print(), PrintRawArrayTo(), testing::gtest_printers_test::TEST(), testing::internal::FunctionMockerBase< R(A1, A2)>::UntypedDescribeUninterestingCall(), testing::internal::FunctionMockerBase< R(A1, A2)>::UntypedPrintArgs(), and foo::StreamableTemplateInFoo< T >::value().

                                                    {
  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
  // UniversalPrinter with T directly.
  typedef T T1;
  UniversalPrinter<T1>::Print(value, os);
}

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

Definition at line 309 of file gtest-printers.cc.

References UniversalPrintCharArray().

                                                                     {
  UniversalPrintCharArray(begin, len, os);
}

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

Definition at line 315 of file gtest-printers.cc.

References UniversalPrintCharArray().

Referenced by UniversalPrintCharArray().

                                                                        {
  UniversalPrintCharArray(begin, len, os);
}

template<typename T >

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

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

References folly::test::begin(), GTEST_API_, PrintRawArrayTo(), and UniversalPrintArray().

                                                                     {
  if (len == 0) {
    *os << "{}";
  } else {
    *os << "{ ";
    const size_t kThreshold = 18;
    const size_t kChunkSize = 8;
    // If the array has more than kThreshold elements, we'll have to
    // omit some details by printing only the first and the last
    // kChunkSize elements.
    // TODO(wan@google.com): let the user control the threshold using a flag.
    if (len <= kThreshold) {
      PrintRawArrayTo(begin, len, os);
    } else {
      PrintRawArrayTo(begin, kChunkSize, os);
      *os << ", ..., ";
      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
    }
    *os << " }";
  }
}

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

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

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

template<typename CharType >

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

static

Definition at line 286 of file gtest-printers.cc.

References folly::test::begin(), PrintCharsAsStringTo(), PrintStringTo(), PrintTo(), s, string, UniversalPrintArray(), and UniversalPrintCharArray().

                                                    {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

  // If, however, the last element in the array is not '\0', e.g.
  //    const char kFoo[] = { 'f', 'o', 'o' };
  // we must print the entire array.  We also print a message to indicate
  // that the array is not NUL-terminated.
  PrintCharsAsStringTo(begin, len, os);
  *os << " (no terminating NUL)";
}

template<typename CharType >

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

static

Definition at line 286 of file gtest-printers.cc.

References PrintCharsAsStringTo().

                                                    {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

  // If, however, the last element in the array is not '\0', e.g.
  //    const char kFoo[] = { 'f', 'o', 'o' };
  // we must print the entire array.  We also print a message to indicate
  // that the array is not NUL-terminated.
  PrintCharsAsStringTo(begin, len, os);
  *os << " (no terminating NUL)";
}

template<typename CharType >

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

static

Definition at line 286 of file gtest-printers.cc.

References folly::test::begin(), PrintCharsAsStringTo(), PrintStringTo(), PrintTo(), s, string, and UniversalPrintArray().

Referenced by UniversalPrintArray(), and UniversalPrintCharArray().

                                                    {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

  // If, however, the last element in the array is not '\0', e.g.
  //    const char kFoo[] = { 'f', 'o', 'o' };
  // we must print the entire array.  We also print a message to indicate
  // that the array is not NUL-terminated.
  PrintCharsAsStringTo(begin, len, os);
  *os << " (no terminating NUL)";
}

template<typename T >

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

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

References testing::gtest_printers_test::Print().

Referenced by testing::internal::UniversalTersePrinter< wchar_t * >::Print(), testing::gtest_printers_test::TEST(), and foo::StreamableTemplateInFoo< T >::value().

                                                         {
  UniversalTersePrinter<T>::Print(value, os);
}

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

Definition at line 1823 of file gtest.cc.

References CodePointToUtf8(), CreateCodePointFromUtf16SurrogatePair(), i, IsUtf16SurrogatePair(), stream, and StringStreamToString().

Referenced by operator<<(), testing::internal::String::ShowWideCString(), testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                                              {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    UInt32 unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<UInt32>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

void testing::internal::WriteToShardStatusFileIfNeeded

(

)

Definition at line 4693 of file gtest.cc.

References COLOR_RED, ColoredPrintf(), FILE, testing::internal::posix::FOpen(), and testing::internal::posix::GetEnv().

Referenced by testing::internal::UnitTestImpl::RunAllTests(), TearDownEnvironment(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

                                      {
  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
  if (test_shard_file != NULL) {
    FILE* const file = posix::FOpen(test_shard_file, "w");
    if (file == NULL) {
      ColoredPrintf(COLOR_RED,
                    "Could not write to the test shard status file \"%s\" "
                    "specified by the %s environment variable.\n",
                    test_shard_file, kTestShardStatusFile);
      fflush(stdout);
      exit(EXIT_FAILURE);
    }
    fclose(file);
  }
}

Variable Documentation

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

Definition at line 387 of file gtest.cc.

Referenced by GetArgvs(), InitGoogleTestImpl(), and ShouldRunTestCase().

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

Definition at line 243 of file gmock-spec-builders.cc.

Referenced by testing::InSequence::InSequence(), testing::Sequence::Sequence(), and testing::InSequence::~InSequence().

bool testing::internal::g_help_flag = false

Definition at line 188 of file gtest.cc.

Referenced by ParseGoogleTestFlag(), ParseGoogleTestFlagsOnlyImpl(), testing::internal::UnitTestImpl::RunAllTests(), TearDownEnvironment(), and testing::InitGoogleTestTest::TestParsingFlags().

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

Referenced by testing::Sequence::Sequence(), and testing::internal::GTestFlagSaver::~GTestFlagSaver().

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

Definition at line 89 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 90 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 91 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const char testing::internal::kColorEncodedHelpMessage[]

static

Definition at line 5159 of file gtest.cc.

const char testing::internal::kColorEncodedHelpMessage[]

static

Definition at line 5159 of file gtest.cc.

const char testing::internal::kColorEncodedHelpMessage[]

static

Definition at line 5159 of file gtest.cc.

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

Definition at line 92 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const char testing::internal::kCurrentDirectoryString = "./"

Definition at line 86 of file gtest-filepath.cc.

Referenced by IsPathSeparator(), and testing::internal::FilePath::RemoveFileName().

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

Definition at line 50 of file gtest-death-test-internal.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 51 of file gtest-death-test-internal.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 318 of file gmock-internal-utils.h.

Referenced by LogIsVisible(), testing::internal::GoogleTestFailureReporter::ReportFailure(), and testing::internal::ExpectationTester::SetCallCount().

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

Definition at line 93 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const char testing::internal::kFlagfileFlag = "flagfile"

Definition at line 103 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlagsOnlyImpl().

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

Definition at line 314 of file gmock-internal-utils.h.

Referenced by LogIsVisible(), testing::internal::GoogleTestFailureReporter::ReportFailure(), ReportUninterestingCall(), and testing::internal::ExpectationTester::SetCallCount().

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

Definition at line 52 of file gtest-death-test-internal.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 94 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const BiggestInt testing::internal::kMaxBiggestInt

Initial value:

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

Definition at line 2439 of file gtest-port.h.

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

Definition at line 1733 of file gtest.cc.

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

Definition at line 1736 of file gtest.cc.

const UInt32 testing::internal::kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1

Definition at line 1739 of file gtest.cc.

const UInt32 testing::internal::kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1

Definition at line 1742 of file gtest.cc.

const int testing::internal::kMaxRandomSeed = 99999

Definition at line 106 of file gtest-internal-inl.h.

Referenced by operator<<(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

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

Definition at line 95 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const char testing::internal::kPathSeparator = '/'

Definition at line 85 of file gtest-filepath.cc.

Referenced by IsPathSeparator(), and testing::internal::FilePath::Normalize().

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

Definition at line 96 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 97 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 98 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 99 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 100 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 184 of file gtest.cc.

Referenced by testing::UnitTest::AddTestPartResult(), testing::TestPartResult::ExtractSummary(), and testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile().

const int testing::internal::kStdErrFileno = STDERR_FILENO

Definition at line 89 of file gtest-port.cc.

const int testing::internal::kStdOutFileno = STDOUT_FILENO

Definition at line 88 of file gtest-port.cc.

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

Definition at line 101 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

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

Definition at line 626 of file gtest.cc.

Referenced by operator<<(), ShouldRunTestCase(), and testing::internal::UnitTestRecordPropertyTestHelper::UnitTestRecordProperty().

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

Definition at line 102 of file gtest-internal-inl.h.

Referenced by ParseGoogleTestFlag().

const int testing::internal::kTypedTestCases = 0

Definition at line 107 of file gtest-unittest-api_test.cc.

Referenced by testing::internal::UnitTestHelper::GetSortedTests().

const int testing::internal::kTypedTests = 0

Definition at line 108 of file gtest-unittest-api_test.cc.

Referenced by testing::internal::UnitTestHelper::GetSortedTests().

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

static

Definition at line 3006 of file gtest.cc.

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

static

Definition at line 3006 of file gtest.cc.

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

static

Definition at line 3006 of file gtest.cc.

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

Definition at line 876 of file gtest-port.cc.

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

static

Definition at line 3007 of file gtest.cc.

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

static

Definition at line 3007 of file gtest.cc.

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

static

Definition at line 3007 of file gtest.cc.

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

Definition at line 316 of file gmock-internal-utils.h.

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