testing::internal Namespace Reference

Namespaces
namespace	invoke_argument
namespace	edit_distance
namespace	posix

Classes
class	ActionAdaptor
struct	BuiltInDefaultValueGetter
struct	BuiltInDefaultValueGetter< T, false >
class	BuiltInDefaultValue
class	BuiltInDefaultValue< const T >
class	BuiltInDefaultValue< T * >
struct	ByMoveWrapper
class	ReturnAction
class	ReturnNullAction
class	ReturnVoidAction
class	ReturnRefAction
class	ReturnRefOfCopyAction
class	DoDefaultAction
class	AssignAction
class	SetErrnoAndReturnAction
class	SetArgumentPointeeAction
class	SetArgumentPointeeAction< N, Proto, true >
class	InvokeWithoutArgsAction
class	InvokeMethodWithoutArgsAction
class	IgnoreResultAction
class	ReferenceWrapper
class	DoBothAction
class	InvokeHelper
class	InvokeHelper< R, ::testing::tuple<> >
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	SelectArgs
class	SelectArgs< Result, ArgumentTuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, -1, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, -1, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, -1, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, -1, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, -1, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, -1, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, -1, -1 >
class	SelectArgs< Result, ArgumentTuple, k1, k2, k3, k4, k5, k6, k7, k8, k9, -1 >
class	WithArgsAction
struct	ExcessiveArg
class	ActionHelper
class	FunctionMockerBase
class	FunctionMocker
class	FunctionMocker< R(A1)>
class	FunctionMocker< R(A1, A2)>
class	FunctionMocker< R(A1, A2, A3)>
class	FunctionMocker< R(A1, A2, A3, A4)>
class	FunctionMocker< R(A1, A2, A3, A4, A5)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
class	FunctionMocker< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
class	TupleFields
class	TupleFields< Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, -1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, -1, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, -1, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, -1, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, -1, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, -1, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, -1, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, -1, -1 >
class	TupleFields< Tuple, k0, k1, k2, k3, k4, k5, k6, k7, k8, -1 >
class	ArgsMatcherImpl
class	ArgsMatcher
struct	AllOfResult1
struct	AllOfResult2
struct	AllOfResult3
struct	AllOfResult4
struct	AllOfResult5
struct	AllOfResult6
struct	AllOfResult7
struct	AllOfResult8
struct	AllOfResult9
struct	AllOfResult10
struct	AnyOfResult1
struct	AnyOfResult2
struct	AnyOfResult3
struct	AnyOfResult4
struct	AnyOfResult5
struct	AnyOfResult6
struct	AnyOfResult7
struct	AnyOfResult8
struct	AnyOfResult9
struct	AnyOfResult10
struct	AnyEq
struct	AnyNe
struct	AnyLt
struct	AnyGt
struct	AnyLe
struct	AnyGe
class	DummyMatchResultListener
class	StreamMatchResultListener
class	MatcherBase
class	MatcherCastImpl
class	MatcherCastImpl< T, Matcher< U > >
class	MatcherCastImpl< T, Matcher< T > >
class	TuplePrefix
class	TuplePrefix< 0 >
class	TransformTupleValuesHelper
class	AnyMatcherImpl
class	AnythingMatcher
class	ComparisonBase
class	EqMatcher
class	NeMatcher
class	LtMatcher
class	GtMatcher
class	LeMatcher
class	GeMatcher
class	IsNullMatcher
class	NotNullMatcher
class	RefMatcher
class	RefMatcher< T & >
class	StrEqualityMatcher
class	HasSubstrMatcher
class	StartsWithMatcher
class	EndsWithMatcher
class	MatchesRegexMatcher
class	PairMatchBase
class	Eq2Matcher
class	Ne2Matcher
class	Lt2Matcher
class	Gt2Matcher
class	Le2Matcher
class	Ge2Matcher
class	NotMatcherImpl
class	NotMatcher
class	BothOfMatcherImpl
class	BothOfMatcher
class	EitherOfMatcherImpl
class	EitherOfMatcher
class	TrulyMatcher
class	MatcherAsPredicate
class	PredicateFormatterFromMatcher
class	FloatingEqMatcher
class	PointeeMatcher
class	WhenDynamicCastToMatcherBase
class	WhenDynamicCastToMatcher
class	WhenDynamicCastToMatcher< To & >
class	FieldMatcher
class	PropertyMatcher
struct	CallableTraits
struct	CallableTraits< ResType(*)(ArgType)>
class	ResultOfMatcher
class	SizeIsMatcher
class	BeginEndDistanceIsMatcher
class	ContainerEqMatcher
struct	LessComparator
class	WhenSortedByMatcher
class	PointwiseMatcher
class	QuantifierMatcherImpl
class	ContainsMatcherImpl
class	EachMatcherImpl
class	ContainsMatcher
class	EachMatcher
class	KeyMatcherImpl
class	KeyMatcher
class	PairMatcherImpl
class	PairMatcher
class	ElementsAreMatcherImpl
class	MatchMatrix
class	UnorderedElementsAreMatcherImplBase
class	UnorderedElementsAreMatcherImpl
struct	CastAndAppendTransform
class	UnorderedElementsAreMatcher
class	ElementsAreMatcher
class	UnorderedElementsAreArrayMatcher
class	ElementsAreArrayMatcher
class	BoundSecondMatcher
class	InvokeAction
class	InvokeMethodAction
class	TypedExpectation
class	UntypedFunctionMockerBase
class	UntypedOnCallSpecBase
class	OnCallSpec
class	ExpectationBase
class	MockSpec
class	ReferenceOrValueWrapper
class	ReferenceOrValueWrapper< T & >
class	UntypedActionResultHolderBase
class	ActionResultHolder
class	ActionResultHolder< void >
class	IgnoredValue
struct	MatcherTuple
struct	MatcherTuple< ::testing::tuple<> >
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	Function
struct	Function< R(A1)>
struct	Function< R(A1, A2)>
struct	Function< R(A1, A2, A3)>
struct	Function< R(A1, A2, A3, A4)>
struct	Function< R(A1, A2, A3, A4, A5)>
struct	Function< R(A1, A2, A3, A4, A5, A6)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
struct	PointeeOf
struct	PointeeOf< T * >
struct	LinkedPtrLessThan
struct	KindOf
struct	LosslessArithmeticConvertibleImpl
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To >
struct	LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To >
struct	LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To >
struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool >
struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To >
struct	is_reference
struct	is_reference< T & >
struct	type_equals
struct	type_equals< T, T >
struct	remove_reference
struct	remove_reference< T & >
struct	DecayArray
struct	DecayArray< T[N]>
struct	DecayArray< T[]>
class	StlContainerView
class	StlContainerView< Element[N]>
class	StlContainerView< ::testing::tuple< ElementPointer, Size > >
struct	RemoveConstFromKey
struct	RemoveConstFromKey< std::pair< const K, V > >
struct	BooleanConstant
class	FormatForComparison
class	FormatForComparison< ToPrint[N], OtherOperand >
class	UniversalPrinter
class	UniversalPrinter< T[N]>
class	UniversalPrinter< T & >
class	UniversalTersePrinter
class	UniversalTersePrinter< T & >
class	UniversalTersePrinter< T[N]>
class	UniversalTersePrinter< const char * >
class	UniversalTersePrinter< char * >
class	UniversalTersePrinter< wchar_t * >
struct	TuplePolicy
class	SingleFailureChecker
class	HasNewFatalFailureHelper
class	EqHelper
class	EqHelper< true >
class	AssertHelper
class	FilePath
class	ScopedTrace
class	FloatingPoint
class	TypeIdHelper
class	TestFactoryBase
class	TestFactoryImpl
struct	CodeLocation
struct	ConstCharPtr
class	Random
struct	CompileAssertTypesEqual
struct	CompileAssertTypesEqual< T, T >
struct	RemoveReference
struct	RemoveReference< T & >
struct	RemoveConst
struct	RemoveConst< const T >
struct	RemoveConst< const T[N]>
struct	AddReference
struct	AddReference< T & >
class	ImplicitlyConvertible
struct	IsAProtocolMessage
struct	EnableIf
struct	EnableIf< true >
struct	RelationToSourceReference
struct	RelationToSourceCopy
class	NativeArray
class	linked_ptr_internal
class	linked_ptr
struct	CompileAssert
struct	StaticAssertTypeEqHelper
struct	StaticAssertTypeEqHelper< T, T >
class	scoped_ptr
class	RE
class	GTestLog
class	Mutex
class	GTestMutexLock
class	ThreadLocal
struct	bool_constant
struct	is_pointer
struct	is_pointer< T * >
struct	IteratorTraits
struct	IteratorTraits< T * >
struct	IteratorTraits< const T * >
class	TypeWithSize
class	TypeWithSize< 4 >
class	TypeWithSize< 8 >
class	String
class	GTestFlagSaver
class	TestPropertyKeyIs
class	UnitTestOptions
class	OsStackTraceGetterInterface
class	OsStackTraceGetter
struct	TraceInfo
class	DefaultGlobalTestPartResultReporter
class	DefaultPerThreadTestPartResultReporter
class	UnitTestImpl
class	TestResultAccessor

