Namespaces
	edit_distance

	internal_stream_operator_without_lexical_name_lookup

	posix

Classes
struct	ActionImpl

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

class	AssertHelper

class	AssignAction

class	BuiltInDefaultValue

class	BuiltInDefaultValue< const T >

class	BuiltInDefaultValue< T * >

struct	BuiltInDefaultValueGetter

struct	BuiltInDefaultValueGetter< T, false >

struct	ByMoveWrapper

class	CartesianProductGenerator

class	CartesianProductHolder

struct	CodeLocation

struct	conjunction

struct	conjunction< P1 >

struct	conjunction< P1, Ps... >

struct	ConstCharPtr

struct	ConstRef

struct	ConstRef< T & >

struct	ContainerPrinter

struct	ConvertibleToIntegerPrinter

struct	ConvertibleToStringViewPrinter

class	DefaultGlobalTestPartResultReporter

struct	DefaultNameGenerator

class	DefaultPerThreadTestPartResultReporter

struct	DeleteArgAction

struct	disjunction

struct	disjunction< P1 >

struct	disjunction< P1, Ps... >

class	DoAllAction

class	DoAllAction< FinalAction >

class	DoAllAction< InitialAction, OtherActions... >

class	DoDefaultAction

struct	DoubleSequence

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

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

struct	ElemFromList

struct	ElemFromListImpl

struct	ElemFromListImpl< IndexSequence< I... > >

class	EqHelper

struct	ExcessiveArg

class	FailureReporterInterface

struct	faketype

struct	FallbackPrinter

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	FloatingPoint

class	FormatForComparison

class	FormatForComparison< ToPrint[N], OtherOperand >

struct	Function

struct	Function< R(Args...)>

struct	FunctionPointerPrinter

struct	GenerateTypeList

class	GTestFlagSaver

class	GTestLog

class	GTestMutexLock

class	GTestNonCopyable

class	HasDebugStringAndShortDebugString

struct	Ignore

class	IgnoredValue

class	IgnoreResultAction

struct	ImplBase

struct	IndexSequence

struct	InvokeArgumentAction

struct	InvokeMethodAction

struct	InvokeMethodWithoutArgsAction

struct	InvokeWithoutArgsAction

struct	is_callable_r_impl

struct	is_callable_r_impl< void_t< call_result_t< F, Args... > >, R, F, Args... >

struct	is_implicitly_convertible

struct	is_proxy_type_list

struct	is_proxy_type_list< ProxyTypeList< Ts... > >

class	IsEmptyMatcher

struct	IsHashTable

struct	IsRecursiveContainer

struct	IsRecursiveContainerImpl

struct	IsRecursiveContainerImpl< C, false >

struct	IsRecursiveContainerImpl< C, true >

struct	KindOf

struct	MakeIndexSequenceImpl

struct	MakeIndexSequenceImpl< 0 >

struct	MarkAsIgnored

class	Mutex

class	NaggyMockImpl

struct	NameGeneratorSelector

class	NativeArray

struct	negation

class	NiceMockImpl

struct	None

class	OsStackTraceGetter

class	OsStackTraceGetterInterface

class	ParamConverterGenerator

class	ParameterizedTestFactory

class	ParameterizedTestSuiteInfo

class	ParameterizedTestSuiteInfoBase

class	ParameterizedTestSuiteRegistry

class	ParamGenerator

class	ParamGeneratorConverter

class	ParamGeneratorInterface

class	ParamIterator

class	ParamIteratorInterface

struct	PointerPrinter

struct	ProtobufPrinter

struct	ProxyTypeList

class	Random

class	RangeGenerator

struct	RawBytesPrinter

class	RE

struct	RelationToSourceCopy

struct	RelationToSourceReference

struct	RemoveConstFromKey

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

class	ReturnAction

class	ReturnAction< ByMoveWrapper< T > >

struct	ReturnArgAction

struct	ReturnNewAction

class	ReturnNullAction

struct	ReturnPointeeAction

class	ReturnRefAction

class	ReturnRefOfCopyAction

class	ReturnRoundRobinAction

class	ReturnVoidAction

struct	SaveArgAction

struct	SaveArgPointeeAction

struct	SetArgRefereeAction

struct	SetArgumentPointeeAction

struct	SetArrayArgumentAction

class	SetErrnoAndReturnAction

class	StlContainerView

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

class	StlContainerView< Element[N]>

class	StrictMockImpl

class	String

struct	SuiteApiResolver

struct	Templates

struct	Templates< Head_ >

struct	TemplateSel

class	TestFactoryBase

class	TestFactoryImpl

class	TestMetaFactory

class	TestMetaFactoryBase

class	TestPropertyKeyIs

class	TestResultAccessor

struct	ThisRefAdjuster

class	ThreadLocal

struct	TraceInfo

struct	TrueWithString

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	UnitTestImpl

class	UnitTestOptions

class	UniversalPrinter

class	UniversalPrinter< const T >

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

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< std::reference_wrapper< T > >

class	UniversalTersePrinter< T & >

class	UniversalTersePrinter< T[N]>

class	UniversalTersePrinter< wchar_t * >

class	ValueArray

class	ValuesInIteratorRangeGenerator

struct	WithArgsAction

class	WithoutMatchers

Typedefs
template<typename... >
using	void_t = void

template<typename F , typename... Args>
using	call_result_t = decltype(std::declval< F >()(std::declval< Args >()...))

template<typename R , typename F , typename... Args>
using	is_callable_r = is_callable_r_impl< void, R, F, Args... >

template<typename T >
using	identity_t = T

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<typename From , typename To >
using	LosslessArithmeticConvertible = LosslessArithmeticConvertibleImpl< GMOCK_KIND_OF_(From), From, GMOCK_KIND_OF_(To), To >

template<size_t I, typename T >
using	TupleElement = typename std::tuple_element< I, T >::type

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

typedef FloatingPoint< float >	Float

typedef FloatingPoint< double >	Double

typedef const void *	TypeId

using	SetUpTestSuiteFunc = void(*)()

using	TearDownTestSuiteFunc = void(*)()

