testing::internal Namespace Reference

Namespaces
namespace	any_cast_matcher
namespace	edit_distance
namespace	invoke_argument
namespace	pair_getters
namespace	posix
namespace	variant_matcher

Classes
class	ActionAdaptor
class	ActionHelper
class	ActionResultHolder
class	ActionResultHolder< void >
struct	AddReference
struct	AddReference< T & >
class	AllOfMatcherImpl
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
class	AnyOfMatcherImpl
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	BoundSecondMatcher
class	BuiltInDefaultValue
class	BuiltInDefaultValue< const T >
class	BuiltInDefaultValue< T * >
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
struct	ConstRef
struct	ConstRef< T & >
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	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	FloatingEq2Matcher
class	FloatingEqMatcher
class	FloatingPoint
class	FormatForComparison
class	FormatForComparison< ToPrint[N], OtherOperand >
struct	Function
struct	Function< R(A1)>
struct	Function< R(A1, A2)>
struct	Function< R(A1, A2, A3)>
struct	Function< R(A1, A2, A3, A4)>
struct	Function< R(A1, A2, A3, A4, A5)>
struct	Function< R(A1, A2, A3, A4, A5, A6)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
class	FunctionMocker
class	FunctionMocker< R(A1)>
class	FunctionMocker< R(A1, A2)>
class	FunctionMocker< R(A1, A2, A3)>
class	FunctionMocker< R(A1, A2, A3, A4)>
class	FunctionMocker< R(A1, A2, A3, A4, A5)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
class	FunctionMockerBase
class	Ge2Matcher
class	GeMatcher
class	GoogleTestFailureReporter
class	Gt2Matcher
class	GTestFlagSaver
class	GTestLog
class	GTestMutexLock
class	GtMatcher
class	HasNewFatalFailureHelper
class	HasSubstrMatcher
struct	HasValueType
struct	HasValueType< T, VoidT< typename T::value_type > >
class	IgnoredValue
class	IgnoreResultAction
class	ImplicitlyConvertible
class	InvokeAction
class	InvokeCallbackAction
class	InvokeCallbackWithoutArgsAction
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	is_same
struct	is_same< T, T >
struct	IsAProtocolMessage
struct	IsHashTable
class	IsNullMatcher
struct	IsRecursiveContainer
struct	IsRecursiveContainerImpl
struct	IsRecursiveContainerImpl< C, false, HV >
struct	IsRecursiveContainerImpl< C, true, false >
struct	IsRecursiveContainerImpl< C, true, true >
struct	IsSame
struct	IsSame< T, T >
struct	IteratorTraits
struct	IteratorTraits< const T * >
struct	IteratorTraits< T * >
class	JsonUnitTestResultPrinter
class	KeyMatcher
class	KeyMatcherImpl
struct	KindOf
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 > >
class	MatcherInterfaceAdapter
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	OptionalMatcher
class	OsStackTraceGetter
class	OsStackTraceGetterInterface
class	PairMatchBase
class	PairMatcher
class	PairMatcherImpl
class	ParameterizedTestCaseInfo
class	ParameterizedTestCaseInfoBase
class	ParameterizedTestCaseRegistry
class	ParameterizedTestFactory
class	ParamGenerator
class	ParamGeneratorInterface
class	ParamIterator
class	ParamIteratorInterface
struct	ParamNameGenFunc
class	PointeeMatcher
struct	PointeeOf
struct	PointeeOf< T * >
class	PointwiseMatcher
class	PredicateFormatterFromMatcher
class	PrettyUnitTestResultPrinter
class	PropertyMatcher
class	QuantifierMatcherImpl
class	Random
class	RangeGenerator
struct	Rank0
struct	Rank1
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
struct	RvalueRef
class	scoped_ptr
class	ScopedPrematureExitFile
class	SelectArgs
class	SelectArgs< Result, ArgumentTuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9, -1 >
class	SetArgumentPointeeAction
class	SetArgumentPointeeAction< N, Proto, true >
class	SetErrnoAndReturnAction
class	SingleFailureChecker
class	SizeIsMatcher
class	StartsWithMatcher
struct	StaticAssertTypeEqHelper
struct	StaticAssertTypeEqHelper< T, T >
class	StlContainerView
class	StlContainerView< ::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	TestMetaFactory
class	TestMetaFactoryBase
class	TestPropertyKeyIs
class	TestResultAccessor
class	ThreadLocal
class	To
struct	TraceInfo
class	TransformTupleValuesHelper
class	TrulyMatcher
class	TupleFields
class	TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >
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
struct	UnorderedMatcherRequire
class	UntypedActionResultHolderBase
class	UntypedFunctionMockerBase
class	UntypedOnCallSpecBase
class	ValueArray1
class	ValueArray10
class	ValueArray11
class	ValueArray12
class	ValueArray13
class	ValueArray14
class	ValueArray15
class	ValueArray16
class	ValueArray17
class	ValueArray18
class	ValueArray19
class	ValueArray2
class	ValueArray20
class	ValueArray21
class	ValueArray22
class	ValueArray23
class	ValueArray24
class	ValueArray25
class	ValueArray26
class	ValueArray27
class	ValueArray28
class	ValueArray29
class	ValueArray3
class	ValueArray30
class	ValueArray31
class	ValueArray32
class	ValueArray33
class	ValueArray34
class	ValueArray35
class	ValueArray36
class	ValueArray37
class	ValueArray38
class	ValueArray39
class	ValueArray4
class	ValueArray40
class	ValueArray41
class	ValueArray42
class	ValueArray43
class	ValueArray44
class	ValueArray45
class	ValueArray46
class	ValueArray47
class	ValueArray48
class	ValueArray49
class	ValueArray5
class	ValueArray50
class	ValueArray6
class	ValueArray7
class	ValueArray8
class	ValueArray9
class	ValuesInIteratorRangeGenerator
struct	VoidT
class	WhenSortedByMatcher
class	WithArgsAction
class	WithoutMatchers
struct	WrapPrinterType
class	XmlUnitTestResultPrinter

Typedefs
typedef ::std::pair< size_t, size_t >	ElementMatcherPair
typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs
typedef ::std::vector< ::std::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 }
enum	TypeKind { kBool , kInteger , kFloatingPoint , kOther }
enum	LogSeverity { kInfo = 0 , kWarning = 1 }
enum	DefaultPrinterType { kPrintContainer , kPrintPointer , kPrintFunctionPointer , kPrintOther }
enum	GTestLogSeverity { GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL }
enum	CharFormat { kAsIs , kHexEscape , kSpecialEscape }
enum	GTestColor { COLOR_DEFAULT , COLOR_RED , COLOR_GREEN , COLOR_YELLOW }