Typedefs
typedef ::std::pair< size_t, size_t >	ElementMatcherPair
typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs
typedef ::std::vector< string >	Strings
typedef FloatingPoint< float >	Float
typedef FloatingPoint< double >	Double
typedef const void *	TypeId
typedef void(*	SetUpTestCaseFunc) ()
typedef void(*	TearDownTestCaseFunc) ()
typedef int	IsContainer
typedef char	IsNotContainer
typedef ::std::string	string
typedef ::std::wstring	wstring
typedef GTestMutexLock	MutexLock
typedef bool_constant< false >	false_type
typedef bool_constant< true >	true_type
typedef long long	BiggestInt
typedef TypeWithSize< 4 >::Int	Int32
typedef TypeWithSize< 4 >::UInt	UInt32
typedef TypeWithSize< 8 >::Int	Int64
typedef TypeWithSize< 8 >::UInt	UInt64
typedef TypeWithSize< 8 >::Int	TimeInMillis

Enumerations
enum	CallReaction { kAllow , kWarn , kFail , kDefault = kWarn }
enum	TypeKind { kBool , kInteger , kFloatingPoint , kOther }
enum	LogSeverity { kInfo = 0 , kWarning = 1 }
enum	GTestLogSeverity {   GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL ,   GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL }
enum	GTestLogSeverity {   GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL ,   GTEST_INFO , GTEST_WARNING , GTEST_ERROR , GTEST_FATAL }

