Namespaces
	posix

Classes
class	ActionAdaptor

class	ActionHelper

class	ActionResultHolder

class	ActionResultHolder< void >

struct	AddReference

struct	AddReference< T & >

class	AnyMatcherImpl

class	AnythingMatcher

class	ArgsMatcher

class	ArgsMatcherImpl

class	AssertHelper

class	AssignAction

struct	bool_constant

class	BothOfMatcher

class	BothOfMatcherImpl

class	BuiltInDefaultValue

class	BuiltInDefaultValue< const T >

class	BuiltInDefaultValue< T * >

class	CallableHelper

struct	CallableTraits

struct	CallableTraits< ResType(*)(ArgType)>

struct	CompileAssert

struct	CompileAssertTypesEqual

struct	CompileAssertTypesEqual< T, T >

struct	ConstCharPtr

class	ContainerEqMatcher

class	ContainsMatcher

class	ContainsMatcherImpl

class	DefaultGlobalTestPartResultReporter

class	DefaultPerThreadTestPartResultReporter

class	DoBothAction

class	DoDefaultAction

class	DummyMatchResultListener

class	EachMatcher

class	EachMatcherImpl

class	EitherOfMatcher

class	EitherOfMatcherImpl

class	ElementsAreArrayMatcher

class	ElementsAreMatcher0

class	ElementsAreMatcher1

class	ElementsAreMatcher10

class	ElementsAreMatcher2

class	ElementsAreMatcher3

class	ElementsAreMatcher4

class	ElementsAreMatcher5

class	ElementsAreMatcher6

class	ElementsAreMatcher7

class	ElementsAreMatcher8

class	ElementsAreMatcher9

class	ElementsAreMatcherImpl

struct	EnableIf

struct	EnableIf< true >

class	EndsWithMatcher

class	EqHelper

class	EqHelper< true >

struct	ExcessiveArg

class	ExpectationBase

class	FieldMatcher

class	FilePath

class	FloatingEqMatcher

class	FloatingPoint

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	GoogleTestFailureReporter

class	GTestFlagSaver

class	GTestLog

class	GTestMutexLock

class	HasNewFatalFailureHelper

class	HasSubstrMatcher

class	IgnoredValue

class	IgnoreResultAction

class	ImplicitlyConvertible

class	InvokeAction

class	InvokeHelper

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

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

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

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

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

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

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

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

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

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

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

class	InvokeMethodAction

class	InvokeMethodWithoutArgsAction

class	InvokeWithoutArgsAction

struct	is_pointer

struct	is_pointer< T * >

struct	is_reference

struct	is_reference< T & >

struct	IsAProtocolMessage

class	IsNullMatcher

struct	IteratorTraits

struct	IteratorTraits< const T * >

struct	IteratorTraits< T * >

class	KeyMatcher

class	KeyMatcherImpl

struct	KindOf

class	linked_ptr

class	linked_ptr_internal

struct	LinkedPtrLessThan

struct	LosslessArithmeticConvertibleImpl

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To >

class	MatcherAsPredicate

class	MatcherBase

class	MatcherCastImpl

class	MatcherCastImpl< T, Matcher< T > >

class	MatcherCastImpl< T, Matcher< U > >

struct	MatcherTuple

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

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

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

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

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

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

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

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

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

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

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

class	MatchesRegexMatcher

class	MockSpec

class	Mutex

class	NativeArray

class	NotMatcher

class	NotMatcherImpl

class	NotNullMatcher

class	OnCallSpec

class	OsStackTraceGetter

class	OsStackTraceGetterInterface

class	PairMatcher

class	PairMatcherImpl

class	PointeeMatcher

struct	PointeeOf

struct	PointeeOf< T * >

class	PointwiseMatcher

class	PredicateFormatterFromMatcher

class	PrettyUnitTestResultPrinter

class	PropertyMatcher

class	QuantifierMatcherImpl

class	Random

class	RE

class	ReferenceWrapper

class	RefMatcher

class	RefMatcher< T & >

struct	remove_reference

struct	remove_reference< T & >

struct	RemoveConst

struct	RemoveConst< const T >

struct	RemoveReference

struct	RemoveReference< T & >

class	ResultOfMatcher