using	SetUpTearDownSuiteFuncType = void(*)()

using	TypedTestCasePState = TypedTestSuitePState

typedef int	IsContainer

typedef char	IsNotContainer

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

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

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

typedef GTestMutexLock	MutexLock

using	BiggestInt = long long

using	TimeInMillis = int64_t

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

enum	LogSeverity { kInfo = 0, kWarning = 1 }

enum	GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }

Functions
	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (void,)

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

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (bool, false)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (char, '\0')

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned short, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed short, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long long, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long long, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (float, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (double, 0)

template<typename T >
std::add_const< T >::type &	as_const (T &t)

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

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

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

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

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

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

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

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

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

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

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

std::false_type	StrictnessModifierProbe (...)

template<typename T >
constexpr bool	HasStrictnessModifier ()

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

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

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)

	GMOCK_DECLARE_KIND_ (bool, kBool)

	GMOCK_DECLARE_KIND_ (char, kInteger)

	GMOCK_DECLARE_KIND_ (signed char, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)

	GMOCK_DECLARE_KIND_ (short, kInteger)

	GMOCK_DECLARE_KIND_ (int, kInteger)

	GMOCK_DECLARE_KIND_ (long, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned long long, kInteger)

	GMOCK_DECLARE_KIND_ (wchar_t, kInteger)

	GMOCK_DECLARE_KIND_ (float, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (double, kFloatingPoint)

	GMOCK_DECLARE_KIND_ (long double, kFloatingPoint)

GTEST_API_ FailureReporterInterface *	GetFailureReporter ()

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

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

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

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

GTEST_API_ bool	LogIsVisible (LogSeverity severity)

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

GTEST_API_ WithoutMatchers	GetWithoutMatchers ()

template<typename T >
T	Invalid ()

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

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 >
auto	Apply (F &&f, Tuple &&args) -> decltype(ApplyImpl(std::forward< F >(f), std::forward< Tuple >(args), MakeIndexSequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >()))

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

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

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

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

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

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)

	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char16_t)

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

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

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

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

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

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

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

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

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

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

template<typename FloatType >
int	AppropriateResolution (FloatType val)

void	PrintTo (float f, ::std::ostream *os)

void	PrintTo (double d, ::std::ostream *os)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	PrintTo (std::nullptr_t, ::std::ostream *os)

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

const void *	VoidifyPointer (const void *p)

const void *	VoidifyPointer (volatile const void *p)

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)

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

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

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

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

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

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

template<typename T >
void	UniversalPrintArray (const T begin, size_t len, ::std::ostream os)

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

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

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

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

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

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)

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

class UnitTestImpl *	GetUnitTestImpl ()

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

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

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

bool	operator== (faketype, faketype)

bool	operator!= (faketype, faketype)

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	CmpHelperOpFailure (const char expr1, const char expr2, const T1 &val1, const T2 &val2, const char *op)

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

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

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

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

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

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

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

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

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

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

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

template<typename T >
TypeId	GetTypeId ()

GTEST_API_ TypeId	GetTestTypeId ()

SetUpTearDownSuiteFuncType	GetNotDefaultOrNull (SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def)

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)

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

	GTEST_DISABLE_MSC_WARNINGS_PUSH_ (4251) class GTEST_API_ TypedTestSuitePState

	GTEST_DISABLE_MSC_WARNINGS_POP_ () inline const char SkipComma(const char str)

std::string	GetPrefixUntilComma (const char *str)

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

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)

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

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

GTEST_API_ void	RegisterTypeParameterizedTestSuiteInstantiation (const char *case_name)

GTEST_API_ std::string	GetCurrentOsStackTraceExceptTop (int skip_count)

GTEST_API_ bool	AlwaysTrue ()

bool	AlwaysFalse ()

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 >
IsNotContainer	IsContainerTest (long)

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

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

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

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

template<typename T , typename U >
void	CopyArray (const T from, size_t size, U to)

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

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

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

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

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

	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 ("INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TYPED_TEST_SUITE_P") const expr bool InstantiateTypedTestCase_P_IsDeprecated()

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

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

template<typename T = int>
void	TestNotEmpty ()

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

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

GTEST_API_ bool	IsTrue (bool condition)

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

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

void	LogToStderr ()

void	FlushInfoLog ()

template<typename To >
To	ImplicitCast_ (To x)

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

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

GTEST_API_ void	CaptureStdout ()

GTEST_API_ std::string	GetCapturedStdout ()

GTEST_API_ void	CaptureStderr ()

GTEST_API_ std::string	GetCapturedStderr ()

GTEST_API_ size_t	GetFileSize (FILE *file)

GTEST_API_ std::string	ReadEntireFile (FILE *file)

GTEST_API_ std::vector< std::string >	GetArgvs ()

GTEST_API_ size_t	GetThreadCount ()

bool	IsAlpha (char ch)

bool	IsAlNum (char ch)

bool	IsDigit (char ch)

bool	IsLower (char ch)

bool	IsSpace (char ch)

bool	IsUpper (char ch)

bool	IsXDigit (char ch)

bool	IsXDigit (char16_t ch)

bool	IsXDigit (char32_t ch)

bool	IsXDigit (wchar_t ch)

char	ToLower (char ch)

char	ToUpper (char ch)

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

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

bool	BoolFromGTestEnv (const char *flag, bool default_val)

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

std::string	OutputFlagAlsoCheckEnvVar ()

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

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

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

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

GTEST_API_ TimeInMillis	GetTimeInMillis ()

GTEST_API_ bool	ShouldUseColor (bool stdout_is_tty)

GTEST_API_ std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)

GTEST_API_ std::string	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)

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

int	GetRandomSeedFromFlag (int32_t random_seed_flag)

int	GetNextRandomSeed (int seed)

GTEST_API_ std::string	CodePointToUtf8 (uint32_t code_point)

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

void	WriteToShardStatusFileIfNeeded ()

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

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

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

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

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

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

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

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

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, char *argv)

GTEST_API_ void	ParseGoogleTestFlagsOnly (int argc, wchar_t *argv)

Variables
const char	kInfoVerbosity [] = "info"