Functions
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (::std::string, "")
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (wchar_t, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned int, 0U)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed int, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (UInt64, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (Int64, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)
template<typename T >
void	PrintTo (const ReferenceWrapper< T > &ref, ::std::ostream *os)
template<typename MockType >
const MockType *	AdjustConstness_const (const MockType *mock)
template<typename MockType >
MockType *	AdjustConstness_ (const MockType *mock)
void	PrintIfNotEmpty (const std::string &explanation, ::std::ostream *os)
bool	IsReadableTypeName (const std::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)
template<typename Tuple2Matcher , typename Second >
BoundSecondMatcher< Tuple2Matcher, Second >	MatcherBindSecond (const Tuple2Matcher &tm, const Second &second)
GTEST_API_ std::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 std::string &message)
void	ReportUninterestingCall (CallReaction reaction, const std::string &msg)
GTEST_API_ std::string	JoinAsTuple (const Strings &fields)
GTEST_API_ std::string	ConvertIdentifierNameToWords (const char *id_name)
template<typename Pointer >
const Pointer::element_type *	GetRawPointer (const Pointer &p)
template<typename Element >
Element *	GetRawPointer (Element *p)
	GMOCK_DECLARE_KIND_ (bool, kBool)
	GMOCK_DECLARE_KIND_ (char, kInteger)
	GMOCK_DECLARE_KIND_ (signed char, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)
	GMOCK_DECLARE_KIND_ (short, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned short, kInteger)
	GMOCK_DECLARE_KIND_ (int, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned int, kInteger)
	GMOCK_DECLARE_KIND_ (long, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned long, kInteger)
	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)
	GMOCK_DECLARE_KIND_ (Int64, kInteger)
	GMOCK_DECLARE_KIND_ (UInt64, kInteger)
	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)
template<typename From , typename To >
void	Assert (bool condition, const char *file, int line)
void	Expect (bool condition, const char *file, int line, const std::string &msg)
void	Expect (bool condition, const char *file, int line)
GTEST_API_ bool	LogIsVisible (LogSeverity severity)
GTEST_API_ void	Log (LogSeverity severity, const std::string &message, int stack_frames_to_skip)
GTEST_API_ WithoutMatchers	GetWithoutMatchers ()
template<typename T >
T	Invalid ()
GTEST_API_ void	IllegalDoDefault (const char *file, int line)
GTEST_API_ FailureReporterInterface *	GetFailureReporter ()
GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)
CallReaction	intToCallReaction (int mock_behavior)
template<typename CharType >
void	InitGoogleMockImpl (int *argc, CharType **argv)
template<typename T >
std::string	StreamableToString (const T &streamable)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)
	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)
	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)
template<typename T1 , typename T2 >
std::string	FormatForComparisonFailureMessage (const T1 &value, const T2 &)
template<typename T >
void	UniversalPrint (const T &value, ::std::ostream *os)
template<typename C >
void	DefaultPrintTo (WrapPrinterType< kPrintContainer >, const C &container, ::std::ostream *os)
template<typename T >
void	DefaultPrintTo (WrapPrinterType< kPrintPointer >, T *p, ::std::ostream *os)
template<typename T >
void	DefaultPrintTo (WrapPrinterType< kPrintFunctionPointer >, T *p, ::std::ostream *os)
template<typename T >
void	DefaultPrintTo (WrapPrinterType< kPrintOther >, 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)
	GTEST_IMPL_CMP_HELPER_ (NE, !=)
	GTEST_IMPL_CMP_HELPER_ (LE,<=)
	GTEST_IMPL_CMP_HELPER_ (LT,<)
	GTEST_IMPL_CMP_HELPER_ (GE, >=)
	GTEST_IMPL_CMP_HELPER_ (GT, >)
GTEST_API_ AssertionResult	CmpHelperSTREQ (const char *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)
GTEST_API_ void	ReportInvalidTestCaseType (const char *test_case_name, CodeLocation code_location)
template<class ParamType >
std::string	DefaultParamName (const TestParamInfo< ParamType > &info)
template<class ParamType , class ParamNameGenFunctor >
ParamNameGenFunctor	GetParamNameGen (ParamNameGenFunctor func)
template<class ParamType >
ParamNameGenFunc< ParamType >::Type *	GetParamNameGen ()
GTEST_API_ bool	IsTrue (bool condition)
GTEST_API_::std::string	FormatFileLocation (const char *file, int line)
GTEST_API_::std::string	FormatCompilerIndependentFileLocation (const char *file, int line)
void	LogToStderr ()
void	FlushInfoLog ()
template<typename T >
const T &	move (const T &t)
template<typename T >
	GTEST_ADD_REFERENCE_ (T) forward(GTEST_ADD_REFERENCE_(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)
GTEST_API_ void	CaptureStdout ()
GTEST_API_ std::string	GetCapturedStdout ()
GTEST_API_ void	CaptureStderr ()
GTEST_API_ std::string	GetCapturedStderr ()
GTEST_API_ size_t	GetFileSize (FILE *file)
GTEST_API_ std::string	ReadEntireFile (FILE *file)
GTEST_API_ std::vector< std::string >	GetArgvs ()
GTEST_API_ size_t	GetThreadCount ()
bool	IsAlpha (char ch)
bool	IsAlNum (char ch)
bool	IsDigit (char ch)
bool	IsLower (char ch)
bool	IsSpace (char ch)
bool	IsUpper (char ch)
bool	IsXDigit (char ch)
bool	IsXDigit (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)
GTEST_API_ Int32	Int32FromGTestEnv (const char *flag, Int32 default_val)
std::string	OutputFlagAlsoCheckEnvVar ()
const char *	StringFromGTestEnv (const char *flag, const char *default_val)
GTEST_API_ std::string	StringStreamToString (::std::stringstream *stream)
std::string	CanonicalizeForStdLibVersioning (std::string s)
template<typename T >
std::string	GetTypeName ()
	GTEST_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.")
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)
GTEST_API_ FilePath	GetCurrentExecutableName ()
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
bool	IsPrintableAscii (wchar_t c)
template<typename UnsignedChar , typename Char >
void	PrintCharAndCodeTo (Char c, ostream *os)
void	PrintTo (wchar_t wc, 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)
GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)
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)
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)

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"
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	kPrintUTF8Flag [] = "print_utf8"
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
class testing::internal::GTestFlagSaver	GTEST_ATTRIBUTE_UNUSED_
const int	kStdOutFileno = STDOUT_FILENO
const int	kStdErrFileno = STDERR_FILENO
const char	kUnknownFile [] = "unknown file"
::std::vector< std::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
const int	kTypedTestCases = 0
const int	kTypedTests = 0