class	ReturnAction

class	ReturnNullAction

class	ReturnRefAction

class	ReturnRefOfCopyAction

class	ReturnVoidAction

class	scoped_ptr

class	ScopedTrace

class	SelectArgs

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

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

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

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

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

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

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

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

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

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

class	SetArgumentPointeeAction

class	SetArgumentPointeeAction< N, Proto, true >

class	SetErrnoAndReturnAction

class	SingleFailureChecker

class	StartsWithMatcher

struct	StaticAssertTypeEqHelper

struct	StaticAssertTypeEqHelper< T, T >

class	StlContainerView

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

class	StlContainerView< Element[N]>

class	StreamMatchResultListener

class	StrEqualityMatcher

class	String

class	StringMatchResultListener

class	TestCaseNameIs

class	TestEventRepeater

class	TestFactoryBase

class	TestFactoryImpl

class	TestPropertyKeyIs

class	TestResultAccessor

class	ThreadLocal

struct	TraceInfo

class	TrulyMatcher

class	TupleFields

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

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

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

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

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

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

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

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

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

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

class	TuplePrefix

class	TuplePrefix< 0 >

struct	type_equals

struct	type_equals< T, T >

class	TypedExpectation

class	TypeIdHelper

class	TypeWithSize

class	TypeWithSize< 4 >

class	TypeWithSize< 8 >

class	UnitTestImpl

class	UnitTestOptions

class	UniversalPrinter

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

class	UntypedActionResultHolderBase

class	UntypedFunctionMockerBase

class	UntypedOnCallSpecBase

class	WithArgsAction

class	XmlUnitTestResultPrinter

Typedefs
typedef long long	BiggestInt

typedef FloatingPoint< double >	Double

typedef bool_constant< false >	false_type

typedef FloatingPoint< float >	Float

typedef TypeWithSize< 4 >::Int	Int32

typedef TypeWithSize< 8 >::Int	Int64

typedef int	IsContainer

typedef char	IsNotContainer

typedef GTestMutexLock	MutexLock

typedef void(*	SetUpTestCaseFunc) ()

typedef ::std::string	string

typedef void(*	TearDownTestCaseFunc) ()

typedef TypeWithSize< 8 >::Int	TimeInMillis

typedef bool_constant< true >	true_type

typedef const void *	TypeId

typedef TypeWithSize< 4 >::UInt	UInt32

typedef TypeWithSize< 8 >::UInt	UInt64

typedef ::std::wstring	wstring

Enumerations
enum	CallReaction { ALLOW, WARN, FAIL }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape }

enum	GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	LogSeverity { INFO = 0, WARNING = 1 }

enum	RelationToSource { kReference, kCopy }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther }

Functions
bool	AlwaysFalse ()

GTEST_API_ bool	AlwaysTrue ()

GTEST_API_ String	AppendUserMessage (const String &gtest_msg, const Message &user_msg)

template<typename Iter , typename Element >
Iter	ArrayAwareFind (Iter begin, Iter end, const Element &elem)

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 From , typename To >
void	Assert (bool condition, const char *file, int line)

bool	BoolFromGTestEnv (const char *flag, bool default_val)

GTEST_API_ void	CaptureStderr ()

GTEST_API_ void	CaptureStdout ()

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<class Derived , class Base >
Derived *	CheckedDowncastToActualType (Base *base)

UInt32	ChopLowBits (UInt32 *bits, int n)

static char *	CloneString (const char *str, size_t length)

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

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

template<typename RawType >
AssertionResult	CmpHelperFloatingPointEQ (const char expected_expression, const char actual_expression, RawType expected, RawType actual)

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

GTEST_API_ AssertionResult	CmpHelperSTRCASENE (const char s1_expression, const char s2_expression, const char s1, const char s2)

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

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

GTEST_API_ AssertionResult	CmpHelperSTRNE (const char s1_expression, const char s2_expression, const char s1, const char s2)

GTEST_API_ AssertionResult	CmpHelperSTRNE (const char s1_expression, const char s2_expression, const wchar_t s1, const wchar_t s2)

GTEST_API_ char *	CodePointToUtf8 (UInt32 code_point, char *str)

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

