Namespaces
	edit_distance

	posix

Classes
struct	AddReference

struct	AddReference< T & >

class	AssertHelper

class	Base

struct	bool_constant

class	Castable

struct	CodeLocation

struct	CompileAssert

struct	CompileAssertTypesEqual

struct	CompileAssertTypesEqual< T, T >

class	ConstAndNonConstCastable

class	ConstCastable

struct	ConstCharPtr

class	DefaultGlobalTestPartResultReporter

class	DefaultPerThreadTestPartResultReporter

class	Derived

struct	EnableIf

struct	EnableIf< true >

class	EnvironmentInvocationCatcher

class	EqHelper

class	EqHelper< true >

class	EventRecordingListener

class	FilePath

class	FinalSuccessChecker

class	FloatingPoint

class	FormatForComparison

class	FormatForComparison< ToPrint[N], OtherOperand >

class	GTestFlagSaver

class	GTestLog

class	GTestMutexLock

class	HasNewFatalFailureHelper

class	ImplicitlyConvertible

struct	is_pointer

struct	is_pointer< T * >

struct	IsAProtocolMessage

struct	IteratorTraits

struct	IteratorTraits< const T * >

struct	IteratorTraits< T * >

struct	LessByName

class	linked_ptr

class	linked_ptr_internal

class	ListenerTest

class	Mutex

class	NativeArray

class	NoDefaultContructor

class	OsStackTraceGetter

class	OsStackTraceGetterInterface

class	PrettyUnitTestResultPrinter

class	Random

class	RE

struct	RelationToSourceCopy

struct	RelationToSourceReference

struct	RemoveConst

struct	RemoveConst< const T >

struct	RemoveConst< const T[N]>

struct	RemoveReference

struct	RemoveReference< T & >

class	scoped_ptr

class	ScopedPrematureExitFile

class	ScopedTrace

class	SingleFailureChecker

struct	StaticAssertTypeEqHelper

struct	StaticAssertTypeEqHelper< T, T >

class	String

class	TestCaseNameIs

class	TestEventListenersAccessor

class	TestEventRepeater

class	TestFactoryBase

class	TestFactoryImpl

class	TestPropertyKeyIs

class	TestResultAccessor

class	ThreadLocal

class	To

struct	TraceInfo

struct	TuplePolicy

class	TypeIdHelper

class	TypeWithSize

class	TypeWithSize< 4 >

class	TypeWithSize< 8 >

class	UnitTestHelper

class	UnitTestImpl

class	UnitTestOptions

class	UnitTestRecordPropertyTestHelper

class	UniversalPrinter

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

class	UniversalTersePrinter

class	UniversalTersePrinter< char * >

class	UniversalTersePrinter< const char * >

class	UniversalTersePrinter< T & >

class	UniversalTersePrinter< T[N]>

class	UniversalTersePrinter< wchar_t * >

class	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 ::std::vector< string >	Strings

typedef void(*	TearDownTestCaseFunc) ()

typedef TypeWithSize< 8 >::Int	TimeInMillis

typedef bool_constant< true >	true_type

typedef TypeWithSize< 4 >::UInt	UInt32

typedef TypeWithSize< 8 >::UInt	UInt64

typedef ::std::wstring	wstring

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

Functions
bool	AlwaysFalse ()

GTEST_API_ bool	AlwaysTrue ()

GTEST_API_ std::string	AppendUserMessage (const std::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, const U &rhs)

template<typename T , typename U >
bool	ArrayEq (const T lhs, size_t size, const U rhs)

template<typename T , typename U , size_t N>
bool	ArrayEq (const T(&lhs)[N], const U(&rhs)[N])

bool	BoolFromGTestEnv (const char *flag, bool default_val)

GTEST_API_ void	CaptureStderr ()

GTEST_API_ void	CaptureStdout ()

template<class Derived , class Base >
Derived *	CheckedDowncastToActualType (Base *base)

UInt32	ChopLowBits (UInt32 *bits, int n)

GTEST_API_ AssertionResult	CmpHelperEQ (const char lhs_expression, const char rhs_expression, BiggestInt lhs, BiggestInt rhs)

template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQ (const char lhs_expression, const char rhs_expression, const T1 &lhs, const T2 &rhs)