const char	kWarningVerbosity [] = "warning"

const char	kErrorVerbosity [] = "error"

const char	kDeathTestStyleFlag [] = "death_test_style"

const char	kDeathTestUseFork [] = "death_test_use_fork"

const char	kInternalRunDeathTestFlag [] = "internal_run_death_test"

GTEST_API_ const char	kStackTraceMarker []

constexpr BiggestInt	kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)()

GTEST_API_ const TypeId	kTestTypeIdInGoogleTest

const int	kMaxRandomSeed = 99999

GTEST_API_ bool	g_help_flag

Typedef Documentation

◆ BiggestInt

using testing::internal::BiggestInt = typedef long long

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

◆ call_result_t

template<typename F , typename... Args>

using testing::internal::call_result_t = typedef decltype(std::declval<F>()(std::declval<Args>()...))

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

◆ Double

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

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

◆ Float

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

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

◆ identity_t

template<typename T >

using testing::internal::identity_t = typedef T

Definition at line 50 of file gmock-function-mocker.h.

◆ IndexSequenceFor

template<typename... T>

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

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

◆ is_callable_r

template<typename R , typename F , typename... Args>

using testing::internal::is_callable_r = typedef is_callable_r_impl<void, R, F, Args...>

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

◆ IsContainer

typedef int testing::internal::IsContainer

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

◆ IsNotContainer

typedef char testing::internal::IsNotContainer

Definition at line 955 of file 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 222 of file 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 210 of file gmock-internal-utils.h.

◆ MakeIndexSequence

template<size_t N>

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

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

◆ MutexLock

typedef GTestMutexLock testing::internal::MutexLock

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

◆ ParameterizedTestCaseInfo

template<class TestCase >

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

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

◆ SetUpTearDownSuiteFuncType

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

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

◆ SetUpTestSuiteFunc

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

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

◆ Strings

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

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

◆ TearDownTestSuiteFunc

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

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

◆ TimeInMillis

using testing::internal::TimeInMillis = typedef int64_t

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

◆ TupleElement

template<size_t I, typename T >

using testing::internal::TupleElement = typedef typename std::tuple_element<I, T>::type

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

◆ TypedTestCasePState

using testing::internal::TypedTestCasePState = typedef TypedTestSuitePState

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

◆ TypeId

typedef const void* testing::internal::TypeId

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

◆ void_t

template<typename... >

using testing::internal::void_t = typedef void

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

Enumeration Type Documentation

◆ GTestLogSeverity

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

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

977 { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL };

testing::internal::GTEST_WARNING

Definition: gtest-port.h:977

testing::internal::GTEST_FATAL

Definition: gtest-port.h:977

testing::internal::GTEST_ERROR

Definition: gtest-port.h:977

testing::internal::GTEST_INFO

Definition: gtest-port.h:977

◆ LogSeverity

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning

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

271 { kInfo = 0, kWarning = 1 };

testing::internal::kWarning

Definition: gmock-internal-utils.h:271

testing::internal::kInfo

Definition: gmock-internal-utils.h:271

◆ TypeKind

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

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

131 { kBool, kInteger, kFloatingPoint, kOther };

testing::internal::kOther

Definition: gmock-internal-utils.h:131

testing::internal::kFloatingPoint

Definition: gmock-internal-utils.h:131

testing::internal::kBool

Definition: gmock-internal-utils.h:131

testing::internal::kInteger

Definition: gmock-internal-utils.h:131

Function Documentation

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

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

843 { return !AlwaysTrue(); }

testing::internal::AlwaysTrue

GTEST_API_ bool AlwaysTrue()

◆ AlwaysTrue()

GTEST_API_ bool testing::internal::AlwaysTrue ( )

◆ AppendUserMessage()

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

◆ 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< typename std::remove_reference<Tuple>::type>::value>()))

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

                                                            {
   return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
                    MakeIndexSequence<std::tuple_size<
                        typename std::remove_reference<Tuple>::type>::value>());
 }

◆ ApplyImpl()

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 426 of file gmock-internal-utils.h.

                                                   {
   return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
 }

◆ AppropriateResolution()

template<typename FloatType >

int testing::internal::AppropriateResolution ( FloatType val )

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

                                          {
   int full = std::numeric_limits<FloatType>::max_digits10;
   if (val < 0) val = -val;
 
   if (val < 1000000) {
     FloatType mulfor6 = 1e10;
     if (val >= 100000.0) {  // 100,000 to 999,999
       mulfor6 = 1.0;
     } else if (val >= 10000.0) {
       mulfor6 = 1e1;
     } else if (val >= 1000.0) {
       mulfor6 = 1e2;
     } else if (val >= 100.0) {
       mulfor6 = 1e3;
     } else if (val >= 10.0) {
       mulfor6 = 1e4;
     } else if (val >= 1.0) {
       mulfor6 = 1e5;
     } else if (val >= 0.1) {
       mulfor6 = 1e6;
     } else if (val >= 0.01) {
       mulfor6 = 1e7;
     } else if (val >= 0.001) {
       mulfor6 = 1e8;
     } else if (val >= 0.0001) {
       mulfor6 = 1e9;
     }
     if (static_cast<int32_t>(val * mulfor6 + 0.5) / mulfor6 == val) return 6;
   } else if (val < 1e10) {
     FloatType divfor6 = 1.0;
     if (val >= 1e9) {  // 1,000,000,000 to 9,999,999,999
       divfor6 = 10000;
     } else if (val >= 1e8) {  // 100,000,000 to 999,999,999
       divfor6 = 1000;
     } else if (val >= 1e7) {  // 10,000,000 to 99,999,999
       divfor6 = 100;
     } else if (val >= 1e6) {  // 1,000,000 to 9,999,999
       divfor6 = 10;
     }
     if (static_cast<int32_t>(val / divfor6 + 0.5) * divfor6 == val) return 6;
   }
   return full;
 }

◆ ArrayAwareFind()

template<typename Iter , typename Element >

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

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

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

◆ ArrayEq() [1/3]

template<typename T , typename U >

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

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

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

◆ ArrayEq() [2/3]