string	ConvertIdentifierNameToWords (const char *id_name)

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

template<class Container , typename Predicate >
int	CountIf (const Container &c, Predicate predicate)

UInt32	CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)

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 >
static void	Delete (T *x)

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

template<typename To , typename From >
To	DownCast_ (From *f)

GTEST_API_ AssertionResult	EqFailure (const char expected_expression, const char actual_expression, const String &expected_value, const String &actual_value, bool ignoring_case)

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

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

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

static String	FlagToEnvVar (const char *flag)

template<typename RawType >
AssertionResult	FloatingPointLE (const char expr1, const char expr2, RawType val1, RawType val2)

void	FlushInfoLog ()

template<class Container , typename Functor >
void	ForEach (const Container &c, Functor functor)

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

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

template<typename T1 , typename T2 >
String	FormatForComparisonFailureMessage (const T1 &value, const T2 &)

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

GTEST_API_ std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)

const char *	GetAnsiColorCode (GTestColor color)

GTEST_API_ String	GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char expression_text, const char actual_predicate_value, const char *expected_predicate_value)

GTEST_API_ String	GetCapturedStderr ()

GTEST_API_ String	GetCapturedStdout ()

GTEST_API_ FilePath	GetCurrentExecutableName ()

GTEST_API_ String	GetCurrentOsStackTraceExceptTop (UnitTest *unit_test, int skip_count)

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

FailureReporterInterface *	GetFailureReporter ()

int	GetNextRandomSeed (int seed)

int	GetRandomSeedFromFlag (Int32 random_seed_flag)

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

template<typename Element >
Element *	GetRawPointer (Element *p)

GTEST_API_ TypeId	GetTestTypeId ()

GTEST_API_ size_t	GetThreadCount ()

GTEST_API_ TimeInMillis	GetTimeInMillis ()

template<typename T >
TypeId	GetTypeId ()

template<typename T >
String	GetTypeName ()

class UnitTestImpl *	GetUnitTestImpl ()

	GMOCK_DECLARE_KIND_ (bool, kBool)

	GMOCK_DECLARE_KIND_ (char, kInteger)

	GMOCK_DECLARE_KIND_ (signed char, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)

	GMOCK_DECLARE_KIND_ (short, kInteger)

	GMOCK_DECLARE_KIND_ (int, kInteger)

	GMOCK_DECLARE_KIND_ (long, kInteger)

	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)

	GMOCK_DECLARE_KIND_ (Int64, kInteger)

	GMOCK_DECLARE_KIND_ (UInt64, kInteger)

	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)

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

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (UInt64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (Int64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)

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

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

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

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

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

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

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

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

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

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

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

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

GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_linked_ptr_mutex)

	GTEST_DECLARE_STATIC_MUTEX_ (g_gmock_mutex)

	GTEST_DECLARE_string_ (internal_run_death_test)

	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)

	GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)

	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 ""colons. 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_ (NE,!=)

	GTEST_IMPL_CMP_HELPER_ (LE,<=)

	GTEST_IMPL_CMP_HELPER_ (LT,< )

	GTEST_IMPL_CMP_HELPER_ (GE, >=)

	GTEST_IMPL_CMP_HELPER_ (GT, >)

static bool	GTestIsInitialized ()

template<class T , typename Result >
Result	HandleExceptionsInMethodIfSupported (T object, Result(T::method)(), const char *location)

template<class T , typename Result >
Result	HandleSehExceptionsInMethodIfSupported (T object, Result(T::method)(), const char *location)

static bool	HasGoogleTestFlagPrefix (const char *str)

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

template<typename To >
To	ImplicitCast_ (To x)

template<typename CharType >
void	InitGoogleMockImpl (int argc, CharType *argv)

template<typename CharType >
void	InitGoogleTestImpl (int argc, CharType *argv)

GTEST_API_ Int32	Int32FromEnvOrDie (const char *env_var, Int32 default_val)

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

template<typename T >
T	Invalid ()

template<>
void	Invalid< void > ()

bool	IsAlNum (char ch)

bool	IsAlpha (char ch)

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

template<class C >
IsNotContainer	IsContainerTest (long)

bool	IsDigit (char ch)

bool	IsLower (char ch)