Typedef Documentation

BiggestInt

typedef long long testing::internal::BiggestInt

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

Double

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

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

ElementMatcherPair

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

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

ElementMatcherPairs

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

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

false_type

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

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

Float

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

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

Int32

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

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

Int64

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

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

IsContainer

typedef int testing::internal::IsContainer

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

IsNotContainer

typedef char testing::internal::IsNotContainer

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

MutexLock

typedef GTestMutexLock testing::internal::MutexLock

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

SetUpTestCaseFunc

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

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

string

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

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

Strings

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

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

TearDownTestCaseFunc

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

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

TimeInMillis

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

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

true_type

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

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

TypeId

typedef const void* testing::internal::TypeId

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

UInt32

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

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

UInt64

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

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

wstring

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

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

Enumeration Type Documentation

CallReaction

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail

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

                  {
  kAllow,
  kWarn,
  kFail,
};

CharFormat

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape

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

                {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

DefaultPrinterType

enum testing::internal::DefaultPrinterType

Enumerator
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther

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

                        {
  kPrintContainer,
  kPrintPointer,
  kPrintFunctionPointer,
  kPrintOther,
};

GTestColor

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

Definition at line 2892 of file gtest.cc.

                {
  COLOR_DEFAULT,
  COLOR_RED,
  COLOR_GREEN,
  COLOR_YELLOW
};

GTestLogSeverity

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

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

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

LogSeverity

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning

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

                 {
  kInfo = 0,
  kWarning = 1
};

TypeKind

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

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

              {
  kBool, kInteger, kFloatingPoint, kOther
};

Function Documentation

AdjustConstness_()

template<typename MockType >

MockType * testing::internal::AdjustConstness_

(

const MockType *

mock

)

Definition at line 383 of file gmock-generated-function-mockers.h.

                                                 {
  return const_cast<MockType*>(mock);
}

AdjustConstness_const()

template<typename MockType >

const MockType * testing::internal::AdjustConstness_const

(

const MockType *

mock

)

Definition at line 376 of file gmock-generated-function-mockers.h.

                                                            {
  return mock;
}

AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

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

{ return !AlwaysTrue(); }

Here is the call graph for this function:

Here is the caller graph for this function:

AlwaysTrue()

bool testing::internal::AlwaysTrue

(

)

Definition at line 5406 of file gtest.cc.

                  {
#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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AppendUserMessage()

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

Definition at line 2016 of file gtest.cc.

                                                       {
  // 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;
}

Here is the call graph for this function:

ArrayAwareFind()

template<typename Iter , typename Element >

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayEq() [1/3]

template<typename T , typename U >

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

inline

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

{ return lhs == rhs; }

ArrayEq() [2/3]

template<typename T , typename U >

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayEq() [3/3]

template<typename T , typename U , size_t N>

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

inline

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

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

Here is the call graph for this function:

Assert()

template<typename From , typename To >

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

inline

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

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

Here is the caller graph for this function:

BoolFromGTestEnv()

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

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

                                                            {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
  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;
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
}

Here is the call graph for this function:

CanonicalizeForStdLibVersioning()

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

inline

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

                                                              {
  static const char prefix[] = "std::__";
  if (s.compare(0, strlen(prefix), prefix) == 0) {
    std::string::size_type end = s.find("::", strlen(prefix));
    if (end != s.npos) {
      // Erase everything between the initial `std` and the second `::`.
      s.erase(strlen("std"), end - strlen("std"));
    }
  }
  return s;
}

Here is the caller graph for this function:

CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr

(

)

Here is the caller graph for this function:

CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout

(

)

Here is the caller graph for this function:

CaseInsensitiveCStringEquals() [1/2]

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

inline

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

CaseInsensitiveCStringEquals() [2/2]

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

inline

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

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

Here is the call graph for this function:

CaseInsensitiveStringEquals()

template<typename StringType >

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

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

                                                       {
  // 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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckedDowncastToActualType()

template<class Derived , class Base >

Derived * testing::internal::CheckedDowncastToActualType

(

Base *

base

)

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

                                                 {
#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
}

Here is the caller graph for this function:

ChopLowBits()

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

inline

Definition at line 1762 of file gtest.cc.

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

Here is the caller graph for this function:

CmpHelperEQ() [1/2]

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

Definition at line 1452 of file gtest.cc.

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

Here is the call graph for this function:

CmpHelperEQ() [2/2]

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 1428 of file gtest.h.

                                           {
  if (lhs == rhs) {
    return AssertionSuccess();
  }
 
  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperEQFailure()

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 1416 of file gtest.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperFloatingPointEQ()

template<typename RawType >

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

Definition at line 1670 of file gtest.h.

                                                            {
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperOpFailure()

template<typename T1 , typename T2 >

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

Definition at line 1525 of file gtest.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTRCASEEQ()

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

Definition at line 1518 of file gtest.cc.

                                                    {
  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTRCASENE()

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

Definition at line 1548 of file gtest.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTREQ() [1/2]

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

Definition at line 1502 of file gtest.cc.

                                                {
  if (String::CStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTREQ() [2/2]

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

Definition at line 1884 of file gtest.cc.

                                                   {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

Here is the call graph for this function:

CmpHelperSTRNE() [1/2]

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

Definition at line 1534 of file gtest.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTRNE() [2/2]

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

Definition at line 1900 of file gtest.cc.

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

Here is the call graph for this function:

CodePointToUtf8()

std::string testing::internal::CodePointToUtf8

(

UInt32

code_point

)

Definition at line 1774 of file gtest.cc.

                                             {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertIdentifierNameToWords()

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

(

const char *

id_name

)

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

                                                                       {
  std::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CopyArray() [1/3]

template<typename T , typename U >

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

inline

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

{ *to = from; }

CopyArray() [2/3]

template<typename T , typename U >

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

CopyArray() [3/3]

template<typename T , typename U , size_t N>

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

inline

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

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

Here is the call graph for this function:

CopyElements()

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.

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

Here is the caller graph for this function:

CountIf()

template<class Container , typename Predicate >

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

inline

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

                                                            {
  // 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;
}

Here is the caller graph for this function:

CreateCodePointFromUtf16SurrogatePair()

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

inline

Definition at line 1815 of file gtest.cc.

                                                                    {
  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);
}

Here is the caller graph for this function:

DefaultParamName()

template<class ParamType >

std::string testing::internal::DefaultParamName

(

const TestParamInfo< ParamType > &

info

)

Definition at line 372 of file gtest-param-util.h.

                                                                 {
  Message name_stream;
  name_stream << info.index;
  return name_stream.GetString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

DefaultPrintTo() [1/4]

template<typename C >

void testing::internal::DefaultPrintTo	(	WrapPrinterType< kPrintContainer >	,
		const C &	container,
		::std::ostream *	os )

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

                                                        {
  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 << '}';
}

Here is the call graph for this function:

Here is the caller graph for this function:

DefaultPrintTo() [2/4]

template<typename T >

void testing::internal::DefaultPrintTo	(	WrapPrinterType< kPrintFunctionPointer >	,
		T *	p,
		::std::ostream *	os )

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

                                          {
  if (p == NULL) {
    *os << "NULL";
  } 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*.
    *os << reinterpret_cast<const void*>(p);
  }
}

DefaultPrintTo() [3/4]

template<typename T >

void testing::internal::DefaultPrintTo	(	WrapPrinterType< kPrintOther >	,
		const T &	value,
		::std::ostream *	os )

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

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

Here is the call graph for this function:

DefaultPrintTo() [4/4]

template<typename T >

void testing::internal::DefaultPrintTo	(	WrapPrinterType< kPrintPointer >	,
		T *	p,
		::std::ostream *	os )

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

                                          {
  if (p == NULL) {
    *os << "NULL";
  } else {
    // 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;
  }
}

DiffStrings()

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

DoubleNearPredFormat()

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 1377 of file gtest.cc.

                                                       {
  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 << ".";
}

Here is the call graph for this function:

DownCast_()

template<typename To , typename From >

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

inline

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

                             {  // 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);
}

Here is the call graph for this function:

EqFailure()

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

Definition at line 1326 of file gtest.cc.

                                              {
  Message msg;
  msg << "Expected equality of these values:";
  msg << "\n  " << lhs_expression;
  if (lhs_value != lhs_expression) {
    msg << "\n    Which is: " << lhs_value;
  }
  msg << "\n  " << 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Expect() [1/2]

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

inline

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

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

Here is the call graph for this function:

Expect() [2/2]

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

inline

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

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

Here is the caller graph for this function:

ExplainMatchFailureTupleTo()

template<typename MatcherTuple , typename ValueTuple >

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

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

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

FindMaxBipartiteMatching()

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching

(

const MatchMatrix &

g

)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

FloatingPointLE()

template<typename RawType >

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

Definition at line 1399 of file gtest.cc.

                                              {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

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

{ fflush(NULL); }

ForEach()

template<class Container , typename Functor >

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

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

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

Here is the caller graph for this function:

FormatCompilerIndependentFileLocation()

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

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

                                {
  const std::string file_name(file == NULL ? kUnknownFile : file);
 
  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

Here is the call graph for this function:

Here is the caller graph for this function:

FormatEpochTimeInMillisAsIso8601()

std::string testing::internal::FormatEpochTimeInMillisAsIso8601

(

TimeInMillis

ms

)

Definition at line 3617 of file gtest.cc.

                                                            {
  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);
}

Here is the call graph for this function:

FormatFileLocation()

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

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

                                                                    {
  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
}

Here is the caller graph for this function:

FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

FormatMatcherDescription()

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

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

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

Here is the call graph for this function:

FormatTimeInMillisAsSeconds()

std::string testing::internal::FormatTimeInMillisAsSeconds

(

TimeInMillis

ms

)

Definition at line 3593 of file gtest.cc.

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

GetArgvs()

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

(

)

Definition at line 398 of file gtest.cc.

                                {
#if defined(GTEST_CUSTOM_GET_ARGVS_)
  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  // ::string. This code converts it to the appropriate type.
  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  return ::std::vector<std::string>(custom.begin(), custom.end());
#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  return g_argvs;
#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
}

Here is the caller graph for this function:

GetBoolAssertionFailureMessage()

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 1361 of file gtest.cc.

                                          {
  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();
}

Here is the call graph for this function:

GetCapturedStderr()

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

(

)

Here is the caller graph for this function:

GetCapturedStdout()

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

(

)

Here is the caller graph for this function:

GetCurrentExecutableName()

FilePath testing::internal::GetCurrentExecutableName

(

)

Definition at line 411 of file gtest.cc.

                                    {
  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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCurrentOsStackTraceExceptTop()

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

Definition at line 5391 of file gtest.cc.

                                                            {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetElementOr()

template<typename E >

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

inline

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

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

GetFailureReporter()

GTEST_API_ FailureReporterInterface * testing::internal::GetFailureReporter

(

)

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

                                                          {
  // 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;
}

GetFileSize()

size_t testing::internal::GetFileSize

(

FILE *

file

)

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

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

Here is the caller graph for this function:

GetNextRandomSeed()

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

inline

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

                                       {
  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;
}

Here is the caller graph for this function:

GetParamNameGen() [1/2]

template<class ParamType >

ParamNameGenFunc< ParamType >::Type * testing::internal::GetParamNameGen

(

)

Definition at line 394 of file gtest-param-util.h.

                                                            {
  return DefaultParamName;
}

Here is the call graph for this function:

GetParamNameGen() [2/2]

template<class ParamType , class ParamNameGenFunctor >

ParamNameGenFunctor testing::internal::GetParamNameGen

(

ParamNameGenFunctor

func

)

Definition at line 384 of file gtest-param-util.h.

                                                              {
  return func;
}

GetRandomSeedFromFlag()

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

inline

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

                                                         {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRawPointer() [1/2]

template<typename Pointer >

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

inline

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

                                                                           {
  return p.get();
}

Here is the caller graph for this function:

GetRawPointer() [2/2]

template<typename Element >

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

inline

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

{ return p; }

GetTestTypeId()

TypeId testing::internal::GetTestTypeId

(

)

Definition at line 637 of file gtest.cc.

                       {
  return GetTypeId<Test>();
}

Here is the call graph for this function:

GetThreadCount()

size_t testing::internal::GetThreadCount

(

)

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

                        {
  // 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;
}

Here is the caller graph for this function:

GetTimeInMillis()

TimeInMillis testing::internal::GetTimeInMillis

(

)

Definition at line 820 of file gtest.cc.

                               {
#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
}

Here is the caller graph for this function:

GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId

(

)

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

                   {
  // 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_);
}

Here is the caller graph for this function:

GetTypeName()

template<typename T >

std::string testing::internal::GetTypeName

(

)

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

                        {
# 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 CanonicalizeForStdLibVersioning(name_str);
#  else
  return name;
#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
 
# else
 
  return "<type>";
 
# endif  // GTEST_HAS_RTTI
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetWithoutMatchers()

GTEST_API_ WithoutMatchers testing::internal::GetWithoutMatchers

(

)

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

{ return WithoutMatchers(); }

GMOCK_DECLARE_KIND_() [1/16]

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

GMOCK_DECLARE_KIND_() [2/16]

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

GMOCK_DECLARE_KIND_() [3/16]

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

GMOCK_DECLARE_KIND_() [4/16]

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

GMOCK_DECLARE_KIND_() [5/16]

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

GMOCK_DECLARE_KIND_() [6/16]

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

GMOCK_DECLARE_KIND_() [7/16]

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

GMOCK_DECLARE_KIND_() [8/16]

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

GMOCK_DECLARE_KIND_() [9/16]

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

GMOCK_DECLARE_KIND_() [10/16]

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

GMOCK_DECLARE_KIND_() [11/16]

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

GMOCK_DECLARE_KIND_() [12/16]

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

GMOCK_DECLARE_KIND_() [13/16]

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

GMOCK_DECLARE_KIND_() [14/16]

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

GMOCK_DECLARE_KIND_() [15/16]

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

GMOCK_DECLARE_KIND_() [16/16]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [15/17]

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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [16/17]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_

(

void

)

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [17/17]

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

GTEST_ADD_REFERENCE_()

template<typename T >

testing::internal::GTEST_ADD_REFERENCE_

(

T

)

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

{ return t; }

GTEST_DECLARE_STATIC_MUTEX_() [1/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_gmock_mutex

)

GTEST_DECLARE_STATIC_MUTEX_() [2/2]

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_

(

g_linked_ptr_mutex

)

GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_

(

internal_run_death_test

)

GTEST_DEFINE_STATIC_MUTEX_() [1/2]

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_

(

g_gmock_mutex

)

GTEST_DEFINE_STATIC_MUTEX_() [2/2]

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_

(

g_linked_ptr_mutex

)

GTEST_DEFINE_string_()

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

GTEST_IMPL_CMP_HELPER_() [1/5]

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

GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

GT

)

Here is the call graph for this function:

GTEST_IMPL_CMP_HELPER_() [3/5]

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

GTEST_IMPL_CMP_HELPER_() [4/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

LT

)

GTEST_IMPL_CMP_HELPER_() [5/5]

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

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

char

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

wchar_t

)

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_()

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

HandleExceptionsInMethodIfSupported()

template<class T , typename Result >

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

Definition at line 2426 of file gtest.cc.

                                                          {
  // 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 AssertionException&) {  // NOLINT
      // This failure was reported already.
    } 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)();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

HandleSehExceptionsInMethodIfSupported()

template<class T , typename Result >

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

Definition at line 2399 of file gtest.cc.

                                                          {
#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
}

Here is the call graph for this function:

Here is the caller graph for this function:

IllegalDoDefault()

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

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

                                                             {
  internal::Assert(
      false, file, line,
      "You are using DoDefault() inside a composite action like "
      "DoAll() or WithArgs().  This is not supported for technical "
      "reasons.  Please instead spell out the default action, or "
      "assign the default action to an Action variable and use "
      "the variable in various places.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

ImplicitCast_()

template<typename To >

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

inline

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

{ return x; }

InitGoogleMockImpl()

template<typename CharType >

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

Definition at line 148 of file gmock.cc.

                                                    {
  // 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)) ||
        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
                               &GMOCK_FLAG(default_mock_behavior))) {
      // 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--;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitGoogleTestImpl()

template<typename CharType >

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

Definition at line 5761 of file gtest.cc.

                                                    {
  // 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Int32FromEnvOrDie()

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

Definition at line 5173 of file gtest.cc.

                                                            {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Int32FromGTestEnv()

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

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

                                                               {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
  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;
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
}

Here is the call graph for this function:

intToCallReaction()

CallReaction testing::internal::intToCallReaction

(

int

mock_behavior

)

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

                                                  {
  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
    return static_cast<internal::CallReaction>(mock_behavior);
  }
  return kWarn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Invalid()

template<typename T >

T testing::internal::Invalid ( )

inline

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

                   {
  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>();
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsAlNum()

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

inline

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

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

Here is the caller graph for this function:

IsAlpha()

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

inline

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

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

Here is the caller graph for this function:

IsContainerTest() [1/2]

template<class C >

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

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

                                                                {
  return 0;
}

IsContainerTest() [2/2]

template<class C >

IsNotContainer testing::internal::IsContainerTest

(

long

)

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

{ return '\0'; }

IsDigit()

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

inline

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

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

Here is the caller graph for this function:

IsLower()

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

inline

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

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

Here is the caller graph for this function:

IsNull()

AssertionResult testing::internal::IsNull

(

const char *

str

)

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

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

Here is the call graph for this function:

IsNullLiteralHelper() [1/2]

char(& testing::internal::IsNullLiteralHelper

(

...

)

)[2]

IsNullLiteralHelper() [2/2]

char testing::internal::IsNullLiteralHelper

(

Secret *

p

)

IsPrintableAscii()

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

inline

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

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

IsReadableTypeName()

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

inline

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

                                                           {
  // 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("<(") == std::string::npos);
}

Here is the caller graph for this function:

IsSpace()

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

inline

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

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

Here is the caller graph for this function:

IsTrue()

bool testing::internal::IsTrue

(

bool

condition

)

Definition at line 5404 of file gtest.cc.

{ return condition; }

Here is the caller graph for this function:

IsUpper()

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

inline

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

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

Here is the caller graph for this function:

IsUtf16SurrogatePair()

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

inline

Definition at line 1809 of file gtest.cc.

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

Here is the caller graph for this function:

IsXDigit() [1/2]

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

inline

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

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

Here is the caller graph for this function:

IsXDigit() [2/2]

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

inline

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

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

JoinAsTuple()

GTEST_API_ std::string testing::internal::JoinAsTuple

(

const Strings &

fields

)

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

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

Here is the caller graph for this function:

Log()

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

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

                                              {
  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;
}

Here is the call graph for this function:

LogIsVisible()

GTEST_API_ bool testing::internal::LogIsVisible

(

LogSeverity

severity

)

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

                                                   {
  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;
  }
}

Here is the caller graph for this function:

LogToStderr()

void testing::internal::LogToStderr ( )

inline

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

{}

LogWithLocation()

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

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

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

Here is the caller graph for this function:

make_linked_ptr()

template<typename T >

linked_ptr< T > testing::internal::make_linked_ptr

(

T *

ptr

)

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

                                      {
  return linked_ptr<T>(ptr);
}

MakeAndRegisterTestInfo()

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 2561 of file gtest.cc.

                              {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakePredicateFormatterFromMatcher()

template<typename M >

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

inline

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

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

Here is the call graph for this function:

MatcherBindSecond()

template<typename Tuple2Matcher , typename Second >

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

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

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

Here is the caller graph for this function:

MatchPrintAndExplain()

template<typename Value , typename T >

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

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

                                                         {
  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 std::string& type_name = GetTypeName<Value>();
  if (IsReadableTypeName(type_name))
    *listener->stream() << " (of type " << type_name << ")";
#endif
  PrintIfNotEmpty(inner_listener.str(), listener->stream());
 
  return match;
}

Here is the call graph for this function:

Here is the caller graph for this function:

move()

template<typename T >

const T & testing::internal::move

(

const T &

t

)

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

                          {
  return t;
}

Here is the caller graph for this function:

operator!=()

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.

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

Here is the call graph for this function:

operator==()

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.

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

Here is the call graph for this function:

OutputFlagAlsoCheckEnvVar()

std::string testing::internal::OutputFlagAlsoCheckEnvVar

(

)

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

                                     {
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (NULL != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

Here is the call graph for this function:

ParseGoogleTestFlagsOnly() [1/2]

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

Definition at line 5749 of file gtest.cc.

                                                      {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseGoogleTestFlagsOnly() [2/2]

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

Definition at line 5752 of file gtest.cc.

                                                         {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

Here is the call graph for this function:

ParseGoogleTestFlagsOnlyImpl()

template<typename CharType >

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

Definition at line 5696 of file gtest.cc.

                                                              {
  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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseInt32()

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

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

                                                                        {
  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParseInt32Flag()

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

Definition at line 5487 of file gtest.cc.

                                                                     {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintCharAndCodeTo()

template<typename UnsignedChar , typename Char >

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

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

                                             {
  // 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 hexadecimal,
  // 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 << ")";
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintIfNotEmpty()

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

inline

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

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

Here is the caller graph for this function:

PrintRawArrayTo()

template<typename T >

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

PrintStringTo() [1/2]

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

Here is the caller graph for this function:

PrintStringTo() [2/2]

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

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

                                                    {
  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
    if (GTEST_FLAG(print_utf8)) {
      ConditionalPrintAsText(s.data(), s.size(), os);
    }
  }
}

PrintTo() [1/20]

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

inline

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

                                            {
  *os << (x ? "true" : "false");
}

PrintTo() [2/20]

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

inline

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

                                             {
  PrintTo(ImplicitCast_<const char*>(s), os);
}

Here is the call graph for this function:

PrintTo() [3/20]

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

inline

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

                                            {
  // 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);
}

Here is the call graph for this function:

PrintTo() [4/20]

template<typename T1 , typename T2 >

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

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

                                                           {
  *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 << ')';
}

Here is the call graph for this function:

PrintTo() [5/20]

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

inline

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

                                                        {
  PrintStringTo(s, os);
}

Here is the call graph for this function:

PrintTo() [6/20]

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

PrintTo() [7/20]

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

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

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

PrintTo() [8/20]

template<typename T >

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

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

                                                             {
  T& value = ref;
  UniversalPrinter<T&>::Print(value, os);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintTo() [9/20]

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

inline

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

                                                          {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

Here is the call graph for this function:

PrintTo() [10/20]

template<typename T >

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

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

                                             {
  // DefaultPrintTo() is overloaded.  The type of its first argument
  // determines which version will be picked.
  //
  // 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.
  //
  // Note that MSVC and clang-cl do allow an implicit conversion from
  // pointer-to-function to pointer-to-object, but clang-cl warns on it.
  // So don't use ImplicitlyConvertible if it can be helped since it will
  // cause this warning, and use a separate overload of DefaultPrintTo for
  // function pointers so that the `*os << p` in the object pointer overload
  // doesn't cause that warning either.
  DefaultPrintTo(
      WrapPrinterType <
                  (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
              !IsRecursiveContainer<T>::value
          ? kPrintContainer
          : !is_pointer<T>::value
                ? kPrintOther
#if GTEST_LANG_CXX11
                : std::is_function<typename std::remove_pointer<T>::type>::value
#else
                : !internal::ImplicitlyConvertible<T, const void*>::value
#endif
                      ? kPrintFunctionPointer
                      : kPrintPointer > (),
      value, os);
}

Here is the call graph for this function:

PrintTo() [11/20]

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

inline

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

                                                            {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

Here is the call graph for this function:

PrintTo() [12/20]

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

PrintTo() [13/20]

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

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

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

PrintTo() [14/20]

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

inline

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

                                                    {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

Here is the call graph for this function:

PrintTo() [15/20]

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

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

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

Here is the call graph for this function:

PrintTo() [16/20]

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

inline

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

                                                      {
  PrintTo(ImplicitCast_<const void*>(s), os);
}

Here is the call graph for this function:

PrintTo() [17/20]

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

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

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

Here is the call graph for this function:

PrintTo() [18/20]

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

inline

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

                                                {
  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
}

Here is the call graph for this function:

PrintTo() [19/20]

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

PrintTo() [20/20]

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

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

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

Here is the call graph for this function:

ReadEntireFile()

std::string testing::internal::ReadEntireFile

(

FILE *

file

)

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

                                     {
  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;
}

Here is the call graph for this function:

ReportFailureInUnknownLocation()

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

Definition at line 2266 of file gtest.cc.

                                                              {
  // 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.
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReportInvalidTestCaseType()

void testing::internal::ReportInvalidTestCaseType	(	const char *	test_case_name,
		CodeLocation	code_location )

Definition at line 2578 of file gtest.cc.

                                                           {
  Message errors;
  errors
      << "Attempted redefinition of test case " << test_case_name << ".\n"
      << "All tests in the same test case must use the same test fixture\n"
      << "class.  However, in test case " << test_case_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test cases.";
 
  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
                                          code_location.line)
                    << " " << errors.GetString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReportUninterestingCall()

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

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

                                                                          {
  // 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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldRunTestOnShard()

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

Definition at line 5191 of file gtest.cc.

                                                                          {
  return (test_id % total_shards) == shard_index;
}

Here is the caller graph for this function:

ShouldShard()

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

Definition at line 5128 of file gtest.cc.

                                                    {
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldUseColor()

bool testing::internal::ShouldUseColor

(

bool

stdout_is_tty

)

Definition at line 2959 of file gtest.cc.

                                        {
  const char* const gtest_color = GTEST_FLAG(color).c_str();
 
  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
    // 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.
}

Here is the call graph for this function:

Shuffle()

template<typename E >

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

inline

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

                                                             {
  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
}

Here is the call graph for this function:

ShuffleRange()

template<typename E >

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

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

                                   {
  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]);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SkipPrefix()

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

Definition at line 5419 of file gtest.cc.

                                                       {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

SplitString()

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

Definition at line 936 of file gtest.cc.

                                              {
  ::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);
}

Here is the call graph for this function:

StreamableToString()

template<typename T >

std::string testing::internal::StreamableToString

(

const T &

streamable

)

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

                                                  {
  return (Message() << streamable).GetString();
}

Here is the caller graph for this function:

StringFromGTestEnv()

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

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

                                                                            {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const value = posix::GetEnv(env_var.c_str());
  return value == NULL ? default_value : value;
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
}

Here is the call graph for this function:

StringStreamToString()

std::string testing::internal::StringStreamToString

(

::std::stringstream *

stream

)

Definition at line 1997 of file gtest.cc.

                                                    {
  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;
}

Here is the caller graph for this function:

StripTrailingSpaces()

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

inline

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

                                                    {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

Here is the call graph for this function:

TEST() [1/41]

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

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

{}

TEST() [2/41]

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

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

                                             {
  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());
}

Here is the call graph for this function:

TEST() [3/41]

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

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

                                              {
  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
}

Here is the call graph for this function:

TEST() [4/41]

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

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

                                              {
  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");
}

Here is the call graph for this function:

TEST() [5/41]

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

Definition at line 954 of file gtest-port_test.cc.

                                                   {
  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.
}

Here is the call graph for this function:

TEST() [6/41]

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

Definition at line 934 of file gtest-port_test.cc.

                                  {
  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()));
}

Here is the call graph for this function:

TEST() [7/41]

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

Definition at line 924 of file gtest-port_test.cc.

                                  {
  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()));
}

Here is the call graph for this function:

TEST() [8/41]

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

Definition at line 945 of file gtest-port_test.cc.

                                           {
  CaptureStdout();
  CaptureStderr();
  fprintf(stdout, "pqr");
  fprintf(stderr, "stu");
  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
}

Here is the call graph for this function:

TEST() [9/41]

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

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

{}

TEST() [10/41]

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

Definition at line 282 of file gtest-port_test.cc.

                                                                     {
  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
}

Here is the call graph for this function:

TEST() [11/41]

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

Definition at line 286 of file gtest-port_test.cc.

                                                                   {
  EXPECT_EQ("unknown file:42",
            FormatCompilerIndependentFileLocation(NULL, 42));
}

Here is the call graph for this function:

TEST() [12/41]

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

Definition at line 295 of file gtest-port_test.cc.

                                                                          {
  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1));
}

Here is the call graph for this function:

TEST() [13/41]

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

Definition at line 291 of file gtest-port_test.cc.

                                                                   {
  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
}

Here is the call graph for this function:

TEST() [14/41]

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

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

                                                  {
  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
}

Here is the call graph for this function:

TEST() [15/41]

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

Definition at line 277 of file gtest-port_test.cc.

                                                       {
  EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1));
}

Here is the call graph for this function:

TEST() [16/41]

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

Definition at line 273 of file gtest-port_test.cc.

                                                {
  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
}

Here is the call graph for this function:

TEST() [17/41]

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

Definition at line 267 of file gtest-port_test.cc.

                                                 {
  EXPECT_PRED_FORMAT2(
      IsSubstring, "unknown file", FormatFileLocation(NULL, 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42));
}

Here is the call graph for this function:

TEST() [18/41]

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

Definition at line 340 of file gtest-port_test.cc.

                                                              {
  EXPECT_EQ(0U, GetThreadCount());
}

Here is the call graph for this function:

TEST() [19/41]

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

Definition at line 345 of file gtest-port_test.cc.

                                                          {
  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);
}

TEST() [20/41]

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

Definition at line 232 of file gtest-port_test.cc.

                                                        {
  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) << "";
}

Here is the call graph for this function:

TEST() [21/41]

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

Definition at line 248 of file gtest-port_test.cc.

                                            {
  switch (0) {
    case 1:
      break;
    default:
      GTEST_CHECK_(true);
  }
 
  switch (0)
    case 0:
      GTEST_CHECK_(true) << "Check failed in switch case";
}

TEST() [22/41]

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

Definition at line 178 of file gtest-port_test.cc.

                                                                          {
  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);
}

Here is the call graph for this function:

TEST() [23/41]

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

Definition at line 153 of file gtest-port_test.cc.

                                                             {
  bool converted = false;
  const ConstCastable const_castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
  EXPECT_TRUE(converted);
}

Here is the call graph for this function:

TEST() [24/41]

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

Definition at line 199 of file gtest-port_test.cc.

                                                  {
  bool converted = false;
  To to = ::testing::internal::ImplicitCast_<To>(&converted);
  (void)to;
  EXPECT_TRUE(converted);
}

Here is the call graph for this function:

TEST() [25/41]

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

Definition at line 116 of file gtest-port_test.cc.

                                          {
  Derived derived(1);
  Base base = ::testing::internal::ImplicitCast_<Base>(derived);
  EXPECT_EQ(derived.member(), base.member());
}

Here is the call graph for this function:

TEST() [26/41]

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

Definition at line 134 of file gtest-port_test.cc.

                                                   {
  bool converted = false;
  Castable castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
  EXPECT_TRUE(converted);
}

Here is the call graph for this function:

TEST() [27/41]

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

Definition at line 111 of file gtest-port_test.cc.

                                         {
  Derived derived(0);
  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
}

Here is the call graph for this function:

TEST() [28/41]

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

Definition at line 69 of file gtest-port_test.cc.

                                                  {
  EXPECT_FALSE(IsXDigit(static_cast<char>('\x80')));
  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
}

Here is the call graph for this function:

TEST() [29/41]

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

Definition at line 87 of file gtest-port_test.cc.

                                                {
  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)));
}

Here is the call graph for this function:

TEST() [30/41]

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

Definition at line 56 of file gtest-port_test.cc.

                                        {
  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'));
}

Here is the call graph for this function:

TEST() [31/41]

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

Definition at line 74 of file gtest-port_test.cc.

                                      {
  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'));
}

Here is the call graph for this function:

TEST() [32/41]

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForPointerToConst	)

Definition at line 218 of file gtest-port_test.cc.

                                                 {
  StaticAssertTypeEq<char, IteratorTraits<const char*>::value_type>();
  StaticAssertTypeEq<const void*,
      IteratorTraits<const void* const*>::value_type>();
}

TEST() [33/41]

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForPointerToNonConst	)

Definition at line 213 of file gtest-port_test.cc.

                                                    {
  StaticAssertTypeEq<char, IteratorTraits<char*>::value_type>();
  StaticAssertTypeEq<const void*, IteratorTraits<const void**>::value_type>();
}

TEST() [34/41]

testing::internal::TEST	(	IteratorTraitsTest	,
		WorksForSTLContainerIterators	)

Definition at line 206 of file gtest-port_test.cc.

                                                        {
  StaticAssertTypeEq<int,
      IteratorTraits< ::std::vector<int>::const_iterator>::value_type>();
  StaticAssertTypeEq<bool,
      IteratorTraits< ::std::list<bool>::iterator>::value_type>();
}

TEST() [35/41]

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

Definition at line 376 of file gtest-port_test.cc.

                                                          {
#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
}

TEST() [36/41]

testing::internal::TEST	(	ScopedPtrTest	,
		DefinesElementType	)

Definition at line 226 of file gtest-port_test.cc.

                                        {
  StaticAssertTypeEq<int, ::testing::internal::scoped_ptr<int>::element_type>();
}

TEST() [37/41]

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

Definition at line 966 of file gtest-port_test.cc.

                                                                    {
  ThreadLocal<int> t1;
  EXPECT_EQ(0, t1.get());
 
  ThreadLocal<void*> t2;
  EXPECT_TRUE(t2.get() == NULL);
}

Here is the call graph for this function:

TEST() [38/41]

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

Definition at line 994 of file gtest-port_test.cc.

                                                    {
  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()));
}

Here is the call graph for this function:

TEST() [39/41]

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

Definition at line 1004 of file gtest-port_test.cc.

                                                             {
  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());
}

Here is the call graph for this function:

TEST() [40/41]

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

Definition at line 974 of file gtest-port_test.cc.

                                                                {
  ThreadLocal<int> t1(123);
  EXPECT_EQ(123, t1.get());
 
  int i = 0;
  ThreadLocal<int*> t2(&i);
  EXPECT_EQ(&i, t2.get());
}

Here is the call graph for this function:

TEST() [41/41]

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

Definition at line 989 of file gtest-port_test.cc.

                                                                          {
  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
  bar.pointer();
}

TEST_F() [1/2]

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

Definition at line 165 of file gtest-listener_test.cc.

                              {
  g_events->push_back("ListenerTest::* Test Body");
  SUCCEED();  // Triggers OnTestPartResult.
}

TEST_F() [2/2]

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

Definition at line 158 of file gtest-listener_test.cc.

                              {
  // 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.
}

ToLower()

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

inline

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

                             {
  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
}

Here is the caller graph for this function:

ToUpper()

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

inline

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

                             {
  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
}

TransformTupleValues()

template<typename Tuple , typename Func , typename OutIter >

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

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

                                                                  {
  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TupleMatches()

template<typename MatcherTuple , typename ValueTuple >

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

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

                                                 {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UniversalPrint()

template<typename T >

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

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

                                                    {
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UniversalPrintArray() [1/5]

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

UniversalPrintArray() [2/5]

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

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

                                                                     {
  UniversalPrintCharArray(begin, len, os);
}

UniversalPrintArray() [3/5]

template<typename T >

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

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

                                                                     {
  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 << " }";
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

UniversalPrintArray() [4/5]

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

UniversalPrintArray() [5/5]

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

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

                                                                        {
  UniversalPrintCharArray(begin, len, os);
}

UniversalTersePrint()

template<typename T >

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

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

                                                         {
  UniversalTersePrinter<T>::Print(value, os);
}

Here is the call graph for this function:

WideStringToUtf8()

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

Definition at line 1838 of file gtest.cc.

                                                              {
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded

(

)

Definition at line 5106 of file gtest.cc.

                                      {
  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);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_argvs

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

Definition at line 396 of file gtest.cc.

g_gmock_implicit_sequence

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

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

g_help_flag

bool testing::internal::g_help_flag = false

Definition at line 183 of file gtest.cc.

GTEST_ATTRIBUTE_UNUSED_

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

kAlsoRunDisabledTestsFlag

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

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

kBreakOnFailureFlag

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

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

kCatchExceptionsFlag

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

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

kColorFlag

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

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

kCurrentDirectoryString

const char testing::internal::kCurrentDirectoryString[] = "./"

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

kDeathTestStyleFlag

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

Definition at line 49 of file gtest-death-test-internal.h.

kDeathTestUseFork

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

Definition at line 50 of file gtest-death-test-internal.h.

kErrorVerbosity

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

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

kFilterFlag

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

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

kFlagfileFlag

const char testing::internal::kFlagfileFlag[] = "flagfile"

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

kInfoVerbosity

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

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

kInternalRunDeathTestFlag

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

Definition at line 51 of file gtest-death-test-internal.h.

kListTestsFlag

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

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

kMaxBiggestInt

const BiggestInt testing::internal::kMaxBiggestInt

Initial value:

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

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

kMaxCodePoint1

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

Definition at line 1748 of file gtest.cc.

kMaxCodePoint2

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

Definition at line 1751 of file gtest.cc.

kMaxCodePoint3

const UInt32 testing::internal::kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1

Definition at line 1754 of file gtest.cc.

kMaxCodePoint4

const UInt32 testing::internal::kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1

Definition at line 1757 of file gtest.cc.

kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

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

kOutputFlag

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

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

kPathSeparator

const char testing::internal::kPathSeparator = '/'

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

kPrintTimeFlag

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

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

kPrintUTF8Flag

const char testing::internal::kPrintUTF8Flag[] = "print_utf8"

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

kRandomSeedFlag

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

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

kRepeatFlag

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

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

kShuffleFlag

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

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

kStackTraceDepthFlag

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

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

kStackTraceMarker

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

Definition at line 179 of file gtest.cc.

kStdErrFileno

const int testing::internal::kStdErrFileno = STDERR_FILENO

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

kStdOutFileno

const int testing::internal::kStdOutFileno = STDOUT_FILENO

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

kStreamResultToFlag

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

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

kTestTypeIdInGoogleTest

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

extern

Definition at line 643 of file gtest.cc.

kThrowOnFailureFlag

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

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

kTypedTestCases

const int testing::internal::kTypedTestCases = 0

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

kTypedTests

const int testing::internal::kTypedTests = 0

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

kUnknownFile

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

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

kWarningVerbosity

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

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