Functions
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (::std::string, "")
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (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)
void	PrintIfNotEmpty (const internal::string &explanation, ::std::ostream *os)
bool	IsReadableTypeName (const string &type_name)
template<typename Value, typename T>
bool	MatchPrintAndExplain (Value &value, const Matcher< T > &matcher, MatchResultListener *listener)
template<typename MatcherTuple, typename ValueTuple>
bool	TupleMatches (const MatcherTuple &matcher_tuple, const ValueTuple &value_tuple)
template<typename MatcherTuple, typename ValueTuple>
void	ExplainMatchFailureTupleTo (const MatcherTuple &matchers, const ValueTuple &values, ::std::ostream *os)
template<typename Tuple, typename Func, typename OutIter>
OutIter	TransformTupleValues (Func f, const Tuple &t, OutIter out)
bool	CaseInsensitiveCStringEquals (const char *lhs, const char *rhs)
bool	CaseInsensitiveCStringEquals (const wchar_t *lhs, const wchar_t *rhs)
template<typename StringType>
bool	CaseInsensitiveStringEquals (const StringType &s1, const StringType &s2)
template<typename M>
PredicateFormatterFromMatcher< M >	MakePredicateFormatterFromMatcher (M matcher)
GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)
GTEST_API_ bool	FindPairing (const MatchMatrix &matrix, MatchResultListener *listener)
template<typename Tuple2Matcher, typename Second>
BoundSecondMatcher< Tuple2Matcher, Second >	MatcherBindSecond (const Tuple2Matcher &tm, const Second &second)
GTEST_API_ string	FormatMatcherDescription (bool negation, const char *matcher_name, const Strings &param_values)
template<typename InputIterator, typename OutputIterator>
OutputIterator	CopyElements (InputIterator first, InputIterator last, OutputIterator output)
GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_gmock_mutex)
GTEST_API_ void	LogWithLocation (testing::internal::LogSeverity severity, const char *file, int line, const string &message)
void	ReportUninterestingCall (CallReaction reaction, const string &msg)
GTEST_API_ string	ConvertIdentifierNameToWords (const char *id_name)
template<typename Pointer>
const Pointer::element_type *	GetRawPointer (const Pointer &p)
template<typename Element>
Element *	GetRawPointer (Element *p)
	GMOCK_DECLARE_KIND_ (bool, kBool)
	GMOCK_DECLARE_KIND_ (char, kInteger)
	GMOCK_DECLARE_KIND_ (signed char, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)
	GMOCK_DECLARE_KIND_ (short, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned short, kInteger)
	GMOCK_DECLARE_KIND_ (int, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned int, kInteger)
	GMOCK_DECLARE_KIND_ (long, kInteger)
	GMOCK_DECLARE_KIND_ (unsigned long, kInteger)
	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)
	GMOCK_DECLARE_KIND_ (Int64, kInteger)
	GMOCK_DECLARE_KIND_ (UInt64, kInteger)
	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)
	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)