char	IsNullLiteralHelper (Secret *p)

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

static bool	IsPathSeparator (char c)

bool	IsPrintableAscii (wchar_t c)

bool	IsReadableTypeName (const string &type_name)

bool	IsSpace (char ch)

GTEST_API_ bool	IsTrue (bool condition)

bool	IsUpper (char ch)

bool	IsUtf16SurrogatePair (wchar_t first, wchar_t second)

bool	IsXDigit (char ch)

string	JoinAsTuple (const Strings &fields)

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

bool	LogIsVisible (LogSeverity severity)

void	LogToStderr ()

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

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

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

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

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

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

inline::std::ostream &	operator<< (::std::ostream &os, const String &str)

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

bool	ParseBoolFlag (const char str, const char flag, bool *value)

const char *	ParseFlagValue (const char str, const char flag, bool def_optional)

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

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

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

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, char *argv)

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, wchar_t *argv)

template<typename CharType >
void	ParseGoogleTestFlagsOnlyImpl (int argc, CharType *argv)

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

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

bool	ParseStringFlag (const char str, const char flag, String *value)

template<typename UnsignedChar , typename Char >
static CharFormat	PrintAsCharLiteralTo (Char c, ostream *os)

static CharFormat	PrintAsNarrowStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsWideStringLiteralTo (wchar_t c, ostream *os)

template<typename UnsignedChar , typename Char >
void	PrintCharAndCodeTo (Char c, ostream *os)

static void	PrintCharsAsStringTo (const char begin, size_t len, ostream os)

static void	PrintColorEncoded (const char *str)

void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

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

template<typename T >
void	PrintRawArrayTo (const T a[], size_t count,::std::ostream *os)

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

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

void	PrintTo (wchar_t wc, ostream *os)

void	PrintTo (const char s, ostream os)

void	PrintTo (const wchar_t s, 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)

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	PrintTo (const ReferenceWrapper< T > &ref,::std::ostream *os)

static void	PrintWideCharsAsStringTo (const wchar_t begin, size_t len, ostream os)

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

void	ReportUninterestingCall (CallReaction reaction, const string &msg)

static void	SetUpEnvironment (Environment *env)

static bool	ShouldRunTestCase (const TestCase *test_case)

GTEST_API_ bool	ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)

GTEST_API_ bool	ShouldShard (const char total_shards_str, const char shard_index_str, bool in_subprocess_for_death_test)

GTEST_API_ bool	ShouldUseColor (bool stdout_is_tty)

template<typename E >
void	Shuffle (internal::Random random, std::vector< E > v)

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

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

template<typename T >
String	StreamableToString (const T &streamable)

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

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

static int	SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)

static void	TearDownEnvironment (Environment *env)

static bool	TestCaseFailed (const TestCase *test_case)

static bool	TestCasePassed (const TestCase *test_case)

char	ToLower (char ch)

char	ToUpper (char ch)

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

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

void	UniversalPrintArray (const char begin, size_t len, 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)

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

void	UniversalTersePrint (const char str,::std::ostream os)

void	UniversalTersePrint (char str,::std::ostream os)

GTEST_API_ String	WideStringToUtf8 (const wchar_t *str, int num_chars)

void	WriteToShardStatusFileIfNeeded ()

Variables
String	g_executable_path

ThreadLocal< Sequence * >	g_gmock_implicit_sequence

GTEST_API_ bool	g_help_flag = false

int	g_init_gtest_count = 0

class GTEST_API_ testing::internal::ScopedTrace	GTEST_ATTRIBUTE_UNUSED_

const char	kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"

const char	kBreakOnFailureFlag [] = "break_on_failure"

const char	kCatchExceptionsFlag [] = "catch_exceptions"

static const char	kColorEncodedHelpMessage []

const char	kColorFlag [] = "color"

const char	kCurrentDirectoryString [] = "./"

const char	kDeathTestStyleFlag [] = "death_test_style"

const char	kDeathTestUseFork [] = "death_test_use_fork"

const char	kErrorVerbosity [] = "error"

const char	kFilterFlag [] = "filter"

const char	kInfoVerbosity [] = "info"

const char	kInternalRunDeathTestFlag [] = "internal_run_death_test"

