Namespaces
	edit_distance

	gmockpp

	internal_stream_operator_without_lexical_name_lookup

	invoke_argument

	posix

Classes
class	ActionAdaptor

class	ActionHelper

struct	ActionImpl

struct	ActionImpl< R(Args...), Impl >

class	ActionResultHolder

class	ActionResultHolder< void >

struct	AddReference

struct	AddReference< T & >

struct	AllOfResult1

struct	AllOfResult10

struct	AllOfResult2

struct	AllOfResult3

struct	AllOfResult4

struct	AllOfResult5

struct	AllOfResult6

struct	AllOfResult7

struct	AllOfResult8

struct	AllOfResult9

struct	AnyEq

struct	AnyGe

struct	AnyGt

struct	AnyLe

struct	AnyLt

class	AnyMatcherImpl

struct	AnyNe

struct	AnyOfResult1

struct	AnyOfResult10

struct	AnyOfResult2

struct	AnyOfResult3

struct	AnyOfResult4

struct	AnyOfResult5

struct	AnyOfResult6

struct	AnyOfResult7

struct	AnyOfResult8

struct	AnyOfResult9

class	AnythingMatcher

struct	append

struct	append< int_pack< Is... >, I >

class	ArgsMatcher

class	ArgsMatcherImpl

class	AssertHelper

class	AssignAction

class	Base

class	BeginEndDistanceIsMatcher

struct	bool_constant

struct	BooleanConstant

class	BothOfMatcher

class	BothOfMatcherImpl

class	BoundSecondMatcher

class	BriefUnitTestResultPrinter

class	BuiltInDefaultValue

class	BuiltInDefaultValue< const T >

class	BuiltInDefaultValue< T * >

struct	BuiltInDefaultValueGetter

struct	BuiltInDefaultValueGetter< T, false >

struct	ByMoveWrapper

struct	CallableTraits

struct	CallableTraits< ResType(*)(ArgType)>

class	CapturedStream

class	CartesianProductGenerator

class	CartesianProductGenerator10

class	CartesianProductGenerator2

class	CartesianProductGenerator3

class	CartesianProductGenerator4

class	CartesianProductGenerator5

class	CartesianProductGenerator6

class	CartesianProductGenerator7

class	CartesianProductGenerator8

class	CartesianProductGenerator9

class	CartesianProductHolder

class	CartesianProductHolder10

class	CartesianProductHolder2

class	CartesianProductHolder3

class	CartesianProductHolder4

class	CartesianProductHolder5

class	CartesianProductHolder6

class	CartesianProductHolder7

class	CartesianProductHolder8

class	CartesianProductHolder9

class	Castable

struct	CastAndAppendTransform

struct	CodeLocation

class	ComparisonBase

struct	CompileAssert

struct	CompileAssertTypesEqual

struct	CompileAssertTypesEqual< T, T >

class	ConstAndNonConstCastable

class	ConstCastable

struct	ConstCharPtr

struct	ConstRef

struct	ConstRef< T & >

class	ContainerEqMatcher

struct	ContainerPrinter

class	ContainsMatcher

class	ContainsMatcherImpl

struct	ConvertibleToIntegerPrinter

struct	ConvertibleToStringViewPrinter

struct	DecayArray

struct	DecayArray< T[]>

struct	DecayArray< T[N]>

class	DefaultGlobalTestPartResultReporter

struct	DefaultNameGenerator

class	DefaultPerThreadTestPartResultReporter

struct	DeleteArgAction

class	Derived

struct	DoAllAction

class	DoBothAction

class	DoDefaultAction

struct	DoubleSequence

struct	DoubleSequence< false, IndexSequence< I... >, sizeofT >

struct	DoubleSequence< true, IndexSequence< I... >, sizeofT >

class	DummyMatchResultListener

class	EachMatcher

class	EachMatcherImpl

class	EitherOfMatcher

class	EitherOfMatcherImpl

class	ElementsAreArrayMatcher

class	ElementsAreMatcher

class	ElementsAreMatcherImpl

struct	ElemFromList

struct	ElemFromList< N, IndexSequence< I... >, T... >

struct	ElemFromListImpl

struct	ElemFromListImpl< IndexSequence< I... > >

struct	ElemFromListImpl< T, I, I >

struct	EnableIf

struct	EnableIf< true >

class	EndsWithMatcher

class	EnvironmentInvocationCatcher

class	Eq2Matcher

class	EqHelper

class	EqHelper< true >

class	EqMatcher

class	EventRecordingListener

class	EventRecordingListener2

struct	ExcessiveArg

class	ExpectationBase

class	ExpectationTester

class	FailureReporterInterface

struct	faketype

struct	FallbackPrinter

class	FieldMatcher

class	FilePath

class	FinalSuccessChecker

struct	FindFirstPrinter

struct	FindFirstPrinter< T, decltype(Printer::PrintValue(std::declval< const T & >(), nullptr)), Printer, Printers... >

class	FlatTuple

struct	FlatTupleBase

struct	FlatTupleBase< FlatTuple< T... >, IndexSequence< Idx... > >

struct	FlatTupleConstructTag

struct	FlatTupleElemBase

struct	FlatTupleElemBase< FlatTuple< T... >, I >

class	FloatingEqMatcher

class	FloatingPoint

class	FormatForComparison

class	FormatForComparison< ToPrint[N], OtherOperand >

struct	Function

struct	Function< R(A1)>

struct	Function< R(A1, A2)>

struct	Function< R(A1, A2, A3)>

struct	Function< R(A1, A2, A3, A4)>

struct	Function< R(A1, A2, A3, A4, A5)>

struct	Function< R(A1, A2, A3, A4, A5, A6)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>

struct	Function< R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>

struct	Function< R(Args...)>

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

struct	FunctionPointerPrinter

class	Ge2Matcher

class	GeMatcher

struct	GenerateTypeList

class	GoogleTestFailureReporter

class	Gt2Matcher

class	GTestFlagSaver

class	GTestLog

class	GTestMutexLock

class	GtMatcher

class	HasDebugStringAndShortDebugString

class	HasNewFatalFailureHelper

class	HasSubstrMatcher

struct	Ignore

class	IgnoredValue

class	IgnoreResultAction

struct	ImplBase

class	ImplicitlyConvertible

struct	IndexSequence

struct	int_pack

class	InvokeAction

struct	InvokeArgumentAction

class	InvokeHelper

class	InvokeHelper< R, ::testing::tuple< A1 > >

class	InvokeHelper< R, ::testing::tuple< A1, A2 > >

class	InvokeHelper< R, ::testing::tuple< A1, A2, A3 > >

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

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

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

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

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

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

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

class	InvokeHelper< R, ::testing::tuple<> >

struct	InvokeMethodAction

struct	InvokeMethodWithoutArgsAction

struct	InvokeWithoutArgsAction

struct	is_pointer

struct	is_pointer< T * >

struct	is_proxy_type_list

struct	is_proxy_type_list< ProxyTypeList< Ts... > >

struct	is_reference

struct	is_reference< T & >

struct	is_same

struct	is_same< T, T >

struct	IsAProtocolMessage

struct	IsHashTable

class	IsNullMatcher

struct	IsRecursiveContainer

struct	IsRecursiveContainerImpl

struct	IsRecursiveContainerImpl< C, false >

struct	IsRecursiveContainerImpl< C, true >

struct	IsSame

struct	IsSame< T, T >

struct	IteratorTraits

struct	IteratorTraits< const T * >

struct	IteratorTraits< T * >

class	JsonUnitTestResultPrinter