template<typename From, typename To>
void	Assert (bool condition, const char *file, int line)
void	Expect (bool condition, const char *file, int line, const string &msg)
void	Expect (bool condition, const char *file, int line)
GTEST_API_ bool	LogIsVisible (LogSeverity severity)
GTEST_API_ void	Log (LogSeverity severity, const string &message, int stack_frames_to_skip)
template<typename T>
T	Invalid ()
template<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 (IsContainer, false_type, const C &container, ::std::ostream *os)
template<typename T>
void	DefaultPrintTo (IsNotContainer, true_type, T *p, ::std::ostream *os)
template<typename T>
void	DefaultPrintTo (IsNotContainer, false_type, const T &value, ::std::ostream *os)
template<typename T>
void	PrintTo (const T &value, ::std::ostream *os)
GTEST_API_ void	PrintTo (unsigned char c, ::std::ostream *os)
GTEST_API_ void	PrintTo (signed char c, ::std::ostream *os)
void	PrintTo (char c, ::std::ostream *os)
void	PrintTo (bool x, ::std::ostream *os)
GTEST_API_ void	PrintTo (wchar_t wc, ::std::ostream *os)
GTEST_API_ void	PrintTo (const char *s, ::std::ostream *os)
void	PrintTo (char *s, ::std::ostream *os)
void	PrintTo (const signed char *s, ::std::ostream *os)
void	PrintTo (signed char *s, ::std::ostream *os)
void	PrintTo (const unsigned char *s, ::std::ostream *os)
void	PrintTo (unsigned char *s, ::std::ostream *os)
GTEST_API_ void	PrintTo (const wchar_t *s, ::std::ostream *os)
void	PrintTo (wchar_t *s, ::std::ostream *os)
template<typename T>
void	PrintRawArrayTo (const T a[], size_t count, ::std::ostream *os)
GTEST_API_ void	PrintStringTo (const ::std::string &s, ::std::ostream *os)
void	PrintTo (const ::std::string &s, ::std::ostream *os)
template<typename T1, typename T2>
void	PrintTo (const ::std::pair< T1, T2 > &value, ::std::ostream *os)
template<typename T>
void	UniversalPrintArray (const T *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const char *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	UniversalPrintArray (const wchar_t *begin, size_t len, ::std::ostream *os)
template<typename T>
void	UniversalTersePrint (const T &value, ::std::ostream *os)
class UnitTestImpl *	GetUnitTestImpl ()
void	ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
template<typename T1, typename T2>
AssertionResult	CmpHelperEQFailure (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
template<typename T1, typename T2>
AssertionResult	CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
GTEST_API_ AssertionResult	CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, BiggestInt lhs, BiggestInt rhs)
template<typename T1, typename T2>
AssertionResult	CmpHelperOpFailure (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
	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_ 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 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_ std::string	TempDir ()
GTEST_API_ size_t	GetFileSize (FILE *file)
GTEST_API_ std::string	ReadEntireFile (FILE *file)
GTEST_API_ const ::std::vector< testing::internal::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	StringFromGTestEnv (const char *flag, const char *default_val)
GTEST_API_ std::string	StringStreamToString (::std::stringstream *stream)
template<typename T>
std::string	GetTypeName ()
GTEST_API_ TimeInMillis	GetTimeInMillis ()
GTEST_API_ bool	ShouldUseColor (bool stdout_is_tty)
GTEST_API_ std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)
GTEST_API_ std::string	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
GTEST_API_ bool	ParseInt32Flag (const char *str, const char *flag, Int32 *value)
int	GetRandomSeedFromFlag (Int32 random_seed_flag)
int	GetNextRandomSeed (int seed)
GTEST_API_ std::string	CodePointToUtf8 (UInt32 code_point)
GTEST_API_ std::string	WideStringToUtf8 (const wchar_t *str, int num_chars)
void	WriteToShardStatusFileIfNeeded ()
GTEST_API_ bool	ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
GTEST_API_ Int32	Int32FromEnvOrDie (const char *env_var, Int32 default_val)
GTEST_API_ bool	ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
template<class Container, typename Predicate>
int	CountIf (const Container &c, Predicate predicate)
template<class Container, typename Functor>
void	ForEach (const Container &c, Functor functor)
template<typename E>
E	GetElementOr (const std::vector< E > &v, int i, E default_value)
template<typename E>
void	ShuffleRange (internal::Random *random, int begin, int end, std::vector< E > *v)
template<typename E>
void	Shuffle (internal::Random *random, std::vector< E > *v)
GTEST_API_ FilePath	GetCurrentExecutableName ()
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void	ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)

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 []
class GTEST_API_ testing::internal::ScopedTrace	GTEST_ATTRIBUTE_UNUSED_
template<typename T>
bool	TypeIdHelper< T >::dummy_ = false
template<typename From, typename To>
const bool	ImplicitlyConvertible< From, To >::value
template<bool bool_value>
const bool	bool_constant< bool_value >::value
const BiggestInt	kMaxBiggestInt
GTEST_API_ const TypeId	kTestTypeIdInGoogleTest
const char	kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"
const char	kBreakOnFailureFlag [] = "break_on_failure"
const char	kCatchExceptionsFlag [] = "catch_exceptions"
const char	kColorFlag [] = "color"
const char	kFilterFlag [] = "filter"
const char	kListTestsFlag [] = "list_tests"
const char	kOutputFlag [] = "output"
const char	kPrintTimeFlag [] = "print_time"
const char	kRandomSeedFlag [] = "random_seed"
const char	kRepeatFlag [] = "repeat"
const char	kShuffleFlag [] = "shuffle"
const char	kStackTraceDepthFlag [] = "stack_trace_depth"
const char	kStreamResultToFlag [] = "stream_result_to"
const char	kThrowOnFailureFlag [] = "throw_on_failure"
const char	kFlagfileFlag [] = "flagfile"
const int	kMaxRandomSeed = 99999
GTEST_API_ bool	g_help_flag