template<typename T1 , typename T2 >
AssertionResult	CmpHelperEQFailure (const char lhs_expression, const char rhs_expression, const T1 &lhs, const T2 &rhs)

template<typename RawType >
AssertionResult	CmpHelperFloatingPointEQ (const char lhs_expression, const char rhs_expression, RawType lhs_value, RawType rhs_value)

template<typename T1 , typename T2 >
AssertionResult	CmpHelperOpFailure (const char expr1, const char expr2, const T1 &val1, const T2 &val2, const char *op)

GTEST_API_ AssertionResult	CmpHelperSTRCASEEQ (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 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 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_ std::string	CodePointToUtf8 (UInt32 code_point)

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

template<typename T , typename U >
void	CopyArray (const T &from, U *to)

template<typename T , typename U >
void	CopyArray (const T from, size_t size, 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, false_type, const T &value, ::std::ostream *os)

template<typename T >
void	DefaultPrintTo (IsNotContainer, true_type, T p, ::std::ostream os)

template<typename T >
static void	Delete (T *x)

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

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 std::string &expected_value, const std::string &actual_value, bool ignoring_case)

static std::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	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)

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

template<typename T1 , typename T2 >
std::string	FormatForComparisonFailureMessage (const T1 &value, const T2 &)

GTEST_API_ std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)

const char *	GetAnsiColorCode (GTestColor color)

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

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

GTEST_API_ std::string	GetCapturedStderr ()

GTEST_API_ std::string	GetCapturedStdout ()

GTEST_API_ FilePath	GetCurrentExecutableName ()

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

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

GTEST_API_ size_t	GetFileSize (FILE *file)

int	GetNextRandomSeed (int seed)

int	GetRandomSeedFromFlag (Int32 random_seed_flag)

GTEST_API_ TypeId	GetTestTypeId ()

GTEST_API_ size_t	GetThreadCount ()

GTEST_API_ TimeInMillis	GetTimeInMillis ()

template<typename T >
TypeId	GetTypeId ()

template<typename T >
std::string	GetTypeName ()

class UnitTestImpl *	GetUnitTestImpl ()

GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_linked_ptr_mutex)

	GTEST_DECLARE_string_ (internal_run_death_test)

GTEST_API_	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 " "the '\|' characters. This flag is specified if and only if the current " "process is a sub-process launched for running a thread-safe " "death test. FOR INTERNAL USE ONLY.")

	GTEST_IMPL_CMP_HELPER_ (GE, >=)

	GTEST_IMPL_CMP_HELPER_ (GT, >)

	GTEST_IMPL_CMP_HELPER_ (LE,<=)

	GTEST_IMPL_CMP_HELPER_ (LT,<)

	GTEST_IMPL_CMP_HELPER_ (NE, !=)

	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)

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

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)

AssertionResult	IsNull (const char *str)

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

char	IsNullLiteralHelper (Secret *p)

static bool	IsPathSeparator (char c)

bool	IsPrintableAscii (wchar_t c)

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)

bool	IsXDigit (wchar_t ch)

void	LogToStderr ()

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, CodeLocation code_location, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)

template<typename T >
const T &	move (const T &t)

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

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)

bool	ParseGoogleTestFlag (const char *const arg)

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, std::string *value)

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

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

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

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

template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	PrintCharsAsStringTo (const CharType begin, size_t len, ostream os)

static void	PrintColorEncoded (const char *str)

void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

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

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	PrintStringTo (const ::std::string &s, ostream *os)

static void	PrintTestPartResult (const TestPartResult &test_part_result)

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

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

void	PrintTo (char s, ::std::ostream os)

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

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

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

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

void	PrintTo (const char s, ostream os)

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

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

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

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

void	PrintTo (const wchar_t s, ostream os)

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

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

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

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

void	PrintTo (wchar_t s, ::std::ostream os)

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

void	PrintTo (wchar_t wc, ostream *os)

GTEST_API_ std::string	ReadEntireFile (FILE *file)

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

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)

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

template<typename T >
std::string	StreamableToString (const T &streamable)

std::string	StringFromGTestEnv (const char flag, const char default_val)

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

std::string	StripTrailingSpaces (std::string str)

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

static void	TearDownEnvironment (Environment *env)