const char	kListTestsFlag [] = "list_tests"

const BiggestInt	kMaxBiggestInt

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	kMaxRandomSeed = 99999

const char	kOutputFlag [] = "output"

const char	kPathSeparator = '/'

const char	kPathSeparatorString [] = "/"

const char	kPrintTimeFlag [] = "print_time"

const char	kRandomSeedFlag [] = "random_seed"

const char	kRepeatFlag [] = "repeat"

const char	kShuffleFlag [] = "shuffle"

const char	kStackTraceDepthFlag [] = "stack_trace_depth"

GTEST_API_ const char	kStackTraceMarker [] = "\nStack trace:\n"

const int	kStdErrFileno = STDERR_FILENO

const int	kStdOutFileno = STDOUT_FILENO

const char	kStreamResultToFlag [] = "stream_result_to"

GTEST_API_ const TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()

const char	kThrowOnFailureFlag [] = "throw_on_failure"

const char	kUnknownFile [] = "unknown file"

const char	kWarningVerbosity [] = "warning"

Typedef Documentation

typedef long long testing::internal::BiggestInt

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

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

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

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

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

typedef int testing::internal::IsContainer

typedef char testing::internal::IsNotContainer

typedef GTestMutexLock testing::internal::MutexLock

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

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

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

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

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

typedef const void* testing::internal::TypeId

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

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

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

Enumeration Type Documentation

enum testing::internal::CallReaction

Enumerator
ALLOW
WARN
FAIL

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

enum testing::internal::LogSeverity

Enumerator
INFO
WARNING

enum testing::internal::RelationToSource

Enumerator
kReference
kCopy

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

Function Documentation

bool testing::internal::AlwaysFalse ( )

inline

bool testing::internal::AlwaysTrue ( )

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

template<typename Iter , typename Element >

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

template<typename T , typename U >

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

template<typename T , typename U >

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

inline

template<typename T , typename U , size_t N>

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

inline

template<typename From , typename To >

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

inline

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

GTEST_API_ void testing::internal::CaptureStderr ( )

GTEST_API_ void testing::internal::CaptureStdout ( )

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

inline

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

inline

template<typename StringType >

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

template<class Derived , class Base >

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

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

inline

static char* testing::internal::CloneString	(	const char *	str,
		size_t	length
	)

static

template<typename T1 , typename T2 >

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

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

template<typename RawType >

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

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

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

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

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

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

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

char * testing::internal::CodePointToUtf8	(	UInt32	code_point,
		char *	str
	)

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

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

template<typename T , typename U >

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

template<typename T , typename U >

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

inline

template<typename T , typename U , size_t N>

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

inline

template<class Container , typename Predicate >

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

inline

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

inline

template<typename C >

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

template<typename T >

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

template<typename T >

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

template<typename T >

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

static

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

template<typename To , typename From >

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

inline

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

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

inline

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

inline

template<typename MatcherTuple , typename ValueTuple >

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

static String testing::internal::FlagToEnvVar ( const char * flag )

static

template<typename RawType >

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

void testing::internal::FlushInfoLog ( )

inline

template<class Container , typename Functor >

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

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

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

template<typename T1 , typename T2 >

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

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

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

const char* testing::internal::GetAnsiColorCode ( GTestColor color )

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

GTEST_API_ String testing::internal::GetCapturedStderr ( )

GTEST_API_ String testing::internal::GetCapturedStdout ( )

FilePath testing::internal::GetCurrentExecutableName ( )

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

template<typename E >

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

inline

FailureReporterInterface* testing::internal::GetFailureReporter ( )

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

inline

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

inline

template<typename Pointer >

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

inline

template<typename Element >

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

inline

TypeId testing::internal::GetTestTypeId ( )

size_t testing::internal::GetThreadCount ( )

TimeInMillis testing::internal::GetTimeInMillis ( )

template<typename T >

TypeId testing::internal::GetTypeId ( )

template<typename T >

String testing::internal::GetTypeName ( )

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

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

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

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

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

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

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

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

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

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

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

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

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

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

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ ( void )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ ( Lt )

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

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

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

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

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

testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ ( Lt )

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

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_linked_ptr_mutex )

testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_gmock_mutex )