Typedef Documentation

BiggestInt

typedef long long testing::internal::BiggestInt

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

Double

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

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

ElementMatcherPair

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

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

ElementMatcherPairs

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

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

false_type

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

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

Float

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

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

Int32

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

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

Int64

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

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

IsContainer

typedef int testing::internal::IsContainer

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

IsNotContainer

typedef char testing::internal::IsNotContainer

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

MutexLock

typedef GTestMutexLock testing::internal::MutexLock

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

SetUpTestCaseFunc

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

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

string

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

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

Strings

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

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

TearDownTestCaseFunc

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

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

TimeInMillis

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

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

true_type

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

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

TypeId

typedef const void * testing::internal::TypeId

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

UInt32

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

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

UInt64

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

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

wstring

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

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

Enumeration Type Documentation

CallReaction

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault

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

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

GTestLogSeverity [1/2]

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

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

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

GTestLogSeverity [2/2]

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

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

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

LogSeverity

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning

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

                 {
  kInfo = 0,
  kWarning = 1
};

TypeKind

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

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

              {
  kBool, kInteger, kFloatingPoint, kOther
};

Function Documentation

AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

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

{ return !AlwaysTrue(); }

Here is the call graph for this function:

AlwaysTrue()

GTEST_API_ bool testing::internal::AlwaysTrue