GTEST_API_ std::string	TempDir ()

	TEST (ApiTest, DISABLED_Dummy1)

	TEST (ApiTest, TestCaseDisabledAccessorsWork)

	TEST (ApiTest, TestCaseImmutableAccessorsWork)

	TEST (ApiTest, UnitTestImmutableAccessorsWork)

	TEST (CaptureDeathTest, CannotReenterStdoutCapture)

	TEST (CaptureTest, CapturesStderr)

	TEST (CaptureTest, CapturesStdout)

	TEST (CaptureTest, CapturesStdoutAndStderr)

	TEST (DISABLED_Test, Dummy2)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsFileLocation)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFile)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownLine)

	TEST (FormatFileLocationTest, FormatsFileLocation)

	TEST (FormatFileLocationTest, FormatsUknownFileAndLine)

	TEST (FormatFileLocationTest, FormatsUknownLine)

	TEST (FormatFileLocationTest, FormatsUnknownFile)

	TEST (GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads)

	TEST (GtestCheckDeathTest, DiesWithCorrectOutputOnFailure)

	TEST (GtestCheckSyntaxTest, BehavesLikeASingleStatement)

	TEST (GtestCheckSyntaxTest, WorksWithSwitch)

	TEST (ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately)

	TEST (ImplicitCastTest, CanUseConstCastOperatorOnConstValues)

	TEST (ImplicitCastTest, CanUseImplicitConstructor)

	TEST (ImplicitCastTest, CanUseInheritance)

	TEST (ImplicitCastTest, CanUseNonConstCastOperator)

	TEST (ImplicitCastTest, ConvertsPointers)

	TEST (IsXDigitTest, ReturnsFalseForNarrowNonAscii)

	TEST (IsXDigitTest, ReturnsFalseForWideNonAscii)

	TEST (IsXDigitTest, WorksForNarrowAscii)

	TEST (IsXDigitTest, WorksForWideAscii)

	TEST (IteratorTraitsTest, WorksForPointerToConst)

	TEST (IteratorTraitsTest, WorksForPointerToNonConst)

	TEST (IteratorTraitsTest, WorksForSTLContainerIterators)

	TEST (RegexEngineSelectionTest, SelectsCorrectRegexEngine)

	TEST (ScopedPtrTest, DefinesElementType)

	TEST (ThreadLocalTest, DefaultConstructorInitializesToDefaultValues)

	TEST (ThreadLocalTest, GetAndPointerReturnSameValue)

	TEST (ThreadLocalTest, PointerAndConstPointerReturnSameValue)

	TEST (ThreadLocalTest, SingleParamConstructorInitializesToParam)

	TEST (ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion)

	TEST_F (ListenerTest, DoesBar)

	TEST_F (ListenerTest, DoesFoo)

static bool	TestCaseFailed (const TestCase *test_case)

static bool	TestCasePassed (const TestCase *test_case)

char	ToLower (char ch)

char	ToUpper (char ch)

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

GTEST_API_ void	UniversalPrintArray (const char begin, size_t len, ::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 wchar_t begin, size_t len, ::std::ostream os)

void	UniversalPrintArray (const wchar_t begin, size_t len, ostream os)

template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType begin, size_t len, ostream os)

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

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

void	WriteToShardStatusFileIfNeeded ()

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

GTEST_API_ bool	g_help_flag = false

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	kFilterFlag [] = "filter"

const char	kFlagfileFlag [] = "flagfile"

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	kPrintTimeFlag [] = "print_time"

const char	kRandomSeedFlag [] = "random_seed"

const char	kRepeatFlag [] = "repeat"

const char	kShuffleFlag [] = "shuffle"

const char	kStackTraceDepthFlag [] = "stack_trace_depth"

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

const int	kStdErrFileno = STDERR_FILENO

const int	kStdOutFileno = STDOUT_FILENO

const char	kStreamResultToFlag [] = "stream_result_to"

const GTEST_API_ TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()

const char	kThrowOnFailureFlag [] = "throw_on_failure"

const int	kTypedTestCases = 0

const int	kTypedTests = 0

static const char	kTypeParamLabel [] = "TypeParam"

const char	kUnknownFile [] = "unknown file"

static const char	kValueParamLabel [] = "GetParam()"