template<typename T , typename U >

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

inline

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

                                                 {
   return lhs == rhs;
 }

◆ ArrayEq() [3/3]

template<typename T , typename U , size_t N>

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

inline

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

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

◆ as_const()

template<typename T >

std::add_const<T>::type& testing::internal::as_const ( T & t )

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

                                              {
   return t;
 }

◆ Assert() [1/2]

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

inline

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

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

◆ Assert() [2/2]

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

inline

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

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

◆ Base64Unescape()

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

◆ BoolFromGTestEnv()

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

◆ CanonicalizeForStdLibVersioning()

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

inline

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

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

◆ CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr ( )

◆ CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout ( )

◆ CheckedDowncastToActualType()

template<class Derived , class Base >

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

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

                                                  {
 #if GTEST_HAS_RTTI
   GTEST_CHECK_(typeid(*base) == typeid(Derived));
 #endif
 
 #if GTEST_HAS_DOWNCAST_
   return ::down_cast<Derived*>(base);
 #elif GTEST_HAS_RTTI
   return dynamic_cast<Derived*>(base);  // NOLINT
 #else
   return static_cast<Derived*>(base);  // Poor man's downcast.
 #endif
 }

◆ CmpHelperEQ()

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

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

◆ CmpHelperEQFailure()

template<typename T1 , typename T2 >

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

Definition at line 1354 of file gtest.h.

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

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

                                                                                {
   const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
 
   if (lhs.AlmostEquals(rhs)) {
     return AssertionSuccess();
   }
 
   ::std::stringstream lhs_ss;
   lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << lhs_value;
 
   ::std::stringstream rhs_ss;
   rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << rhs_value;
 
   return EqFailure(lhs_expression, rhs_expression,
                    StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
                    false);
 }

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

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

◆ CmpHelperSTRCASEEQ()

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

◆ CmpHelperSTRCASENE()

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

◆ CmpHelperSTREQ() [1/2]

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

◆ CmpHelperSTREQ() [2/2]

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

◆ CmpHelperSTRNE() [1/2]

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

◆ CmpHelperSTRNE() [2/2]

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

◆ CodePointToUtf8()

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

◆ ConvertIdentifierNameToWords()

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

◆ CopyArray() [1/3]

template<typename T , typename U >

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

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

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

◆ CopyArray() [2/3]

template<typename T , typename U >

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

inline

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

                                             {
   *to = from;
 }

◆ 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 1068 of file gtest-internal.h.

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

◆ CountIf()

template<class Container , typename Predicate >

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

inline

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

                                                             {
   // Implemented as an explicit loop since std::count_if() in libCstd on
   // Solaris has a non-standard signature.
   int count = 0;
   for (auto it = c.begin(); it != c.end(); ++it) {
     if (predicate(*it)) ++count;
   }
   return count;
 }

◆ DefaultParamName()

template<class ParamType >

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

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

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

◆ DoubleNearPredFormat()

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

◆ DownCast_()

template<typename To , typename From >

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

inline

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

                              {         // so we only accept pointers
   // Ensures that To is a sub-type of From *.  This test is here only
   // for compile-time type checking, and has no overhead in an
   // optimized build at run-time, as it will be optimized away
   // completely.
   GTEST_INTENTIONAL_CONST_COND_PUSH_()
   if (false) {
     GTEST_INTENTIONAL_CONST_COND_POP_()
     const To to = nullptr;
     ::testing::internal::ImplicitCast_<From*>(to);
   }
 
 #if GTEST_HAS_RTTI
   // RTTI: debug mode only!
   GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
 #endif
   return static_cast<To>(f);
 }

◆ EndsWith()

template<int N, int M>

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

Definition at line 78 of file gmock-function-mocker.h.

                                                                        {
   return N <= M && internal::PrefixOf(suffix, str + M - N);
 }

◆ EqFailure()

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

◆ Equals()

template<int N, int M>

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

Definition at line 83 of file gmock-function-mocker.h.

                                                               {
   return N == M && internal::PrefixOf(a, b);
 }

◆ Expect() [1/2]

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

inline

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

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

◆ Expect() [2/2]

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

inline

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

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

◆ FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

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

1006 { fflush(nullptr); }

◆ ForEach()

template<class Container , typename Functor >

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

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

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

◆ FormatCompilerIndependentFileLocation()

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

◆ FormatEpochTimeInMillisAsIso8601()

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

◆ FormatFileLocation()

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

◆ FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >

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

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

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

◆ FormatTimeInMillisAsSeconds()

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

◆ GenerateNames()

template<typename NameGenerator , typename Types >

std::vector<std::string> testing::internal::GenerateNames ( )

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

                                      {
   std::vector<std::string> result;
   GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
   return result;
 }

◆ GenerateNamesRecursively() [1/2]

template<typename NameGenerator >

void testing::internal::GenerateNamesRecursively	(	internal::None	,
		std::vector< std::string > *	,
		int
	)

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

688 {}

◆ GenerateNamesRecursively() [2/2]

template<typename NameGenerator , typename Types >

void testing::internal::GenerateNamesRecursively	(	Types	,
		std::vector< std::string > *	result,
		int	i
	)

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

                                                                           {
   result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
   GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
                                           i + 1);
 }

◆ GetArgvs()

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

◆ GetBoolAssertionFailureMessage()

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

◆ GetCapturedStderr()

GTEST_API_ std::string testing::internal::GetCapturedStderr ( )

◆ GetCapturedStdout()

GTEST_API_ std::string testing::internal::GetCapturedStdout ( )

◆ GetCurrentOsStackTraceExceptTop()

GTEST_API_ std::string testing::internal::GetCurrentOsStackTraceExceptTop ( int skip_count )

◆ GetElementOr()

template<typename E >

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

inline

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

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

◆ GetFailureReporter()

GTEST_API_ FailureReporterInterface* testing::internal::GetFailureReporter ( )

◆ GetFileSize()

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

◆ GetIgnoredParameterizedTestSuites()

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

◆ GetNextRandomSeed()

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

inline

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

                                        {
   GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
       << "Invalid random seed " << seed << " - must be in [1, "
       << kMaxRandomSeed << "].";
   const int next_seed = seed + 1;
   return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
 }

◆ GetNotDefaultOrNull()

SetUpTearDownSuiteFuncType testing::internal::GetNotDefaultOrNull	(	SetUpTearDownSuiteFuncType	a,
		SetUpTearDownSuiteFuncType	def
	)

inline

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

                                                                   {
   return a == def ? nullptr : a;
 }

◆ GetPrefixUntilComma()

std::string testing::internal::GetPrefixUntilComma ( const char * str )

inline

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

                                                       {
   const char* comma = strchr(str, ',');
   return comma == nullptr ? str : std::string(str, comma);
 }

◆ GetRandomSeedFromFlag()

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

inline

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

                                                            {
   const unsigned int raw_seed =
       (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
                               : static_cast<unsigned int>(random_seed_flag);
 
   // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
   // it's easy to type.
   const int normalized_seed =
       static_cast<int>((raw_seed - 1U) %
                        static_cast<unsigned int>(kMaxRandomSeed)) +
       1;
   return normalized_seed;
 }

◆ GetRawPointer() [1/3]

template<typename Pointer >

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

inline

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

                                                                            {
   return p.get();
 }

◆ GetRawPointer() [2/3]

template<typename Element >

const Element* testing::internal::GetRawPointer ( const std::reference_wrapper< Element > & r )

inline

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

                                                                             {
   return &r.get();
 }

◆ GetRawPointer() [3/3]

template<typename Element >

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

inline

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

                                           {
   return p;
 }

◆ GetTestTypeId()

GTEST_API_ TypeId testing::internal::GetTestTypeId ( )

◆ GetThreadCount()

GTEST_API_ size_t testing::internal::GetThreadCount ( )

◆ GetTimeInMillis()

GTEST_API_ TimeInMillis testing::internal::GetTimeInMillis ( )

◆ GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId ( )

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

                    {
   // The compiler is required to allocate a different
   // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
   // the template.  Therefore, the address of dummy_ is guaranteed to
   // be unique.
   return &(TypeIdHelper<T>::dummy_);
 }

◆ GetTypeName()

template<typename T >

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

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

                         {
 #if GTEST_HAS_RTTI
   return GetTypeName(typeid(T));
 #else
   return "<type>";
 #endif  // GTEST_HAS_RTTI
 }

◆ GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )

inline

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

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

◆ GetWithoutMatchers()

GTEST_API_ WithoutMatchers testing::internal::GetWithoutMatchers ( )

◆ GMOCK_DECLARE_KIND_() [1/12]

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

◆ GMOCK_DECLARE_KIND_() [2/12]

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

◆ GMOCK_DECLARE_KIND_() [3/12]

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

◆ GMOCK_DECLARE_KIND_() [4/12]

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

◆ GMOCK_DECLARE_KIND_() [5/12]

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

◆ GMOCK_DECLARE_KIND_() [6/12]

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

◆ GMOCK_DECLARE_KIND_() [7/12]

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

◆ GMOCK_DECLARE_KIND_() [8/12]

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

◆ GMOCK_DECLARE_KIND_() [9/12]

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

◆ GMOCK_DECLARE_KIND_() [10/12]

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

◆ GMOCK_DECLARE_KIND_() [11/12]

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

◆ GMOCK_DECLARE_KIND_() [12/12]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/14]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ ( void )

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/14]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/14]

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

◆ GTEST_DISABLE_MSC_WARNINGS_POP_()

testing::internal::GTEST_DISABLE_MSC_WARNINGS_POP_ ( ) const

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

                                               {
   const char* comma = strchr(str, ',');
   if (comma == nullptr) {
     return nullptr;
   }
   while (IsSpace(*(++comma))) {
   }
   return comma;
 }

◆ GTEST_DISABLE_MSC_WARNINGS_PUSH_()

testing::internal::GTEST_DISABLE_MSC_WARNINGS_PUSH_ ( 4251 )

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

                                       {
  public:
   TypedTestSuitePState() : registered_(false) {}
 
   // Adds the given test name to defined_test_names_ and return true
   // if the test suite hasn't been registered; otherwise aborts the
   // program.
   bool AddTestName(const char* file, int line, const char* case_name,
                    const char* test_name) {
     if (registered_) {
       fprintf(stderr,
               "%s Test %s must be defined before "
               "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
               FormatFileLocation(file, line).c_str(), test_name, case_name);
       fflush(stderr);
       posix::Abort();
     }
     registered_tests_.insert(
         ::std::make_pair(test_name, CodeLocation(file, line)));
     return true;
   }
 
   bool TestExists(const std::string& test_name) const {
     return registered_tests_.count(test_name) > 0;
   }
 
   const CodeLocation& GetCodeLocation(const std::string& test_name) const {
     RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
     GTEST_CHECK_(it != registered_tests_.end());
     return it->second;
   }
 
   // Verifies that registered_tests match the test names in
   // defined_test_names_; returns registered_tests if successful, or
   // aborts the program otherwise.
   const char* VerifyRegisteredTestNames(const char* test_suite_name,
                                         const char* file, int line,
                                         const char* registered_tests);
 
  private:
   typedef ::std::map<std::string, CodeLocation, std::less<>> RegisteredTestsMap;
 
   bool registered_;
   RegisteredTestsMap registered_tests_;
 };

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( wchar_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [3/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char16_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [4/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char32_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [1/3]

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

◆ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [2/3]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(	char16_t	,
		::std::u16string
	)

◆ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_() [3/3]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(	char32_t	,
		::std::u32string
	)

◆ GTEST_INTERNAL_DEPRECATED() [1/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"INSTANTIATE_TEST_CASE_P is	deprecated,
		please use " "INSTANTIATE_TEST_SUITE_P"
	)		const

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

1299 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [2/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"TYPED_TEST_CASE_P is	deprecated,
		please use " "TYPED_TEST_SUITE_P"
	)		const

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

1304 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [3/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"TYPED_TEST_CASE is	deprecated,
		please use " "TYPED_TEST_SUITE"
	)		const

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

1309 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [4/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"REGISTER_TYPED_TEST_CASE_P is	deprecated,
		please use " "REGISTER_TYPED_TEST_SUITE_P"
	)		const

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

1314 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [5/5]

testing::internal::GTEST_INTERNAL_DEPRECATED	(	"INSTANTIATE_TYPED_TEST_CASE_P is	deprecated,
		please use " "INSTANTIATE_TYPED_TEST_SUITE_P"
	)		const

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

1319 { return true; }

◆ HasStrictnessModifier()

template<typename T >

constexpr bool testing::internal::HasStrictnessModifier ( )

Definition at line 90 of file gmock-nice-strict.h.

                                        {
   return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
 }

◆ IllegalDoDefault()

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

◆ ImplicitCast_()

template<typename To >

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

inline

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

                               {
   return x;
 }

◆ InsertSyntheticTestCase()

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

◆ Int32FromEnvOrDie()

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

◆ Int32FromGTestEnv()

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

◆ Invalid()

template<typename T >

T testing::internal::Invalid ( )

inline

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

                    {
   Assert(false, "", -1, "Internal error: attempt to return invalid value");
 #if defined(__GNUC__) || defined(__clang__)
   __builtin_unreachable();
 #elif defined(_MSC_VER)
   __assume(0);
 #else
   return Invalid<T>();
 #endif
 }

◆ InvokeArgument()

template<typename F , typename... Args>

auto testing::internal::InvokeArgument	(	F	f,
		Args...	args
	)		-> decltype(f(args...))

Definition at line 597 of file gmock-more-actions.h.

                                                                {
   return f(args...);
 }

◆ IsAlNum()

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

inline

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

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

◆ IsAlpha()

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

inline

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

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

◆ IsContainerTest() [1/2]

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 testing::internal::IsContainerTest ( int )

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

                                    {
   return 0;
 }

◆ IsContainerTest() [2/2]

template<class C >

IsNotContainer testing::internal::IsContainerTest ( long )

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

                                        {
   return '\0';
 }

◆ IsDigit()

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

inline

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

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

◆ IsLower()

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

inline

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

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

◆ IsSpace()

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

inline

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

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

◆ IsTrue()

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

◆ IsUpper()

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

inline

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

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

◆ IsXDigit() [1/4]

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

inline

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

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

◆ IsXDigit() [2/4]

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

inline

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

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

◆ IsXDigit() [3/4]

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

inline

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

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

◆ IsXDigit() [4/4]

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

inline

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

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

◆ JoinAsKeyValueTuple()

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

◆ Log()

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

◆ LogIsVisible()

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

◆ LogToStderr()

void testing::internal::LogToStderr ( )

inline

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

1005 {}

◆ MakeAction() [1/2]

template<typename F , typename Impl >

::testing::Action<F> testing::internal::MakeAction ( )

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

                               {
   return ::testing::Action<F>(ActionImpl<F, Impl>());
 }

◆ MakeAction() [2/2]

template<typename F , typename Impl >

::testing::Action<F> testing::internal::MakeAction ( std::shared_ptr< Impl > impl )

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

                                                       {
   return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
 }

◆ MakeAndRegisterTestInfo()

GTEST_API_ TestInfo* testing::internal::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
	)

◆ operator!=()

bool testing::internal::operator!=	(	faketype	,
		faketype
	)

inline

Definition at line 1367 of file gtest.h.

1367 { return false; }

◆ operator==()

bool testing::internal::operator==	(	faketype	,
		faketype
	)

inline

Definition at line 1366 of file gtest.h.

1366 { return true; }

◆ OutputFlagAlsoCheckEnvVar()

std::string testing::internal::OutputFlagAlsoCheckEnvVar ( )

◆ ParseFlag()

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

◆ ParseGoogleTestFlagsOnly() [1/2]

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

◆ ParseGoogleTestFlagsOnly() [2/2]

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

◆ ParseInt32()

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

◆ PrefixOf()

constexpr bool testing::internal::PrefixOf	(	const char *	a,
		const char *	b
	)

Definition at line 68 of file gmock-function-mocker.h.

                                                       {
   return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
 }

◆ PrintBytesInObjectTo()

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

◆ PrintRawArrayTo()

template<typename T >

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

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

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

◆ PrintSmartPointer() [1/2]

template<typename T , typename Ptr >

void testing::internal::PrintSmartPointer	(	const Ptr &	ptr,
		std::ostream *	os,
		char
	)

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

                                                              {
   if (ptr == nullptr) {
     *os << "(nullptr)";
   } else {
     // We can't print the value. Just print the pointer..
     *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
   }
 }

◆ PrintSmartPointer() [2/2]

template<typename T , typename Ptr , typename = typename std::enable_if<!std::is_void<T>::value && !std::is_array<T>::value>::type>

void testing::internal::PrintSmartPointer	(	const Ptr &	ptr,
		std::ostream *	os,
		int
	)

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

                                                             {
   if (ptr == nullptr) {
     *os << "(nullptr)";
   } else {
     *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
     UniversalPrinter<T>::Print(*ptr, os);
     *os << ")";
   }
 }

◆ PrintStringTo()

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

◆ PrintTo() [1/31]

template<typename T >

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

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

                                              {
   internal::PrintWithFallback(value, os);
 }

◆ PrintTo() [2/31]

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

◆ PrintTo() [3/31]

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

◆ PrintTo() [4/31]

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

inline

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

                                             {
   // When printing a plain char, we always treat it as unsigned.  This
   // way, the output won't be affected by whether the compiler thinks
   // char is signed or not.
   PrintTo(static_cast<unsigned char>(c), os);
 }

◆ PrintTo() [5/31]

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

inline

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

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

◆ PrintTo() [6/31]

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

◆ PrintTo() [7/31]

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

◆ PrintTo() [8/31]

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

inline

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

                                                 {
   PrintTo(ImplicitCast_<char32_t>(c), os);
 }

◆ PrintTo() [9/31]

void testing::internal::PrintTo	(	float	f,
		::std::ostream *	os
	)

inline

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

                                              {
   auto old_precision = os->precision();
   os->precision(AppropriateResolution(f));
   *os << f;
   os->precision(old_precision);
 }

◆ PrintTo() [10/31]

void testing::internal::PrintTo	(	double	d,
		::std::ostream *	os
	)

inline

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

                                               {
   auto old_precision = os->precision();
   os->precision(AppropriateResolution(d));
   *os << d;
   os->precision(old_precision);
 }

◆ PrintTo() [11/31]

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

◆ PrintTo() [12/31]

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

inline

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

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

◆ PrintTo() [13/31]

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

inline

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

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

◆ PrintTo() [14/31]

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

inline

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

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

◆ PrintTo() [15/31]

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

inline

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

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

◆ PrintTo() [16/31]

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

inline

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

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

◆ PrintTo() [17/31]

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

◆ PrintTo() [18/31]

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

inline

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

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

◆ PrintTo() [19/31]

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

◆ PrintTo() [20/31]

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

inline

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

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

◆ PrintTo() [21/31]

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

◆ PrintTo() [22/31]

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

inline

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

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

◆ PrintTo() [23/31]

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

inline

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

                                                         {
   PrintStringTo(s, os);
 }

◆ PrintTo() [24/31]

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

inline

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

                                                            {
   PrintU16StringTo(s, os);
 }

◆ PrintTo() [25/31]

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

inline

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

                                                            {
   PrintU32StringTo(s, os);
 }

◆ PrintTo() [26/31]

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

inline

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

669 { *os << "(nullptr)"; }

◆ PrintTo() [27/31]

template<typename T >

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

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

                                                           {
   UniversalPrinter<T&>::Print(ref.get(), os);
 }

◆ PrintTo() [28/31]

template<typename T , typename D >

void testing::internal::PrintTo	(	const std::unique_ptr< T, D > &	ptr,
		std::ostream *	os
	)

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

                                                              {
   (PrintSmartPointer<T>)(ptr, os, 0);
 }

◆ PrintTo() [29/31]

template<typename T >

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

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

                                                           {
   (PrintSmartPointer<T>)(ptr, os, 0);
 }

◆ PrintTo() [30/31]

template<typename... Types>

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

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

                                                           {
   *os << "(";
   PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
   *os << ")";
 }

◆ PrintTo() [31/31]

template<typename T1 , typename T2 >

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

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

                                                            {
   *os << '(';
   // We cannot use UniversalPrint(value.first, os) here, as T1 may be
   // a reference type.  The same for printing value.second.
   UniversalPrinter<T1>::Print(value.first, os);
   *os << ", ";
   UniversalPrinter<T2>::Print(value.second, os);
   *os << ')';
 }

◆ PrintTupleTo() [1/2]

template<typename T >

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

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

723 {}

◆ PrintTupleTo() [2/2]

template<typename T , size_t I>

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

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

                                   {
   PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
   GTEST_INTENTIONAL_CONST_COND_PUSH_()
   if (I > 1) {
     GTEST_INTENTIONAL_CONST_COND_POP_()
     *os << ", ";
   }
   UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
       std::get<I - 1>(t), os);
 }

◆ PrintU16StringTo()

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

◆ PrintU32StringTo()

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

◆ PrintWithFallback()

template<typename T >

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

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

                                                        {
   using Printer = typename FindFirstPrinter<
       T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
       internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
       ProtobufPrinter, ConvertibleToIntegerPrinter,
       ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
   Printer::PrintValue(value, os);
 }

◆ ReadEntireFile()

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

◆ RegisterTypeParameterizedTestSuite()

GTEST_API_ void testing::internal::RegisterTypeParameterizedTestSuite	(	const char *	test_suite_name,
		CodeLocation	code_location
	)

◆ RegisterTypeParameterizedTestSuiteInstantiation()

GTEST_API_ void testing::internal::RegisterTypeParameterizedTestSuiteInstantiation ( const char * case_name )

◆ ReportFailureInUnknownLocation()

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

◆ ReportInvalidTestSuiteType()

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

◆ ShouldRunTestOnShard()

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

◆ ShouldShard()

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

◆ ShouldUseColor()

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

◆ Shuffle()

template<typename E >

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

inline

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

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

◆ ShuffleRange()

template<typename E >

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

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

                                    {
   const int size = static_cast<int>(v->size());
   GTEST_CHECK_(0 <= begin && begin <= size)
       << "Invalid shuffle range start " << begin << ": must be in range [0, "
       << size << "].";
   GTEST_CHECK_(begin <= end && end <= size)
       << "Invalid shuffle range finish " << end << ": must be in range ["
       << begin << ", " << size << "].";
 
   // Fisher-Yates shuffle, from
   // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
   for (int range_width = end - begin; range_width >= 2; range_width--) {
     const int last_in_range = begin + range_width - 1;
     const int selected =
         begin +
         static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
     std::swap((*v)[static_cast<size_t>(selected)],
               (*v)[static_cast<size_t>(last_in_range)]);
   }
 }

◆ SkipPrefix()

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

◆ SplitString()

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

◆ StartsWith()

template<int N, int M>

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

Definition at line 73 of file gmock-function-mocker.h.

                                                                          {
   return N <= M && internal::PrefixOf(prefix, str);
 }

◆ StreamableToString()

template<typename T >

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

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

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

◆ StrictnessModifierProbe() [1/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe ( const NiceMock< T > & )

◆ StrictnessModifierProbe() [2/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe ( const NaggyMock< T > & )

◆ StrictnessModifierProbe() [3/4]

template<typename T >

std::true_type testing::internal::StrictnessModifierProbe ( const StrictMock< T > & )

◆ StrictnessModifierProbe() [4/4]

std::false_type testing::internal::StrictnessModifierProbe ( ... )

◆ StringFromGTestEnv()

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

◆ StringStreamToString()

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

◆ StripTrailingSpaces()

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

inline

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

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

◆ TersePrintPrefixToStrings() [1/2]

template<typename Tuple >

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

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

1091 {}

◆ TersePrintPrefixToStrings() [2/2]

template<typename Tuple , size_t I>

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

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

                                                  {
   TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
                             strings);
   ::std::stringstream ss;
   UniversalTersePrint(std::get<I - 1>(t), &ss);
   strings->push_back(ss.str());
 }

◆ TestNotEmpty() [1/2]

template<typename T = int>

void testing::internal::TestNotEmpty ( )

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

                     {
   static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
 }

◆ TestNotEmpty() [2/2]

template<typename T = int>

void testing::internal::TestNotEmpty ( const T & )

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

392 {}

◆ ToLower()

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

inline

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

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

◆ ToUpper()

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

inline

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

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

◆ UniversalPrint()

template<typename T >

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

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

                                                     {
   // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
   // UniversalPrinter with T directly.
   typedef T T1;
   UniversalPrinter<T1>::Print(value, os);
 }

◆ UniversalPrintArray() [1/5]

template<typename T >

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

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

                                                                      {
   if (len == 0) {
     *os << "{}";
   } else {
     *os << "{ ";
     const size_t kThreshold = 18;
     const size_t kChunkSize = 8;
     // If the array has more than kThreshold elements, we'll have to
     // omit some details by printing only the first and the last
     // kChunkSize elements.
     if (len <= kThreshold) {
       PrintRawArrayTo(begin, len, os);
     } else {
       PrintRawArrayTo(begin, kChunkSize, os);
       *os << ", ..., ";
       PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
     }
     *os << " }";
   }
 }

◆ UniversalPrintArray() [2/5]

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

◆ UniversalPrintArray() [3/5]

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

◆ UniversalPrintArray() [4/5]

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

◆ UniversalPrintArray() [5/5]

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

◆ UniversalTersePrint()

template<typename T >

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

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

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

◆ UniversalTersePrintTupleFieldsToStrings()

template<typename Tuple >

Strings testing::internal::UniversalTersePrintTupleFieldsToStrings ( const Tuple & value )

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

                                                                     {
   Strings result;
   TersePrintPrefixToStrings(
       value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
       &result);
   return result;
 }

◆ ValidateSpec()

template<int N>

constexpr bool testing::internal::ValidateSpec ( const char(&) spec[N] )

Definition at line 88 of file gmock-function-mocker.h.

                                                    {
   return internal::Equals("const", spec) ||
          internal::Equals("override", spec) ||
          internal::Equals("final", spec) ||
          internal::Equals("noexcept", spec) ||
          (internal::StartsWith("noexcept(", spec) &&
           internal::EndsWith(")", spec)) ||
          internal::Equals("ref(&)", spec) ||
          internal::Equals("ref(&&)", spec) ||
          (internal::StartsWith("Calltype(", spec) &&
           internal::EndsWith(")", spec));
 }

◆ VoidifyPointer() [1/2]

const void* testing::internal::VoidifyPointer ( const void * p )

inline

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

682 { return p; }

◆ VoidifyPointer() [2/2]

const void* testing::internal::VoidifyPointer ( volatile const void * p )

inline

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

                                                           {
   return const_cast<const void*>(p);
 }

◆ WideStringToUtf8()

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

◆ WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Variable Documentation

◆ g_help_flag

GTEST_API_ bool testing::internal::g_help_flag

◆ kDeathTestStyleFlag

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

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

◆ kDeathTestUseFork

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

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

◆ kErrorVerbosity

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

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

◆ kInfoVerbosity

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

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

◆ kInternalRunDeathTestFlag

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

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

◆ kMaxBiggestInt

constexpr BiggestInt testing::internal::kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)()

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

◆ kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

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

◆ kStackTraceMarker

GTEST_API_ const char testing::internal::kStackTraceMarker[]

◆ kTestTypeIdInGoogleTest

GTEST_API_ const TypeId testing::internal::kTestTypeIdInGoogleTest

◆ kWarningVerbosity

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

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BiggestInt

◆ call_result_t

◆ Double

◆ Float

◆ identity_t

◆ IndexSequenceFor

◆ is_callable_r

◆ IsContainer

◆ IsNotContainer

◆ LosslessArithmeticConvertible

◆ LosslessArithmeticConvertibleImpl

◆ MakeIndexSequence

◆ MutexLock

◆ ParameterizedTestCaseInfo

◆ SetUpTearDownSuiteFuncType

◆ SetUpTestSuiteFunc

◆ Strings

◆ TearDownTestSuiteFunc

◆ TimeInMillis

◆ TupleElement

◆ TypedTestCasePState

◆ TypeId

◆ void_t

Enumeration Type Documentation

◆ GTestLogSeverity

◆ LogSeverity

◆ TypeKind

Function Documentation

◆ AlwaysFalse()

◆ AlwaysTrue()

◆ AppendUserMessage()

◆ Apply()

◆ ApplyImpl()

◆ AppropriateResolution()

◆ ArrayAwareFind()

◆ ArrayEq() [1/3]

◆ ArrayEq() [2/3]

◆ ArrayEq() [3/3]

◆ as_const()

◆ Assert() [1/2]

◆ Assert() [2/2]

◆ Base64Unescape()

◆ BoolFromGTestEnv()

◆ CanonicalizeForStdLibVersioning()

◆ CaptureStderr()

◆ CaptureStdout()

◆ CheckedDowncastToActualType()

◆ CmpHelperEQ()

◆ CmpHelperEQFailure()

◆ CmpHelperFloatingPointEQ()

◆ CmpHelperOpFailure()

◆ CmpHelperSTRCASEEQ()

◆ CmpHelperSTRCASENE()

◆ CmpHelperSTREQ() [1/2]

◆ CmpHelperSTREQ() [2/2]

◆ CmpHelperSTRNE() [1/2]

◆ CmpHelperSTRNE() [2/2]

◆ CodePointToUtf8()

◆ ConvertIdentifierNameToWords()

◆ CopyArray() [1/3]

◆ CopyArray() [2/3]

◆ CopyArray() [3/3]

◆ CountIf()

◆ DefaultParamName()

◆ DoubleNearPredFormat()

◆ DownCast_()

◆ EndsWith()

◆ EqFailure()

◆ Equals()

◆ Expect() [1/2]

◆ Expect() [2/2]

◆ FlushInfoLog()

◆ ForEach()