(

)

Here is the caller graph for this function:

AppendUserMessage()

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

ArrayAwareFind()

template<typename Iter, typename Element>

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

Definition at line 983 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 960 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 972 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 964 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 288 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 )

CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr

(

)

CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout

(

)

CaseInsensitiveCStringEquals() [1/2]

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

inline

Definition at line 1090 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 1094 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 1102 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 1392 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
}

CmpHelperEQ() [1/2]

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

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

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

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 1375 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 1631 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 1486 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()

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTRCASENE()

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTREQ() [1/2]

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTREQ() [2/2]

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

Here is the call graph for this function:

CmpHelperSTRNE() [1/2]

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

Here is the call graph for this function:

Here is the caller graph for this function:

CmpHelperSTRNE() [2/2]

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

Here is the call graph for this function:

CodePointToUtf8()

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

(

UInt32

code_point

)

ConvertIdentifierNameToWords()

GTEST_API_ string testing::internal::ConvertIdentifierNameToWords

(

const char *

id_name

)

CopyArray() [1/3]

template<typename T, typename U>

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

inline

Definition at line 1000 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 1012 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 1004 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 283 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;
}

DefaultPrintTo() [1/3]

template<typename C>

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

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

                                                        {
  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/3]

template<typename T>

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

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

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

Here is the call graph for this function:

DefaultPrintTo() [3/3]

template<typename T>

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

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

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

Here is the call graph for this function:

DiffStrings()

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

DoubleNearPredFormat()

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

Here is the call graph for this function:

Here is the caller graph for this function:

DownCast_()

template<typename To, typename From>

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

inline

Definition at line 1367 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:

Here is the caller graph for this function:

EqFailure()

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

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 301 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 string & msg )

inline

Definition at line 294 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 810 of file gmock-matchers.h.

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

FindMaxBipartiteMatching()

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching

(

const MatchMatrix &

g

)

FindPairing()

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

Here is the caller graph for this function:

FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

Definition at line 1276 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 296 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 )

FormatEpochTimeInMillisAsIso8601()

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

(

TimeInMillis

ms

)

FormatFileLocation()

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

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 349 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_ string testing::internal::FormatMatcherDescription	(	bool	negation,
		const char *	matcher_name,
		const Strings &	param_values )

FormatTimeInMillisAsSeconds()

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

(

TimeInMillis

ms

)

GetArgvs()

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

(

)

GetBoolAssertionFailureMessage()

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

GetCapturedStderr()

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

(

)

GetCapturedStdout()

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

(

)

GetCurrentExecutableName()

GTEST_API_ FilePath testing::internal::GetCurrentExecutableName

(

)

GetCurrentOsStackTraceExceptTop()

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

GetElementOr()

template<typename E>

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

inline

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

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

Here is the caller graph for this function:

GetFileSize()

GTEST_API_ size_t testing::internal::GetFileSize

(

FILE *

file

)

GetNextRandomSeed()

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

inline

Definition at line 152 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;
}

GetRandomSeedFromFlag()

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

inline

Definition at line 136 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:

GetRawPointer() [1/2]

template<typename Pointer>

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

inline

Definition at line 76 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 81 of file gmock-internal-utils.h.

{ return p; }

GetTestTypeId()

GTEST_API_ TypeId testing::internal::GetTestTypeId

(

)

GetThreadCount()

GTEST_API_ size_t testing::internal::GetThreadCount

(

)

GetTimeInMillis()

GTEST_API_ TimeInMillis testing::internal::GetTimeInMillis

(

)

Here is the caller graph for this function:

GetTypeId()

template<typename T>

TypeId testing::internal::GetTypeId

(

)

Definition at line 447 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_);
}

GetTypeName()

template<typename T>

std::string testing::internal::GetTypeName

(

)

Definition at line 64 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 name_str;
#  else
  return name;
#  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
 
# else
 
  return "<type>";
 
# endif  // GTEST_HAS_RTTI
}

Here is the caller graph for this function:

GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

Definition at line 927 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:

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_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_IMPL_CMP_HELPER_() [1/5]

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

GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

GT

)

GTEST_IMPL_CMP_HELPER_() [3/5]

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

GTEST_IMPL_CMP_HELPER_() [4/5]

testing::internal::GTEST_IMPL_CMP_HELPER_

(

LT

)

GTEST_IMPL_CMP_HELPER_() [5/5]

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

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

char

)

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

wchar_t

)

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_()

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

ImplicitCast_()

template<typename To>

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

inline

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

{ return x; }

Here is the caller graph for this function:

Int32FromEnvOrDie()

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

Int32FromGTestEnv()

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

Invalid()

template<typename T>

T testing::internal::Invalid ( )

inline

Definition at line 377 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 2254 of file gtest-port.h.

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

IsAlpha()

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

inline

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

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

IsContainerTest() [1/2]

template<class C>

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

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

                                                              {
  return 0;
}

Here is the caller graph for this function:

IsContainerTest() [2/2]

template<class C>

IsNotContainer testing::internal::IsContainerTest

(

long

)

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

{ return '\0'; }

IsDigit()

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

inline

Definition at line 2257 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 2260 of file gtest-port.h.

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

IsNullLiteralHelper() [1/2]

char(& testing::internal::IsNullLiteralHelper

(

...

)

)[2]

IsNullLiteralHelper() [2/2]

char testing::internal::IsNullLiteralHelper

(

Secret *

p

)

IsReadableTypeName()

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

inline

Definition at line 688 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("<(") == string::npos);
}

Here is the caller graph for this function:

IsSpace()

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

inline

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

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

Here is the caller graph for this function:

IsTrue()

GTEST_API_ bool testing::internal::IsTrue

(

bool

condition

)

Here is the caller graph for this function:

IsUpper()

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

inline

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

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

IsXDigit() [1/2]

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

inline

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

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

IsXDigit() [2/2]

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

inline

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

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

Log()

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

Here is the call graph for this function:

LogIsVisible()

GTEST_API_ bool testing::internal::LogIsVisible

(

LogSeverity

severity

)

LogToStderr()

void testing::internal::LogToStderr ( )

inline

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

{}

LogWithLocation()

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

Here is the call graph for this function:

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

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

Here is the caller graph for this function:

MakePredicateFormatterFromMatcher()

template<typename M>

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

inline

Definition at line 1879 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 3612 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 701 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 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 1317 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:

ParseGoogleTestFlagsOnly() [1/2]

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

ParseGoogleTestFlagsOnly() [2/2]

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

Here is the call graph for this function:

ParseInt32()

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

ParseInt32Flag()

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

PrintIfNotEmpty()

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

inline

Definition at line 678 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 548 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()

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

Here is the caller graph for this function:

PrintTo() [1/17]

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

inline

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

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

PrintTo() [2/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [3/17]

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

inline

Definition at line 487 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/17]

template<typename T1, typename T2>

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

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

                                                           {
  *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/17]

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

inline

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

                                                        {
  PrintStringTo(s, os);
}

Here is the call graph for this function:

PrintTo() [6/17]

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

PrintTo() [7/17]

template<typename T>

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

Definition at line 964 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() [8/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [9/17]

template<typename T>

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

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

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

Here is the call graph for this function:

PrintTo() [10/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [11/17]

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

PrintTo() [12/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [13/17]

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

PrintTo() [14/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [15/17]

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

PrintTo() [16/17]

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

inline

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

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

Here is the call graph for this function:

PrintTo() [17/17]

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

ReadEntireFile()

GTEST_API_ std::string testing::internal::ReadEntireFile

(

FILE *

file

)

ReportFailureInUnknownLocation()

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReportUninterestingCall()

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

Here is the call graph for this function:

Here is the caller graph for this function:

ShouldRunTestOnShard()

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

ShouldShard()

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

ShouldUseColor()

GTEST_API_ bool testing::internal::ShouldUseColor

(

bool

stdout_is_tty

)

Shuffle()

template<typename E>

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

inline

Definition at line 333 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 312 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()

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

StreamableToString()

template<typename T>

std::string testing::internal::StreamableToString

(

const T &

streamable

)

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

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

StringFromGTestEnv()

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

StringStreamToString()

GTEST_API_ std::string testing::internal::StringStreamToString

(

::std::stringstream *

stream

)

Here is the caller graph for this function:

StripTrailingSpaces()

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

inline

Definition at line 2284 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:

TempDir()

GTEST_API_ std::string testing::internal::TempDir

(

)

ToLower()

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

inline

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

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

ToUpper()

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

inline

Definition at line 2280 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 853 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 796 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 852 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/3]

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

UniversalPrintArray() [2/3]

template<typename T>

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

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

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

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

UniversalTersePrint()

template<typename T>

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

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

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

Here is the call graph for this function:

WideStringToUtf8()

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

WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded

(

)

Variable Documentation

bool_constant< bool_value >::value

template<bool bool_value>

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

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

g_gmock_implicit_sequence

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

extern

g_help_flag

GTEST_API_ bool testing::internal::g_help_flag

extern

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

GTEST_ATTRIBUTE_UNUSED_

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

ImplicitlyConvertible< From, To >::value

template<typename From, typename To>

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

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

kAlsoRunDisabledTestsFlag

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

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

kBreakOnFailureFlag

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

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

kCatchExceptionsFlag

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

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

kColorFlag

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

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

kDeathTestStyleFlag

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

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

kDeathTestUseFork

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

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

kErrorVerbosity

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

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

kFilterFlag

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

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

kFlagfileFlag

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

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

kInfoVerbosity

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

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

kInternalRunDeathTestFlag

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

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

kListTestsFlag

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

Definition at line 94 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 2439 of file gtest-port.h.

kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

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

kOutputFlag

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

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

kPrintTimeFlag

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

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

kRandomSeedFlag

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

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

kRepeatFlag

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

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

kShuffleFlag

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

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

kStackTraceDepthFlag

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

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

kStackTraceMarker

GTEST_API_ const char testing::internal::kStackTraceMarker

extern

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

kStreamResultToFlag

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

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

kTestTypeIdInGoogleTest

GTEST_API_ const TypeId testing::internal::kTestTypeIdInGoogleTest

extern

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

kThrowOnFailureFlag

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

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

kWarningVerbosity

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

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

TypeIdHelper< T >::dummy_

template<typename T>

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

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