class	KeyMatcher

class	KeyMatcherImpl

struct	KindOf

class	Le2Matcher

class	LeMatcher

struct	LessByName

struct	LessComparator

class	linked_ptr

class	linked_ptr_internal

struct	LinkedPtrLessThan

class	ListenerTest

struct	LosslessArithmeticConvertibleImpl

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kBool, bool, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kFloatingPoint, From, kInteger, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kBool, bool >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kFloatingPoint, To >

struct	LosslessArithmeticConvertibleImpl< kInteger, From, kInteger, To >

class	Lt2Matcher

class	LtMatcher

struct	make_int_pack

struct	make_int_pack< 0 >

struct	MakeIndexSequence

struct	MakeIndexSequence< 0 >

struct	MakeIndexSequenceImpl

struct	MakeIndexSequenceImpl< 0 >

struct	MarkAsIgnored

class	MatcherAsPredicate

class	MatcherBase

class	MatcherCastImpl

class	MatcherCastImpl< T, Matcher< T > >

class	MatcherCastImpl< T, Matcher< U > >

struct	MatcherTuple

struct	MatcherTuple< ::testing::tuple< A1 > >

struct	MatcherTuple< ::testing::tuple< A1, A2 > >

struct	MatcherTuple< ::testing::tuple< A1, A2, A3 > >

struct	MatcherTuple< ::testing::tuple< A1, A2, A3, A4 > >

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

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

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

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

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

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

struct	MatcherTuple< ::testing::tuple<> >

class	MatchesRegexMatcher

class	MatchMatrix

class	MaxBipartiteMatchState

class	MockSpec

class	Mutex

class	NaggyMockImpl

struct	NameGeneratorSelector

class	NativeArray

class	Ne2Matcher

class	NeMatcher

class	NiceMockImpl

class	NoDefaultContructor

struct	None

class	NotMatcher

class	NotMatcherImpl

class	NotNullMatcher

class	OnCallSpec

class	OsStackTraceGetter

class	OsStackTraceGetterInterface

class	PairMatchBase

class	PairMatcher

class	PairMatcherImpl

class	ParameterizedTestCaseInfo

class	ParameterizedTestCaseInfoBase

class	ParameterizedTestCaseRegistry

class	ParameterizedTestFactory

class	ParameterizedTestSuiteInfo

class	ParameterizedTestSuiteInfoBase

class	ParameterizedTestSuiteRegistry

class	ParamGenerator

class	ParamGeneratorInterface

class	ParamIterator

class	ParamIteratorInterface

struct	ParamNameGenFunc

class	PointeeMatcher

struct	PointeeOf

struct	PointeeOf< T * >

struct	PointerPrinter

class	PointwiseMatcher

class	PredicateFormatterFromMatcher

class	PrettyUnitTestResultPrinter

class	PropertyMatcher

struct	ProtobufPrinter

struct	ProxyTypeList

class	QuantifierMatcherImpl

class	Random

class	RangeGenerator

struct	RawBytesPrinter

class	RE

class	ReferenceOrValueWrapper

class	ReferenceOrValueWrapper< T & >

class	ReferenceWrapper

class	RefMatcher

class	RefMatcher< T & >

struct	RelationToSourceCopy

struct	RelationToSourceReference

struct	remove_reference

struct	remove_reference< T & >

struct	RemoveConst

struct	RemoveConst< const T >

struct	RemoveConst< const T[N]>

struct	RemoveConstFromKey

struct	RemoveConstFromKey< std::pair< const K, V > >

struct	RemoveReference

struct	RemoveReference< T & >

class	ResultOfMatcher

class	ReturnAction

struct	ReturnArgAction

struct	ReturnNewAction

class	ReturnNullAction

struct	ReturnPointeeAction

class	ReturnRefAction

class	ReturnRefOfCopyAction

class	ReturnRoundRobinAction

class	ReturnVoidAction

struct	SaveArgAction

struct	SaveArgPointeeAction

class	scoped_ptr

class	ScopedPrematureExitFile

class	ScopedTrace

class	SelectArgs

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

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

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

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

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

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

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

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

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

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

struct	SetArgRefereeAction

class	SetArgumentPointeeAction

class	SetArgumentPointeeAction< N, Proto, true >

struct	SetArrayArgumentAction

class	SetErrnoAndReturnAction

class	SingleFailureChecker

class	SizeIsMatcher

class	StartsWithMatcher

struct	StaticAssertTypeEqHelper

struct	StaticAssertTypeEqHelper< T, T >

class	StlContainerView

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

class	StlContainerView< ::testing::tuple< ElementPointer, Size > >

class	StlContainerView< Element[N]>

class	StreamMatchResultListener

class	StrEqualityMatcher

class	StrictMockImpl

class	String

struct	SuiteApiResolver

struct	Templates

struct	Templates< Head_ >

struct	TemplateSel

class	TestCaseNameIs

class	TestEventListenersAccessor

class	TestEventRepeater

class	TestFactoryBase

class	TestFactoryImpl

class	TestMetaFactory

class	TestMetaFactoryBase

class	TestPropertyKeyIs

class	TestResultAccessor

class	TestSuiteNameIs

class	TestSuiteWithCommentTest

struct	ThisRefAdjuster

class	ThreadLocal

class	Timer

class	To

struct	TraceInfo

class	TransformTupleValuesHelper

struct	TrueWithString

class	TrulyMatcher

class	TupleFields

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

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

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

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

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

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

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

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

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

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

struct	TuplePolicy

class	TuplePrefix

class	TuplePrefix< 0 >

struct	TuplePrefixPrinter

struct	TuplePrefixPrinter< 0 >

struct	type_equals

struct	type_equals< T, T >

class	TypedExpectation

class	TypeIdHelper

class	TypeParameterizedTest

class	TypeParameterizedTest< Fixture, TestSel, internal::None >

class	TypeParameterizedTestSuite

class	TypeParameterizedTestSuite< Fixture, internal::None, Types >

class	TypeParameterizedTestSuiteRegistry

struct	Types

struct	Types< Head_ >

class	TypeWithSize

class	TypeWithSize< 4 >

class	TypeWithSize< 8 >

class	UnitTestHelper

class	UnitTestImpl

class	UnitTestOptions

class	UnitTestRecordPropertyTestHelper

class	UniversalPrinter

class	UniversalPrinter< const T >

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

class	UniversalPrinter< Wrapper< T > >

class	UniversalTersePrinter

class	UniversalTersePrinter< char * >

class	UniversalTersePrinter< char16_t * >

class	UniversalTersePrinter< char32_t * >

class	UniversalTersePrinter< const char * >

class	UniversalTersePrinter< const char16_t * >

class	UniversalTersePrinter< const char32_t * >

class	UniversalTersePrinter< const wchar_t * >

class	UniversalTersePrinter< T & >

class	UniversalTersePrinter< T[N]>

class	UniversalTersePrinter< wchar_t * >

class	UnorderedElementsAreArrayMatcher

class	UnorderedElementsAreMatcher

class	UnorderedElementsAreMatcherImpl

class	UnorderedElementsAreMatcherImplBase

class	UntypedActionResultHolderBase

class	UntypedFunctionMockerBase

class	UntypedOnCallSpecBase

class	ValueArray

class	ValueArray1

class	ValueArray10

class	ValueArray11

class	ValueArray12

class	ValueArray13

class	ValueArray14

class	ValueArray15

class	ValueArray16

class	ValueArray17

class	ValueArray18

class	ValueArray19

class	ValueArray2

class	ValueArray20

class	ValueArray21

class	ValueArray22

class	ValueArray23

class	ValueArray24

class	ValueArray25

class	ValueArray26

class	ValueArray27

class	ValueArray28

class	ValueArray29

class	ValueArray3

class	ValueArray30

class	ValueArray31

class	ValueArray32

class	ValueArray33

class	ValueArray34

class	ValueArray35

class	ValueArray36

class	ValueArray37

class	ValueArray38

class	ValueArray39

class	ValueArray4

class	ValueArray40

class	ValueArray41

class	ValueArray42

class	ValueArray43

class	ValueArray44

class	ValueArray45

class	ValueArray46

class	ValueArray47

class	ValueArray48

class	ValueArray49

class	ValueArray5

class	ValueArray50

class	ValueArray6

class	ValueArray7

class	ValueArray8

class	ValueArray9

class	ValuesInIteratorRangeGenerator

class	WhenDynamicCastToMatcher

class	WhenDynamicCastToMatcher< To & >

class	WhenDynamicCastToMatcherBase

class	WhenSortedByMatcher

struct	WithArgsAction

class	WithoutMatchers

struct	WrapPrinterType

class	XmlUnitTestResultPrinter

Typedefs
using	BiggestInt = long long

template<bool B>
using	bool_constant = std::integral_constant< bool, B >

template<typename P , typename Q >
using	disjunction = typename ::std::conditional< P::value, P, Q >::type

typedef FloatingPoint< double >	Double

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

typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs

typedef bool_constant< false >	false_type

typedef FloatingPoint< float >	Float

template<typename T >
using	identity_t = T

template<typename... T>
using	IndexSequenceFor = typename MakeIndexSequence< sizeof...(T)>::type

typedef TypeWithSize< 4 >::Int	Int32

typedef TypeWithSize< 8 >::Int	Int64

typedef int	IsContainer

typedef char	IsNotContainer

template<typename From , typename To >
using	LosslessArithmeticConvertible = LosslessArithmeticConvertibleImpl< GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To >

template<TypeKind kFromKind, typename From , TypeKind kToKind, typename To >
using	LosslessArithmeticConvertibleImpl = std::integral_constant< bool,(kFromKind==kBool) ? true :(kFromKind !=kToKind) ? false :(kFromKind==kInteger &&(((sizeof(From)< sizeof(To)) &&!(std::is_signed< From >::value &&!std::is_signed< To >::value))\|\|((sizeof(From)==sizeof(To)) &&(std::is_signed< From >::value==std::is_signed< To >::value)))) ? true :(kFromKind==kFloatingPoint &&(sizeof(From)<=sizeof(To))) ? true :false >

template<size_t N>
using	MakeIndexSequence = typename MakeIndexSequenceImpl< N >::type

typedef GTestMutexLock	MutexLock

template<class TestCase >
using	ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo< TestCase >

using	SetUpTearDownSuiteFuncType = void(*)()

typedef void(*	SetUpTestCaseFunc) ()

using	SetUpTestSuiteFunc = void(*)()

typedef ::std::string	string

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

typedef void(*	TearDownTestCaseFunc) ()

using	TearDownTestSuiteFunc = void(*)()

using	TimeInMillis = TypeWithSize< 8 >::Int

typedef bool_constant< true >	true_type

using	TypedTestCasePState = TypedTestSuitePState

template<typename T >
using	TypeIsValidNullptrConstant = std::integral_constant< bool, std::is_same< typename std::decay< T >::type, std::nullptr_t >::value\|\|!std::is_convertible< T, Secret * >::value >

typedef TypeWithSize< 4 >::UInt	UInt32

typedef TypeWithSize< 8 >::UInt	UInt64

typedef ::std::wstring	wstring

Enumerations
enum	CallReaction { kAllow, kWarn, kFail, kDefault = kWarn }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	CharFormat { kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape, kAsIs, kHexEscape, kSpecialEscape }

enum	DefaultPrinterType { kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther }

enum	DefaultPrinterType { kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther }

enum	DefaultPrinterType { kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther, kPrintContainer, kPrintPointer, kPrintFunctionPointer, kPrintOther }

enum	GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

enum	GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

enum	GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

enum	GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL, GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	LogSeverity { kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1, kInfo = 0, kWarning = 1 }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

enum	TypeKind { kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther, kBool, kInteger, kFloatingPoint, kOther }

Functions
template<typename MockType >
MockType *	AdjustConstness_ (const MockType *mock)

template<typename MockType >
const MockType *	AdjustConstness_const (const MockType *mock)

bool	AlwaysFalse ()

GTEST_API_ bool	AlwaysTrue ()

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

template<typename F , typename Tuple >
auto	Apply (F &&f, Tuple &&args) -> decltype(ApplyImpl(std::forward< F >(f), std::forward< Tuple >(args), MakeIndexSequence< std::tuple_size< Tuple >::value >()))

template<typename F , typename Tuple , size_t... Idx>
auto	ApplyImpl (F &&f, Tuple &&args, IndexSequence< Idx... >) -> decltype(std::forward< F >(f)(std::get< Idx >(std::forward< Tuple >(args))...))

template<typename F , typename Tuple , size_t... Idx>
auto	ApplyImpl (F &&f, Tuple &&args, int_pack< Idx... >) -> decltype(std::forward< F >(f)(std::get< Idx >(std::forward< Tuple >(args))...))

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

template<typename From , typename To >
void	Assert (bool condition, const char *file, int line)

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

bool	Base64Unescape (const std::string &encoded, std::string *decoded)

bool	BoolFromGTestEnv (const char *flag, bool default_val)

std::string	CanonicalizeForStdLibVersioning (std::string s)

GTEST_API_ void	CaptureStderr ()

GTEST_API_ void	CaptureStdout ()

void	CaptureStream (int fd, const char stream_name, CapturedStream *stream)

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)

uint32_t	ChopLowBits (uint32_t *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)

std::string	CodePointToUtf8 (UInt32 code_point)

std::string	CodePointToUtf8 (uint32_t code_point)

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

GTEST_API_ std::string	ConvertIdentifierNameToWords (const char *id_name)

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<typename InputIterator , typename OutputIterator >
OutputIterator	CopyElements (InputIterator first, InputIterator last, OutputIterator output)

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

UInt32	CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)

template<class ParamType >
std::string	DefaultParamName (const TestParamInfo< ParamType > &info)

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 C >
void	DefaultPrintTo (WrapPrinterType< kPrintContainer >, const C &container, ::std::ostream *os)

template<typename T >
void	DefaultPrintTo (WrapPrinterType< kPrintFunctionPointer >, T p, ::std::ostream os)

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

template<typename T >
void	DefaultPrintTo (WrapPrinterType< kPrintPointer >, T p, ::std::ostream os)

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

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)

template<int N, int M>
constexpr bool	EndsWith (const char(&suffix)[N], const char(&str)[M])

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)

template<int N, int M>
constexpr bool	Equals (const char(&a)[N], const char(&b)[M])

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

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

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

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

GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)

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

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

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

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

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

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

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)

std::string	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)

static std::string	FormatEpochTimeInMillisAsRFC3339 (TimeInMillis ms)

static std::string	FormatEpochTimeInMillisAsRFC3339 (TimeInMillis ms)

static std::string	FormatEpochTimeInMillisAsRFC3339 (TimeInMillis ms)

static std::string	FormatEpochTimeInMillisAsRFC3339 (TimeInMillis ms)

static std::string	FormatEpochTimeInMillisAsRFC3339 (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	FormatMatcherDescription (bool negation, const char matcher_name, const std::vector< const char > &param_names, const Strings &param_values)

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

static std::string	FormatTimeInMillisAsDuration (TimeInMillis ms)

static std::string	FormatTimeInMillisAsDuration (TimeInMillis ms)

static std::string	FormatTimeInMillisAsDuration (TimeInMillis ms)

static std::string	FormatTimeInMillisAsDuration (TimeInMillis ms)

static std::string	FormatTimeInMillisAsDuration (TimeInMillis ms)

std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)

template<typename NameGenerator , typename Types >
std::vector< std::string >	GenerateNames ()

template<typename NameGenerator >
void	GenerateNamesRecursively (internal::None, std::vector< std::string > *, int)

template<typename NameGenerator , typename Types >
void	GenerateNamesRecursively (Types, std::vector< std::string > *result, int i)

static const char *	GetAnsiColorCode (GTestColor color)

static const char *	GetAnsiColorCode (GTestColor color)

static const char *	GetAnsiColorCode (GTestColor color)

static const char *	GetAnsiColorCode (GTestColor color)

static const char *	GetAnsiColorCode (GTestColor color)

GTEST_API_ std::vector< std::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 ()

std::string	GetCapturedStream (CapturedStream **captured_stream)

static const char *	GetCharWidthPrefix (char)

static const char *	GetCharWidthPrefix (char16_t)

static const char *	GetCharWidthPrefix (char32_t)

static const char *	GetCharWidthPrefix (signed char)

static const char *	GetCharWidthPrefix (unsigned char)

static const char *	GetCharWidthPrefix (wchar_t)

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_ FailureReporterInterface *	GetFailureReporter ()

GTEST_API_ size_t	GetFileSize (FILE *file)

std::set< std::string > *	GetIgnoredParameterizedTestSuites ()

int	GetNextRandomSeed (int seed)

SetUpTearDownSuiteFuncType	GetNotDefaultOrNull (SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def)

template<class ParamType >
ParamNameGenFunc< ParamType >::Type *	GetParamNameGen ()

template<class ParamType , class ParamNameGenFunctor >
ParamNameGenFunctor	GetParamNameGen (ParamNameGenFunctor func)

std::string	GetPrefixUntilComma (const char *str)

int	GetRandomSeedFromFlag (Int32 random_seed_flag)

int	GetRandomSeedFromFlag (int32_t random_seed_flag)

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

template<typename Element >
const Element *	GetRawPointer (const std::reference_wrapper< Element > &r)

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

GTEST_API_ TypeId	GetTestTypeId ()

GTEST_API_ size_t	GetThreadCount ()

TimeInMillis	GetTimeInMillis ()

template<typename T >
TypeId	GetTypeId ()

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

UnitTestImpl *	GetUnitTestImpl ()

GTEST_API_ WithoutMatchers	GetWithoutMatchers ()

	GMOCK_DECLARE_KIND_ (bool, kBool)

	GMOCK_DECLARE_KIND_ (char, kInteger)

	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (int, kInteger)

	GMOCK_DECLARE_KIND_ (Int64, kInteger)

	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (long, kInteger)

	GMOCK_DECLARE_KIND_ (short, kInteger)

	GMOCK_DECLARE_KIND_ (signed char, kInteger)

	GMOCK_DECLARE_KIND_ (UInt64, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned int, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned long long, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned long, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned short, kInteger)

	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)

	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_ (char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (Int64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed int, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long long, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (UInt64, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned int, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long long, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (wchar_t, 0U)

GTEST_API_	GTEST_ATTRIBUTE_PRINTF_ (2, 3) void ColoredPrintf(GTestColor color

GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_gmock_mutex)

GTEST_API_	GTEST_DECLARE_STATIC_MUTEX_ (g_linked_ptr_mutex)

	GTEST_DECLARE_string_ (internal_run_death_test)

GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)

GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_mutex)

static	GTEST_DEFINE_STATIC_MUTEX_ (g_log_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_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_DISABLE_MSC_WARNINGS_POP_ () inline const char SkipComma(const char str)

	GTEST_DISABLE_MSC_WARNINGS_PUSH_ (4251) class GTEST_API_ TypedTestSuitePState

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

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char32_t)

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)

	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)

	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char16_t, ::std::u16string)

	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char32_t, ::std::u32string)

	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (wchar_t, ::std::wstring)

	GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TEST_SUITE_P") const expr bool InstantiateTestCase_P_IsDeprecated()

	GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TYPED_TEST_SUITE_P") const expr bool InstantiateTypedTestCase_P_IsDeprecated()

	GTEST_INTERNAL_DEPRECATED ("REGISTER_TYPED_TEST_CASE_P is deprecated, please use " "REGISTER_TYPED_TEST_SUITE_P") const expr bool RegisterTypedTestCase_P_IsDeprecated()

	GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE is deprecated, please use " "TYPED_TEST_SUITE") const expr bool TypedTestCaseIsDeprecated()

	GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE_P is deprecated, please use " "TYPED_TEST_SUITE_P") const expr bool TypedTestCase_P_IsDeprecated()

static bool	GTestIsInitialized ()

static bool	GTestIsInitialized ()

static bool	GTestIsInitialized ()

static bool	GTestIsInitialized ()

static bool	GTestIsInitialized ()

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)

static bool	HasGoogleTestFlagPrefix (const char *str)

static bool	HasGoogleTestFlagPrefix (const char *str)

static bool	HasGoogleTestFlagPrefix (const char *str)

static bool	HasGoogleTestFlagPrefix (const char *str)

static bool	HasGoogleTestFlagPrefix (const char *str)

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

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

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

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

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

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

template<typename T >
constexpr bool	HasStrictnessModifier ()

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

template<typename To >
To	ImplicitCast_ (To x)

static std::string	Indent (int width)

static std::string	Indent (int width)

static std::string	Indent (size_t width)

static std::string	Indent (size_t width)

static std::string	Indent (size_t width)

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

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

GTEST_API_ void	InsertSyntheticTestCase (const std::string &name, CodeLocation location, bool has_test_p)

Int32	Int32FromEnvOrDie (const char *var, Int32 default_val)

int32_t	Int32FromEnvOrDie (const char *var, int32_t default_val)

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

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

CallReaction	intToCallReaction (int mock_behavior)

template<typename T >
T	Invalid ()

template<typename F , typename... Args>
auto	InvokeArgument (F f, Args... args) -> decltype(f(args...))

bool	IsAlNum (char ch)

bool	IsAlpha (char ch)

template<class C , class Iterator = decltype(::std::declval<const C&>().begin()), class = decltype(::std::declval<const C&>().end()), class = decltype(++::std::declval<Iterator&>()), class = decltype(*::std::declval<Iterator>()), class = typename C::const_iterator>
IsContainer	IsContainerTest (int)

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]

std::false_type	IsNullLiteralHelper (IgnoredValue, std::false_type)

std::false_type	IsNullLiteralHelper (IgnoredValue, std::true_type)

std::true_type	IsNullLiteralHelper (Secret *, std::true_type)

char	IsNullLiteralHelper (Secret *p)

static bool	IsPathSeparator (char c)

static bool	IsPathSeparator (char c)

static bool	IsPathSeparator (char c)

static bool	IsPathSeparator (char c)

static bool	IsPathSeparator (char c)

static bool	IsPathSeparator (char c)

bool	IsPrintableAscii (char32_t 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)

bool	IsXDigit (char16_t ch)

bool	IsXDigit (char32_t ch)

bool	IsXDigit (wchar_t ch)

GTEST_API_ std::string	JoinAsKeyValueTuple (const std::vector< const char * > &names, const Strings &values)

GTEST_API_ std::string	JoinAsTuple (const Strings &fields)

void	LoadFlagsFromFile (const std::string &path)

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

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

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

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

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

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

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

GTEST_API_ bool	LogIsVisible (LogSeverity severity)

void	LogToStderr ()

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

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

template<typename F , typename Impl >
::testing::Action< F >	MakeAction ()

template<typename F , typename Impl >
::testing::Action< F >	MakeAction (std::shared_ptr< Impl > impl)

GTEST_API_ TestInfo *	MakeAndRegisterTestInfo (const char test_suite_name, const char name, const char type_param, const char value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, TearDownTestSuiteFunc tear_down_tc, TestFactoryBase *factory)

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

template<typename Tuple2Matcher , typename Second >
BoundSecondMatcher< Tuple2Matcher, Second >	MatcherBindSecond (const Tuple2Matcher &tm, const Second &second)

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

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

static FILE *	OpenFileForWriting (const std::string &output_file)

static FILE *	OpenFileForWriting (const std::string &output_file)

static FILE *	OpenFileForWriting (const std::string &output_file)

static FILE *	OpenFileForWriting (const std::string &output_file)

static FILE *	OpenFileForWriting (const std::string &output_file)

bool	operator!= (faketype, faketype)

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

bool	operator== (faketype, faketype)

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

std::string	OutputFlagAlsoCheckEnvVar ()

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

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

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

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

GTEST_API_ bool	ParseFlag (const char str, const char flag, int32_t *value)

static bool	ParseFlag (const char str, const char flag_name, bool *value)

template<typename String >
static bool	ParseFlag (const char str, const char flag_name, String *value)

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

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

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

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

static const char *	ParseFlagValue (const char str, const char flag_name, bool def_optional)

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

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

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

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

static bool	ParseGoogleMockFlag (const char str, const char flag_name, bool *value)

static bool	ParseGoogleMockFlag (const char str, const char flag_name, int32_t *value)

template<typename String >
static bool	ParseGoogleMockFlag (const char str, const char flag_name, String *value)

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

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

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

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

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

static bool	ParseGoogleMockIntFlag (const char str, const char flag, int *value)

static bool	ParseGoogleMockIntFlag (const char str, const char flag, int *value)

static bool	ParseGoogleMockIntFlag (const char str, const char flag, int *value)

template<typename String >
static bool	ParseGoogleMockStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseGoogleMockStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseGoogleMockStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseGoogleMockStringFlag (const char str, const char flag, String *value)

static bool	ParseGoogleTestFlag (const char *const arg)

static bool	ParseGoogleTestFlag (const char *const arg)

static bool	ParseGoogleTestFlag (const char *const arg)

static bool	ParseGoogleTestFlag (const char *const arg)

static bool	ParseGoogleTestFlag (const char *const arg)

void	ParseGoogleTestFlagsOnly (int argc, char *argv)

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	ParseInt32 (const Message &src_text, const char str, int32_t value)

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

bool	ParseInt32Flag (const char str, const char flag, int32_t *value)

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

template<typename String >
static bool	ParseStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseStringFlag (const char str, const char flag, String *value)

template<typename String >
static bool	ParseStringFlag (const char str, const char flag, String *value)

static bool	PatternMatchesString (const std::string &name_str, const char pattern, const char pattern_end)

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

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

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

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

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

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

constexpr bool	PrefixOf (const char a, const char b)

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

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

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

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

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

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

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char16_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (char32_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

static CharFormat	PrintAsStringLiteralTo (wchar_t c, ostream *os)

GTEST_API_ void	PrintBytesInObjectTo (const unsigned char obj_bytes, size_t count, ::std::ostream os)

void	PrintBytesInObjectTo (const unsigned char obj_bytes, size_t count, ostream os)

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

template<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_ CharFormat	PrintCharsAsStringTo (const CharType begin, size_t len, ostream os)

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

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

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

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

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

static void	PrintColorEncoded (const char *str)

static void	PrintColorEncoded (const char *str)

static void	PrintColorEncoded (const char *str)

static void	PrintColorEncoded (const char *str)

static void	PrintColorEncoded (const char *str)

static void	PrintColorEncoded (const char *str)

static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

static void	PrintFullTestCommentIfPresent (const TestInfo &test_info)

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

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

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

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

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

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

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

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

template<typename T , typename Ptr >
void	PrintSmartPointer (const Ptr &ptr, std::ostream *os, char)

template<typename T , typename Ptr , typename = typename std::enable_if<!std::is_void<T>::value && !std::is_array<T>::value>::type>
void	PrintSmartPointer (const Ptr &ptr, std::ostream *os, int)

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 void	PrintTestPartResult (const TestPartResult &test_part_result)

static void	PrintTestPartResult (const TestPartResult &test_part_result)

static void	PrintTestPartResult (const TestPartResult &test_part_result)

static void	PrintTestPartResult (const TestPartResult &test_part_result)

static void	PrintTestPartResult (const TestPartResult &test_part_result)

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

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

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

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

static std::string	PrintTestPartResultToString (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)

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

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

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

GTEST_API_ void	PrintTo (char32_t 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)

template<typename T1 >
void	PrintTo (const ::std::tr1::tuple< T1 > &t, ::std::ostream *os)

template<typename T1 , typename T2 >
void	PrintTo (const ::std::tr1::tuple< T1, T2 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5, T6 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5, T6, T7 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5, T6, T7, T8 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > &t, ::std::ostream *os)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
void	PrintTo (const ::std::tr1::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > &t, ::std::ostream *os)

void	PrintTo (const ::std::tr1::tuple<> &t, ::std::ostream *os)

template<typename... Types>
void	PrintTo (const ::std::tuple< Types... > &t, ::std::ostream *os)

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

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

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

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

void	PrintTo (const char s, ostream os)

void	PrintTo (const char16_t s, ::std::ostream os)

void	PrintTo (const char16_t s, ostream os)

void	PrintTo (const char32_t s, ::std::ostream os)

void	PrintTo (const char32_t s, ostream os)

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

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

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

template<typename T , typename D >
void	PrintTo (const std::unique_ptr< T, D > &ptr, 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 (std::nullptr_t, ::std::ostream *os)

template<typename T >
void	PrintTo (std::reference_wrapper< T > ref, ::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)

template<typename T >
void	PrintTupleTo (const T &, std::integral_constant< size_t, 0 >, ::std::ostream *)

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

template<typename T , size_t I>
void	PrintTupleTo (const T &t, std::integral_constant< size_t, I >, ::std::ostream *os)

template<typename Tuple >
void	PrintTupleTo (const Tuple &t, ::std::ostream *os)

GTEST_API_ void	PrintU16StringTo (const ::std::u16string &s, ::std::ostream *os)

void	PrintU16StringTo (const ::std::u16string &s, ostream *os)

GTEST_API_ void	PrintU32StringTo (const ::std::u32string &s, ::std::ostream *os)

void	PrintU32StringTo (const ::std::u32string &s, ostream *os)

GTEST_API_ void	PrintWideStringTo (const ::std::wstring &s, ::std::ostream *os)

void	PrintWideStringTo (const ::std::wstring &s, ostream *os)

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

GTEST_API_ std::string	ReadEntireFile (FILE *file)

void	RegisterTypeParameterizedTestSuite (const char *test_suite_name, CodeLocation code_location)

void	RegisterTypeParameterizedTestSuiteInstantiation (const char *case_name)

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

void	ReportInvalidTestCaseType (const char *test_case_name, CodeLocation code_location)

GTEST_API_ void	ReportInvalidTestSuiteType (const char *test_suite_name, CodeLocation code_location)

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

void	ReportUninterestingCall (CallReaction reaction, const string &msg)

static void	SetUpEnvironment (Environment *env)

static void	SetUpEnvironment (Environment *env)

static void	SetUpEnvironment (Environment *env)

static void	SetUpEnvironment (Environment *env)

static void	SetUpEnvironment (Environment *env)

static void	SetUpEnvironment (Environment *env)

static bool	ShouldRunTestCase (const TestCase *test_case)

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

static bool	ShouldRunTestSuite (const TestSuite *test_suite)

static bool	ShouldRunTestSuite (const TestSuite *test_suite)

static bool	ShouldRunTestSuite (const TestSuite *test_suite)

static bool	ShouldRunTestSuite (const TestSuite *test_suite)

static bool	ShouldRunTestSuite (const TestSuite *test_suite)

bool	ShouldShard (const char total_shards_env, const char shard_index_env, bool in_subprocess_for_death_test)

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)

static const char *	SkipSpaces (const char *str)

static std::vector< std::string >	SplitIntoTestNames (const char *src)

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

template<int N, int M>
constexpr bool	StartsWith (const char(&prefix)[N], const char(&str)[M])

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

static void	StreamWideCharsToMessage (const wchar_t wstr, size_t length, Message msg)

std::false_type	StrictnessModifierProbe (...)

template<typename T >
std::true_type	StrictnessModifierProbe (const NaggyMock< T > &)

template<typename T >
std::true_type	StrictnessModifierProbe (const NiceMock< T > &)

template<typename T >
std::true_type	StrictnessModifierProbe (const StrictMock< T > &)

const char *	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 int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)

static int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)

static int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)

static int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)

static int	SumOverTestSuiteList (const std::vector< TestSuite * > &case_list, int(TestSuite::*method)() const)

static void	TearDownEnvironment (Environment *env)

static void	TearDownEnvironment (Environment *env)

static void	TearDownEnvironment (Environment *env)

static void	TearDownEnvironment (Environment *env)

static void	TearDownEnvironment (Environment *env)

static void	TearDownEnvironment (Environment *env)

std::string	TempDir ()

template<typename Tuple >
void	TersePrintPrefixToStrings (const Tuple &, std::integral_constant< size_t, 0 >, Strings *)

template<typename Tuple , size_t I>
void	TersePrintPrefixToStrings (const Tuple &t, std::integral_constant< size_t, I >, Strings *strings)

	TEST (ApiTest, DISABLED_Dummy1)

	TEST (ApiTest, TestSuiteDisabledAccessorsWork)

	TEST (ApiTest, TestSuiteImmutableAccessorsWork)

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

template<typename T = int>
void	TestNotEmpty ()

template<typename T = int>
void	TestNotEmpty (const T &)

static bool	TestSuiteFailed (const TestSuite *test_suite)

static bool	TestSuiteFailed (const TestSuite *test_suite)

static bool	TestSuiteFailed (const TestSuite *test_suite)

static bool	TestSuiteFailed (const TestSuite *test_suite)

static bool	TestSuiteFailed (const TestSuite *test_suite)

static bool	TestSuitePassed (const TestSuite *test_suite)

static bool	TestSuitePassed (const TestSuite *test_suite)

static bool	TestSuitePassed (const TestSuite *test_suite)

static bool	TestSuitePassed (const TestSuite *test_suite)

static bool	TestSuitePassed (const TestSuite *test_suite)

char	ToLower (char ch)

char	ToUpper (char ch)

template<typename Tuple , typename Func , typename OutIter >
OutIter	TransformTupleValues (Func f, const Tuple &t, OutIter out)

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

	TYPED_TEST (TestSuiteWithCommentTest, Dummy)

	TYPED_TEST_SUITE (TestSuiteWithCommentTest, Types< int >)

constexpr std::array< char, 256 >	UnBase64 (const char *const base64)

constexpr char	UnBase64Impl (char c, const char *const base64, char carry)

template<size_t... I>
constexpr std::array< char, 256 >	UnBase64Impl (IndexSequence< I... >, const char *const base64)

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)

GTEST_API_ void	UniversalPrintArray (const char16_t begin, size_t len, ::std::ostream os)

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

GTEST_API_ void	UniversalPrintArray (const char32_t begin, size_t len, ::std::ostream os)

void	UniversalPrintArray (const char32_t 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 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 CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void	UniversalPrintCharArray (const CharType begin, size_t len, ostream os)

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

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

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

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

template<typename Tuple >
Strings	UniversalTersePrintTupleFieldsToStrings (const Tuple &value)

template<int N>
constexpr bool	ValidateSpec (const char(&spec)[N])

const void *	VoidifyPointer (const void *p)

const void *	VoidifyPointer (volatile const void *p)

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

void	WriteToShardStatusFileIfNeeded ()

Variables
GTEST_API_ const char *	fmt

static ::std::vector< std::string >	g_argvs

static CapturedStream *	g_captured_stderr = NULL

static CapturedStream *	g_captured_stdout = NULL

GTEST_API_ ThreadLocal< Sequence * >	g_gmock_implicit_sequence

bool	g_help_flag = false

class testing::internal::GTestFlagSaver	GTEST_ATTRIBUTE_UNUSED_

const char	kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"

static constexpr char	kBase64 []

const char	kBreakOnFailureFlag [] = "break_on_failure"

const char	kCatchExceptionsFlag [] = "catch_exceptions"

static const char	kColorEncodedHelpMessage []

static const char	kColorEncodedHelpMessage []

static const char	kColorEncodedHelpMessage []

static const char	kColorEncodedHelpMessage []

static const char	kColorEncodedHelpMessage []

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	kFlagfileFlag [] = "flagfile"

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	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 TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()

const char	kThrowOnFailureFlag [] = "throw_on_failure"

const int	kTypedTests = 0

const int	kTypedTestSuites = 0

static const char	kTypeParamLabel [] = "TypeParam"

static const char	kTypeParamLabel [] = "TypeParam"

static const char	kTypeParamLabel [] = "TypeParam"

static const char	kTypeParamLabel [] = "TypeParam"

static const char	kTypeParamLabel [] = "TypeParam"

static const char	kTypeParamLabel [] = "TypeParam"

static constexpr std::array< char, 256 >	kUnBase64 = UnBase64(kBase64)

const char	kUnknownFile [] = "unknown file"

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

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

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

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

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

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

const char	kWarningVerbosity [] = "warning"

const typedef void *	TypeId

Typedef Documentation

◆ BiggestInt

typedef long long testing::internal::BiggestInt

Definition at line 1907 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ bool_constant

template<bool B>

using testing::internal::bool_constant = typedef std::integral_constant<bool, B>

Definition at line 1897 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ disjunction

template<typename P , typename Q >

using testing::internal::disjunction = typedef typename ::std::conditional<P::value, P, Q>::type

Definition at line 269 of file googletest/googlemock/include/gmock/gmock-actions.h.

◆ Double

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

Definition at line 397 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ ElementMatcherPair

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

Definition at line 8116 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ ElementMatcherPairs

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

Definition at line 8117 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ false_type

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

Definition at line 1956 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ Float

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

Definition at line 396 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ identity_t

template<typename T >

using testing::internal::identity_t = typedef T

Definition at line 50 of file googletest/googlemock/include/gmock/gmock-function-mocker.h.

◆ IndexSequenceFor

template<typename... T>

using testing::internal::IndexSequenceFor = typedef typename MakeIndexSequence<sizeof...(T)>::type

Definition at line 1192 of file boringssl-with-bazel/src/third_party/googletest/include/gtest/internal/gtest-internal.h.

◆ Int32

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

Definition at line 2159 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ Int64

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

Definition at line 2161 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ IsContainer

typedef int testing::internal::IsContainer

Definition at line 908 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ IsNotContainer

typedef char testing::internal::IsNotContainer

Definition at line 919 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ LosslessArithmeticConvertible

template<typename From , typename To >

using testing::internal::LosslessArithmeticConvertible = typedef LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To>

Definition at line 200 of file googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ LosslessArithmeticConvertibleImpl

template<TypeKind kFromKind, typename From , TypeKind kToKind, typename To >

using testing::internal::LosslessArithmeticConvertibleImpl = typedef std::integral_constant< bool, (kFromKind == kBool) ? true : (kFromKind != kToKind) ? false : (kFromKind == kInteger && (((sizeof(From) < sizeof(To)) && !(std::is_signed<From>::value && !std::is_signed<To>::value)) || ((sizeof(From) == sizeof(To)) && (std::is_signed<From>::value == std::is_signed<To>::value))) ) ? true : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true : false >

Definition at line 188 of file googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ MakeIndexSequence

template<size_t N>

using testing::internal::MakeIndexSequence = typedef typename MakeIndexSequenceImpl<N>::type

Definition at line 1189 of file boringssl-with-bazel/src/third_party/googletest/include/gtest/internal/gtest-internal.h.

◆ MutexLock

typedef GTestMutexLock testing::internal::MutexLock

Definition at line 1875 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ ParameterizedTestCaseInfo

template<class TestCase >

using testing::internal::ParameterizedTestCaseInfo = typedef ParameterizedTestSuiteInfo<TestCase>

Definition at line 648 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h.

◆ SetUpTearDownSuiteFuncType

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

Definition at line 492 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ SetUpTestCaseFunc

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

Definition at line 8236 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ SetUpTestSuiteFunc

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

Definition at line 477 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ string

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

Definition at line 881 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ Strings

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

Definition at line 872 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ TearDownTestCaseFunc

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

Definition at line 8237 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ TearDownTestSuiteFunc

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

Definition at line 478 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ TimeInMillis

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

Definition at line 2163 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ true_type

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

Definition at line 1957 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ TypedTestCasePState

using testing::internal::TypedTestCasePState = typedef TypedTestSuitePState

Definition at line 647 of file googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ TypeIsValidNullptrConstant

template<typename T >

using testing::internal::TypeIsValidNullptrConstant = typedef std::integral_constant< bool, std::is_same<typename std::decay<T>::type, std::nullptr_t>::value || !std::is_convertible<T, Secret*>::value>

Definition at line 133 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ UInt32

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

Definition at line 2160 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ UInt64

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

Definition at line 2162 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ wstring

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

Definition at line 887 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

Enumeration Type Documentation

◆ CallReaction

enum testing::internal::CallReaction

Enumerator
kAllow
kWarn
kFail
kDefault

Definition at line 9539 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ CharFormat [1/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 125 of file boringssl-with-bazel/src/third_party/googletest/src/gtest-printers.cc.

◆ CharFormat [2/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 127 of file bloaty/third_party/protobuf/third_party/googletest/googletest/src/gtest-printers.cc.

◆ CharFormat [3/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 127 of file protobuf/third_party/googletest/googletest/src/gtest-printers.cc.

◆ CharFormat [4/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 128 of file bloaty/third_party/googletest/googletest/src/gtest-printers.cc.

◆ CharFormat [5/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 139 of file googletest/googletest/src/gtest-printers.cc.

◆ CharFormat [6/6]

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape
kAsIs
kHexEscape
kSpecialEscape

Definition at line 9934 of file gmock-gtest-all.cc.

◆ DefaultPrinterType [1/3]

enum testing::internal::DefaultPrinterType

Enumerator
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther

Definition at line 395 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ DefaultPrinterType [2/3]

enum testing::internal::DefaultPrinterType

Enumerator
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther

Definition at line 404 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ DefaultPrinterType [3/3]

enum testing::internal::DefaultPrinterType

Enumerator
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther
kPrintContainer
kPrintPointer
kPrintFunctionPointer
kPrintOther

Definition at line 404 of file protobuf/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ GTestColor [1/4]

enum testing::internal::GTestColor

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

Definition at line 1805 of file bloaty/third_party/googletest/googletest/include/gtest/gtest.h.

◆ GTestColor [2/4]

enum testing::internal::GTestColor

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

Definition at line 1832 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/gtest.h.

◆ GTestColor [3/4]

enum testing::internal::GTestColor

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

Definition at line 1832 of file protobuf/third_party/googletest/googletest/include/gtest/gtest.h.

◆ GTestColor [4/4]

enum testing::internal::GTestColor

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

Definition at line 4328 of file gmock-gtest-all.cc.

◆ GTestLogSeverity [1/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 948 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ GTestLogSeverity [2/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 953 of file boringssl-with-bazel/src/third_party/googletest/include/gtest/internal/gtest-port.h.

◆ GTestLogSeverity [3/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 970 of file googletest/googletest/include/gtest/internal/gtest-port.h.

◆ GTestLogSeverity [4/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 985 of file bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ GTestLogSeverity [5/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 985 of file protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ GTestLogSeverity [6/6]

enum testing::internal::GTestLogSeverity

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

Definition at line 2519 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ LogSeverity [1/5]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 251 of file googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ LogSeverity [2/5]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 294 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ LogSeverity [3/5]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 310 of file bloaty/third_party/protobuf/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ LogSeverity [4/5]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 310 of file protobuf/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ LogSeverity [5/5]

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning
kInfo
kWarning

Definition at line 818 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ TypeKind [1/5]

enum testing::internal::TypeKind

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

Definition at line 111 of file googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ TypeKind [2/5]

enum testing::internal::TypeKind

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

Definition at line 114 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ TypeKind [3/5]

enum testing::internal::TypeKind

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

Definition at line 130 of file protobuf/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ TypeKind [4/5]

enum testing::internal::TypeKind

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

Definition at line 130 of file bloaty/third_party/protobuf/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ TypeKind [5/5]

enum testing::internal::TypeKind

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

Definition at line 638 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

Function Documentation

◆ AdjustConstness_()

template<typename MockType >

MockType * testing::internal::AdjustConstness_ ( const MockType * mock )

Definition at line 100 of file bloaty/third_party/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.

◆ AdjustConstness_const()

template<typename MockType >

const MockType * testing::internal::AdjustConstness_const ( const MockType * mock )

Definition at line 93 of file bloaty/third_party/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

Definition at line 817 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ AlwaysTrue()

bool testing::internal::AlwaysTrue ( )

Definition at line 5712 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ AppendUserMessage()

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

Definition at line 2018 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ Apply()

template<typename F , typename Tuple >

auto testing::internal::Apply	(	F &&	f,
		Tuple &&	args
	)		-> decltype(ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), MakeIndexSequence<std::tuple_size<Tuple>::value>()))

Definition at line 472 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ ApplyImpl() [1/2]

template<typename F , typename Tuple , size_t... Idx>

auto testing::internal::ApplyImpl	(	F &&	f,
		Tuple &&	args,
		IndexSequence< Idx... >
	)		-> decltype( std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...))

Definition at line 465 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ ApplyImpl() [2/2]

template<typename F , typename Tuple , size_t... Idx>

auto testing::internal::ApplyImpl	(	F &&	f,
		Tuple &&	args,
		int_pack< Idx... >
	)		-> decltype( std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...))

Definition at line 518 of file bloaty/third_party/protobuf/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ ArrayAwareFind()

template<typename Iter , typename Element >

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

Definition at line 1007 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ ArrayEq() [1/3]

template<typename T , typename U >

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

inline

Definition at line 984 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ ArrayEq() [2/3]

template<typename T , typename U >

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

Definition at line 996 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ ArrayEq() [3/3]

template<typename T , typename U , size_t N>

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

inline

Definition at line 988 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ Assert() [1/2]

template<typename From , typename To >

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

inline

Definition at line 276 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ Assert() [2/2]

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

inline

Definition at line 226 of file googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ Base64Unescape()

bool testing::internal::Base64Unescape	(	const std::string &	encoded,
		std::string *	decoded
	)

Definition at line 227 of file googletest/googlemock/src/gmock-internal-utils.cc.

◆ BoolFromGTestEnv()

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

Definition at line 1334 of file bloaty/third_party/googletest/googletest/src/gtest-port.cc.

◆ CanonicalizeForStdLibVersioning()

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

inline

Definition at line 64 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h.

◆ CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr ( )

Definition at line 9591 of file gmock-gtest-all.cc.

◆ CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout ( )

Definition at line 9586 of file gmock-gtest-all.cc.

◆ CaptureStream()

void testing::internal::CaptureStream	(	int	fd,
		const char *	stream_name,
		CapturedStream **	stream
	)

Definition at line 9567 of file gmock-gtest-all.cc.

◆ CaseInsensitiveCStringEquals() [1/2]

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

inline

Definition at line 5909 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ CaseInsensitiveCStringEquals() [2/2]

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

inline

Definition at line 5913 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ CaseInsensitiveStringEquals()

template<typename StringType >

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

Definition at line 5921 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ CheckedDowncastToActualType()

template<class Derived , class Base >

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

Definition at line 1107 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ ChopLowBits() [1/2]

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

inline

Definition at line 1758 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ ChopLowBits() [2/2]

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

inline

Definition at line 1916 of file boringssl-with-bazel/src/third_party/googletest/src/gtest.cc.

◆ CmpHelperEQ() [1/2]

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

Definition at line 1450 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperEQ() [2/2]

template<typename T1 , typename T2 >

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

Definition at line 1522 of file bloaty/third_party/googletest/googletest/include/gtest/gtest.h.

◆ CmpHelperEQFailure()

template<typename T1 , typename T2 >

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

Definition at line 1503 of file bloaty/third_party/googletest/googletest/include/gtest/gtest.h.

◆ CmpHelperFloatingPointEQ()

template<typename RawType >

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

Definition at line 1729 of file bloaty/third_party/googletest/googletest/include/gtest/gtest.h.

◆ CmpHelperOpFailure()

template<typename T1 , typename T2 >

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

Definition at line 1584 of file bloaty/third_party/googletest/googletest/include/gtest/gtest.h.

◆ CmpHelperSTRCASEEQ()

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

Definition at line 1516 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperSTRCASENE()

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

Definition at line 1546 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperSTREQ() [1/2]

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

Definition at line 1500 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperSTREQ() [2/2]

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

Definition at line 1883 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperSTRNE() [1/2]

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

Definition at line 1532 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CmpHelperSTRNE() [2/2]

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

Definition at line 1899 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CodePointToUtf8() [1/2]

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

Definition at line 1770 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ CodePointToUtf8() [2/2]

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

Definition at line 1928 of file boringssl-with-bazel/src/third_party/googletest/src/gtest.cc.

◆ ColoredPrintf()

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

Definition at line 3036 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ ConvertIdentifierNameToWords()

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

Definition at line 72 of file bloaty/third_party/googletest/googlemock/src/gmock-internal-utils.cc.

◆ CopyArray() [1/3]

template<typename T , typename U >

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

inline

Definition at line 1024 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ CopyArray() [2/3]

template<typename T , typename U >

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

Definition at line 1036 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ CopyArray() [3/3]

template<typename T , typename U , size_t N>

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

inline

Definition at line 1028 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h.

◆ CopyElements()

template<typename InputIterator , typename OutputIterator >

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

inline

Definition at line 53 of file bloaty/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h.

◆ CountIf()

template<class Container , typename Predicate >

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

inline

Definition at line 690 of file gmock-gtest-all.cc.

◆ CreateCodePointFromUtf16SurrogatePair()

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

inline

Definition at line 1811 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ DefaultParamName()

template<class ParamType >

std::string testing::internal::DefaultParamName ( const TestParamInfo< ParamType > & info )

Definition at line 374 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h.

◆ DefaultPrintTo() [1/7]

template<typename C >

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

Definition at line 10429 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ DefaultPrintTo() [2/7]

template<typename T >

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

Definition at line 10495 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ DefaultPrintTo() [3/7]

template<typename T >

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

Definition at line 10463 of file cares/cares/test/gmock-1.8.0/gtest/gtest.h.

◆ DefaultPrintTo() [4/7]

template<typename C >

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

Definition at line 406 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ DefaultPrintTo() [5/7]

template<typename T >

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

Definition at line 451 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ DefaultPrintTo() [6/7]

template<typename T >

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

Definition at line 466 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ DefaultPrintTo() [7/7]

template<typename T >

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

Definition at line 439 of file bloaty/third_party/googletest/googletest/include/gtest/gtest-printers.h.

◆ Delete() [1/2]

template<typename T >

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

static

Definition at line 333 of file googletest/googletest/src/gtest-internal-inl.h.

◆ Delete() [2/2]

template<typename T >

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

static

Definition at line 747 of file gmock-gtest-all.cc.

◆ DiffStrings()

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

◆ DoubleNearPredFormat()

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

Definition at line 1377 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ DownCast_()

template<typename To , typename From >

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

inline

Definition at line 1082 of file bloaty/third_party/googletest/googletest/include/gtest/internal/gtest-port.h.

◆ EndsWith()

template<int N, int M>

constexpr bool testing::internal::EndsWith	(	const char(&)	suffix[N],
		const char(&)	str[M]
	)

constexpr

Definition at line 78 of file googletest/googlemock/include/gmock/gmock-function-mocker.h.

◆ EqFailure()

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

Definition at line 1326 of file bloaty/third_party/googletest/googletest/src/gtest.cc.

◆ Equals()

template<int N, int M>

constexpr bool testing::internal::Equals	(	const char(&)	a[N],
		const char(&)	b[M]
	)

constexpr

Definition at line 83 of file googletest/googlemock/include/gmock/gmock-function-mocker.h.

◆ Expect() [1/3]

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

inline

Definition at line 289 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ Expect() [2/3]

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

inline

Definition at line 282 of file bloaty/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h.

◆ Expect() [3/3]

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

inline

Definition at line 806 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ ExplainMatchFailureTupleTo()

template<typename MatcherTuple , typename ValueTuple >

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

Definition at line 5629 of file cares/cares/test/gmock-1.8.0/gmock/gmock.h.

◆ FindMaxBipartiteMatching()

GTEST_API_ ElementMatcherPairs testing::internal::FindMaxBipartiteMatching ( const MatchMatrix & g )

Definition at line 228 of file bloaty/third_party/googletest/googlemock/src/gmock-matchers.cc.