const typedef void *	TypeId

Typedef Documentation

◆ BiggestInt

typedef long long testing::internal::BiggestInt

◆ Double

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

◆ false_type

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

◆ Float

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

◆ Int32

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

◆ Int64

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

◆ IsContainer

typedef int testing::internal::IsContainer

◆ IsNotContainer

typedef char testing::internal::IsNotContainer

◆ MutexLock

typedef GTestMutexLock testing::internal::MutexLock

◆ SetUpTestCaseFunc

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

◆ string

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

Examples: /build/assimp-nWsdMC/assimp-5.0.1~ds0/contrib/irrXML/irrXML.h.

◆ Strings

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

◆ TearDownTestCaseFunc

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

◆ TimeInMillis

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

◆ true_type

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

◆ UInt32

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

◆ UInt64

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

◆ wstring

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

Enumeration Type Documentation

◆ CharFormat

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape

◆ GTestColor

enum testing::internal::GTestColor

Enumerator
COLOR_DEFAULT
COLOR_RED
COLOR_GREEN
COLOR_YELLOW

◆ GTestLogSeverity

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

Function Documentation

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

◆ AlwaysTrue()

bool testing::internal::AlwaysTrue ( )

◆ AppendUserMessage()

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
	)

◆ ArrayEq() [1/3]

template<typename T , typename U >

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

inline

◆ ArrayEq() [2/3]

template<typename T , typename U >

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

◆ ArrayEq() [3/3]

template<typename T , typename U , size_t N>

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

inline

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

◆ CheckedDowncastToActualType()

template<class Derived , class Base >

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

◆ ChopLowBits()

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

inline

◆ CmpHelperEQ() [1/2]

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

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

◆ CmpHelperEQFailure()

template<typename T1 , typename T2 >

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

◆ CmpHelperFloatingPointEQ()

template<typename RawType >

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

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

◆ CmpHelperSTRCASEEQ()

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

◆ CmpHelperSTRCASENE()

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

◆ CmpHelperSTREQ() [1/2]

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

◆ CmpHelperSTREQ() [2/2]

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

◆ CmpHelperSTRNE() [1/2]

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

◆ CmpHelperSTRNE() [2/2]

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

◆ CodePointToUtf8()

std::string testing::internal::CodePointToUtf8 ( UInt32 code_point )

◆ ColoredPrintf()

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

◆ CopyArray() [1/3]

template<typename T , typename U >

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

inline

◆ CopyArray() [2/3]

template<typename T , typename U >

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

◆ CopyArray() [3/3]

template<typename T , typename U , size_t N>

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

inline

◆ CountIf()

template<class Container , typename Predicate >

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

inline

◆ CreateCodePointFromUtf16SurrogatePair()

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

inline

◆ DefaultPrintTo() [1/3]

template<typename C >

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

◆ DefaultPrintTo() [2/3]

template<typename T >

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

◆ DefaultPrintTo() [3/3]

template<typename T >

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

◆ Delete()

template<typename T >

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

static

◆ DiffStrings()

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

◆ DoubleNearPredFormat()

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

◆ DownCast_()

template<typename To , typename From >

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

inline

◆ EqFailure()

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

◆ FlagToEnvVar()

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

static

◆ FloatingPointLE()

template<typename RawType >

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

◆ FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

◆ ForEach()

template<class Container , typename Functor >

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

◆ FormatCompilerIndependentFileLocation()

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

◆ FormatEpochTimeInMillisAsIso8601()

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

◆ FormatFileLocation()

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

◆ FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >

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

◆ FormatTimeInMillisAsSeconds()

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

◆ GetAnsiColorCode()

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

◆ GetArgvs()

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

◆ GetBoolAssertionFailureMessage()

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

FilePath testing::internal::GetCurrentExecutableName ( )

◆ GetCurrentOsStackTraceExceptTop()

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

◆ GetFileSize()

size_t testing::internal::GetFileSize ( FILE * file )

◆ GetNextRandomSeed()

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

inline

◆ GetRandomSeedFromFlag()

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

inline

◆ GetTestTypeId()

TypeId testing::internal::GetTestTypeId ( )

◆ GetThreadCount()

size_t testing::internal::GetThreadCount ( )

◆ GetTimeInMillis()

TimeInMillis testing::internal::GetTimeInMillis ( )

◆ GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId ( )

◆ GetTypeName()

template<typename T >

std::string testing::internal::GetTypeName ( )

◆ GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

◆ GTEST_DECLARE_STATIC_MUTEX_()

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_linked_ptr_mutex )

◆ GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_ ( internal_run_death_test )

◆ GTEST_DEFINE_STATIC_MUTEX_()

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_linked_ptr_mutex )

◆ GTEST_DEFINE_string_()

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

◆ GTEST_IMPL_CMP_HELPER_() [1/5]

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

◆ GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( GT )

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

◆ GTestIsInitialized()

static bool testing::internal::GTestIsInitialized ( )

static

◆ HandleExceptionsInMethodIfSupported()

template<class T , typename Result >

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

◆ HandleSehExceptionsInMethodIfSupported()

template<class T , typename Result >

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

◆ HasGoogleTestFlagPrefix()

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

static

◆ HasOneFailure()

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

◆ ImplicitCast_()

template<typename To >

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

inline

◆ InitGoogleTestImpl()

template<typename CharType >

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

◆ Int32FromEnvOrDie()

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

◆ Int32FromGTestEnv()

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

◆ IsAlNum()

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

inline

◆ IsAlpha()

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

inline

◆ IsContainerTest() [1/2]

template<class C >

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

◆ IsContainerTest() [2/2]

template<class C >

IsNotContainer testing::internal::IsContainerTest ( long )

◆ IsDigit()

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

inline

◆ IsLower()

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

inline

◆ IsNull()

AssertionResult testing::internal::IsNull ( const char * str )

◆ IsNullLiteralHelper() [1/2]

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

◆ IsNullLiteralHelper() [2/2]

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

◆ IsPathSeparator()

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

static

◆ IsPrintableAscii()

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

inline

◆ IsSpace()

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

inline

◆ IsTrue()

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

◆ IsUpper()

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

inline

◆ IsUtf16SurrogatePair()

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

inline

◆ IsXDigit() [1/2]

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

inline

◆ IsXDigit() [2/2]

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

inline

◆ LogToStderr()

void testing::internal::LogToStderr ( )

inline

◆ make_linked_ptr()

template<typename T >

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

◆ MakeAndRegisterTestInfo()

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

◆ move()

template<typename T >

const T& testing::internal::move ( const T & t )

◆ operator!=()

template<typename T >

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

inline

◆ operator==()

template<typename T >

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

inline

◆ ParseBoolFlag()

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

◆ ParseFlagValue()

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

◆ ParseGoogleTestFlag()

bool testing::internal::ParseGoogleTestFlag ( const char *const arg )

◆ ParseGoogleTestFlagsOnly() [1/2]

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

◆ ParseGoogleTestFlagsOnly() [2/2]

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

◆ ParseGoogleTestFlagsOnlyImpl()

template<typename CharType >

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

◆ ParseInt32()

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

◆ ParseInt32Flag()

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

◆ ParseStringFlag()

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

◆ PortableLocaltime()

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

static

◆ PrintAsCharLiteralTo()

template<typename UnsignedChar , typename Char >

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

static

◆ PrintAsStringLiteralTo() [1/2]

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

static

◆ PrintAsStringLiteralTo() [2/2]

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

static

◆ PrintCharAndCodeTo()

template<typename UnsignedChar , typename Char >

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

◆ PrintCharsAsStringTo()

template<typename CharType >

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

static

◆ PrintColorEncoded()

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

static

◆ PrintFullTestCommentIfPresent()

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

◆ PrintOnOneLine()

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

static

◆ PrintRawArrayTo()

template<typename T >

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

◆ PrintStringTo() [1/2]

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

◆ PrintStringTo() [2/2]

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

◆ PrintTestPartResult()

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

static

◆ PrintTestPartResultToString()

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

static

◆ PrintTo() [1/19]

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

inline

◆ PrintTo() [2/19]

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

inline

◆ PrintTo() [3/19]

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

inline

◆ PrintTo() [4/19]

template<typename T1 , typename T2 >

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

◆ PrintTo() [5/19]

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

inline

◆ PrintTo() [6/19]

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

◆ PrintTo() [7/19]

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

◆ PrintTo() [8/19]

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

inline

◆ PrintTo() [9/19]

template<typename T >

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

◆ PrintTo() [10/19]

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

inline

◆ PrintTo() [11/19]

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

◆ PrintTo() [12/19]

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

◆ PrintTo() [13/19]

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

inline

◆ PrintTo() [14/19]

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

◆ PrintTo() [15/19]

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

inline

◆ PrintTo() [16/19]

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

◆ PrintTo() [17/19]

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

inline

◆ PrintTo() [18/19]

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

◆ PrintTo() [19/19]

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

◆ ReadEntireFile()

std::string testing::internal::ReadEntireFile ( FILE * file )

◆ ReportFailureInUnknownLocation()

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

◆ SetUpEnvironment()

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

static

◆ ShouldRunTestCase()

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

static

◆ ShouldRunTestOnShard()

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

◆ ShouldShard()

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

◆ ShouldUseColor()

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

◆ Shuffle()

template<typename E >

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

inline

◆ ShuffleRange()

template<typename E >

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

◆ SkipPrefix()

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

◆ SplitString()

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

◆ StreamableToString()

template<typename T >

std::string testing::internal::StreamableToString ( const T & streamable )

◆ StringFromGTestEnv()

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

◆ StringStreamToString()

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

◆ StripTrailingSpaces()

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

inline

◆ SumOverTestCaseList()

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

static

◆ TearDownEnvironment()

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

static

◆ TempDir()

std::string testing::internal::TempDir ( )

◆ TEST() [1/41]

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

◆ TEST() [2/41]

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

◆ TEST() [3/41]

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

◆ TEST() [4/41]

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

◆ TEST() [5/41]

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

◆ TEST() [6/41]

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

◆ TEST() [7/41]

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

◆ TEST() [8/41]

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

◆ TEST() [9/41]

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

◆ TEST() [10/41]

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

◆ TEST() [11/41]

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

◆ TEST() [12/41]

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

◆ TEST() [13/41]

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

◆ TEST() [14/41]

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

◆ TEST() [15/41]

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

◆ TEST() [16/41]

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

◆ TEST() [17/41]

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

◆ TEST() [18/41]

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

◆ TEST() [19/41]

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

◆ TEST() [20/41]

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

◆ TEST() [21/41]

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

◆ TEST() [22/41]

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

◆ TEST() [23/41]

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

◆ TEST() [24/41]

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

◆ TEST() [25/41]

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

◆ TEST() [26/41]

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

◆ TEST() [27/41]

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

◆ TEST() [28/41]

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

◆ TEST() [29/41]

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

◆ TEST() [30/41]

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

◆ TEST() [31/41]

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

◆ TEST() [32/41]

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

◆ TEST() [33/41]

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

◆ TEST() [34/41]

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

◆ TEST() [35/41]

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

◆ TEST() [36/41]

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

◆ TEST() [37/41]

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

◆ TEST() [38/41]

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

◆ TEST() [39/41]

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

◆ TEST() [40/41]

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

◆ TEST() [41/41]

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

◆ TEST_F() [1/2]

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

◆ TEST_F() [2/2]

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

◆ TestCaseFailed()

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

static

◆ TestCasePassed()

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

static

◆ ToLower()

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

inline

◆ ToUpper()

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

inline

◆ UniversalPrint()

template<typename T >

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

◆ UniversalPrintArray() [1/5]

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

◆ UniversalPrintArray() [2/5]

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

◆ UniversalPrintArray() [3/5]

template<typename T >

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

◆ UniversalPrintArray() [4/5]

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

◆ UniversalPrintArray() [5/5]

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

◆ UniversalPrintCharArray()

template<typename CharType >

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

static

◆ UniversalTersePrint()

template<typename T >

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

◆ WideStringToUtf8()

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

◆ WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Variable Documentation

◆ g_argvs

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

◆ g_help_flag

bool testing::internal::g_help_flag = false

◆ GTEST_ATTRIBUTE_UNUSED_

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

◆ kAlsoRunDisabledTestsFlag

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

◆ kBreakOnFailureFlag

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

◆ kCatchExceptionsFlag

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

◆ kColorEncodedHelpMessage

const char testing::internal::kColorEncodedHelpMessage[]

static

◆ kColorFlag

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

◆ kCurrentDirectoryString

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

◆ kDeathTestStyleFlag

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

◆ kDeathTestUseFork

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

◆ kFilterFlag

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

◆ kFlagfileFlag

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

◆ kInternalRunDeathTestFlag

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

◆ kListTestsFlag

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

◆ kMaxBiggestInt

const BiggestInt testing::internal::kMaxBiggestInt

Initial value:

=

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

◆ kMaxCodePoint1

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

◆ kMaxCodePoint2

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

◆ kMaxCodePoint3

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

◆ kMaxCodePoint4

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

◆ kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

◆ kOutputFlag

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

◆ kPathSeparator

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

◆ kPrintTimeFlag

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

◆ kRandomSeedFlag

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

◆ kRepeatFlag

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

◆ kShuffleFlag

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

◆ kStackTraceDepthFlag

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

◆ kStackTraceMarker

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

◆ kStdErrFileno

const int testing::internal::kStdErrFileno = STDERR_FILENO

◆ kStdOutFileno

const int testing::internal::kStdOutFileno = STDOUT_FILENO

◆ kStreamResultToFlag

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

◆ kTestTypeIdInGoogleTest

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

◆ kThrowOnFailureFlag

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

◆ kTypedTestCases

const int testing::internal::kTypedTestCases = 0

◆ kTypedTests

const int testing::internal::kTypedTests = 0

◆ kTypeParamLabel

const char testing::internal::kTypeParamLabel[] = "TypeParam"

static

◆ kUnknownFile

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

◆ kValueParamLabel

const char testing::internal::kValueParamLabel[] = "GetParam()"

static

◆ TypeId

const typedef void* testing::internal::TypeId

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BiggestInt

◆ Double

◆ false_type

◆ Float

◆ Int32

◆ Int64

◆ IsContainer

◆ IsNotContainer

◆ MutexLock

◆ SetUpTestCaseFunc

◆ string

◆ Strings

◆ TearDownTestCaseFunc

◆ TimeInMillis

◆ true_type

◆ UInt32

◆ UInt64

◆ wstring

Enumeration Type Documentation

◆ CharFormat

◆ GTestColor

◆ GTestLogSeverity

Function Documentation

◆ AlwaysFalse()

◆ AlwaysTrue()

◆ AppendUserMessage()

◆ ArrayAwareFind()

◆ ArrayEq() [1/3]

◆ ArrayEq() [2/3]

◆ ArrayEq() [3/3]

◆ BoolFromGTestEnv()

◆ CaptureStderr()

◆ CaptureStdout()

◆ CheckedDowncastToActualType()

◆ ChopLowBits()

◆ CmpHelperEQ() [1/2]

◆ CmpHelperEQ() [2/2]

◆ CmpHelperEQFailure()

◆ CmpHelperFloatingPointEQ()

◆ CmpHelperOpFailure()

◆ CmpHelperSTRCASEEQ()

◆ CmpHelperSTRCASENE()

◆ CmpHelperSTREQ() [1/2]

◆ CmpHelperSTREQ() [2/2]

◆ CmpHelperSTRNE() [1/2]

◆ CmpHelperSTRNE() [2/2]

◆ CodePointToUtf8()

◆ ColoredPrintf()

◆ CopyArray() [1/3]

◆ CopyArray() [2/3]

◆ CopyArray() [3/3]

◆ CountIf()

◆ CreateCodePointFromUtf16SurrogatePair()

◆ DefaultPrintTo() [1/3]

◆ DefaultPrintTo() [2/3]

◆ DefaultPrintTo() [3/3]

◆ Delete()

◆ DiffStrings()

◆ DoubleNearPredFormat()

◆ DownCast_()

◆ EqFailure()

◆ FlagToEnvVar()

◆ FloatingPointLE()

◆ FlushInfoLog()

◆ ForEach()

◆ FormatCompilerIndependentFileLocation()

◆ FormatEpochTimeInMillisAsIso8601()

◆ FormatFileLocation()

◆ FormatForComparisonFailureMessage()

◆ FormatTimeInMillisAsSeconds()

◆ GetAnsiColorCode()

◆ GetArgvs()

◆ GetBoolAssertionFailureMessage()