testing::internal::GTEST_DECLARE_string_ ( internal_run_death_test )

testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_gmock_mutex )

static testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_log_mutex )

static

testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_linked_ptr_mutex )

testing::internal::GTEST_DEFINE_string_	(	internal_run_death_test	,
		""	,
		"Indicates the	file,
		line	number,
		temporal index of""the single death test to	run,
		and a file descriptor to""which a success code may be	sent,
		all separated by""colons.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."
	)

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

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

testing::internal::GTEST_IMPL_CMP_HELPER_ ( LT )

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

testing::internal::GTEST_IMPL_CMP_HELPER_ ( GT )

static bool testing::internal::GTestIsInitialized ( )

static

template<class T , typename Result >

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

template<class T , typename Result >

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

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

static

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

template<typename To >

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

inline

template<typename CharType >

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

template<typename CharType >

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

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

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

template<typename T >

T testing::internal::Invalid ( )

inline

template<>

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

inline

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

inline

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

inline

template<class C >

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

template<class C >

IsNotContainer testing::internal::IsContainerTest ( long )

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

inline

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

inline

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

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

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

static

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

inline

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

inline

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

inline

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

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

inline

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

inline

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

inline

string testing::internal::JoinAsTuple ( const Strings & fields )

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

bool testing::internal::LogIsVisible ( LogSeverity severity )

void testing::internal::LogToStderr ( )

inline

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

template<typename T >

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

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

template<typename M >

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

inline

template<typename Value , typename T >

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

template<typename T >

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

inline

inline ::std::ostream& testing::internal::operator<<	(	::std::ostream &	os,
		const String &	str
	)

template<typename T >

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

inline

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

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

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

static

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

static

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

static

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

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

template<typename CharType >

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

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

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

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

template<typename UnsignedChar , typename Char >

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

static

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

static

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

static

template<typename UnsignedChar , typename Char >

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

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

static

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

static

void testing::internal::PrintFullTestCommentIfPresent ( const TestInfo & test_info )

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

inline

template<typename T >

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

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

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

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

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

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

template<typename T >

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

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

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

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

inline

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

inline

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

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

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

inline

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

inline

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

inline

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

inline

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

inline

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

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

inline

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

inline

template<typename T1 , typename T2 >

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

template<typename T >

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

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

static

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

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

static void testing::internal::SetUpEnvironment ( Environment * env )

static

static bool testing::internal::ShouldRunTestCase ( const TestCase * test_case )

static

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

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

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

template<typename E >

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

inline

template<typename E >

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

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

template<typename T >

String testing::internal::StreamableToString ( const T & streamable )

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

String testing::internal::StringStreamToString ( ::std::stringstream * stream )

static int testing::internal::SumOverTestCaseList	(	const std::vector< TestCase * > &	case_list,
		int(TestCase::*)() const	method
	)

static

static void testing::internal::TearDownEnvironment ( Environment * env )

static

static bool testing::internal::TestCaseFailed ( const TestCase * test_case )

static

static bool testing::internal::TestCasePassed ( const TestCase * test_case )

static

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

inline

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

inline

template<typename MatcherTuple , typename ValueTuple >

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

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

void testing::internal::UniversalTersePrint	(	const char *	str,
		::std::ostream *	os
	)

inline

void testing::internal::UniversalTersePrint	(	char *	str,
		::std::ostream *	os
	)

inline

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

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Variable Documentation

String testing::internal::g_executable_path

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

bool testing::internal::g_help_flag = false

int testing::internal::g_init_gtest_count = 0

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

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

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

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

const char testing::internal::kColorEncodedHelpMessage[]

static

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

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

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

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

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

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

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

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

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

const BiggestInt testing::internal::kMaxBiggestInt

Initial value:

=

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

testing::internal::BiggestInt

long long BiggestInt

Definition: gtest-port.h:1501

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

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

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

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

const int testing::internal::kMaxRandomSeed = 99999

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

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

const char testing::internal::kPathSeparatorString[] = "/"

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

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

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

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

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

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

const int testing::internal::kStdErrFileno = STDERR_FILENO

const int testing::internal::kStdOutFileno = STDOUT_FILENO

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

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

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

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

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation