Namespaces
namespace	edit_distance

namespace	gmockpp

namespace	internal_stream_operator_without_lexical_name_lookup

namespace	posix

Classes
struct	ActionImpl

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

class	AssertHelper

class	AssignAction

class	Base

class	BriefUnitTestResultPrinter

class	BuiltInDefaultValue

class	BuiltInDefaultValue< const T >

class	BuiltInDefaultValue< T * >

struct	BuiltInDefaultValueGetter

struct	BuiltInDefaultValueGetter< T, false >

struct	ByMoveWrapper

class	CartesianProductGenerator

class	CartesianProductHolder

class	Castable

struct	CodeLocation

class	ConstAndNonConstCastable

class	ConstCastable

struct	ConstCharPtr

struct	ConstRef

struct	ConstRef< T & >

struct	ContainerPrinter

struct	ConvertibleToIntegerPrinter

struct	ConvertibleToStringViewPrinter

struct	DefaultNameGenerator

struct	DeleteArgAction

class	Derived

struct	DoAllAction

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	EnvironmentInvocationCatcher

class	EqHelper

class	EventRecordingListener

class	EventRecordingListener2

struct	ExcessiveArg

class	ExpectationTester

class	FailureReporterInterface

struct	faketype

struct	FallbackPrinter

class	FinalSuccessChecker

struct	FindFirstPrinter

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

class	FlatTuple

struct	FlatTupleBase

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

struct	FlatTupleConstructTag

struct	FlatTupleElemBase

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

class	FloatingPoint

class	FormatForComparison

class	FormatForComparison< ToPrint[N], OtherOperand >

struct	Function

struct	Function< R(Args...)>

struct	FunctionPointerPrinter

struct	GenerateTypeList

class	GoogleTestFailureReporter

class	GTestLog

class	GTestMutexLock

class	HasDebugStringAndShortDebugString

struct	Ignore

class	IgnoredValue

class	IgnoreResultAction

struct	ImplBase

struct	IndexSequence

struct	InvokeArgumentAction

struct	InvokeMethodAction

struct	InvokeMethodWithoutArgsAction

struct	InvokeWithoutArgsAction

struct	is_proxy_type_list

struct	is_proxy_type_list< ProxyTypeList< Ts... > >

struct	IsHashTable

struct	IsRecursiveContainer

struct	IsRecursiveContainerImpl

struct	IsRecursiveContainerImpl< C, false >

struct	IsRecursiveContainerImpl< C, true >

class	JsonUnitTestResultPrinter

struct	KindOf

struct	LessByName

class	ListenerTest

struct	MakeIndexSequenceImpl

struct	MakeIndexSequenceImpl< 0 >

struct	MarkAsIgnored

class	MaxBipartiteMatchState

class	Mutex

class	NaggyMockImpl

struct	NameGeneratorSelector

class	NativeArray

class	NiceMockImpl

class	NoDefaultContructor

struct	None

class	ParameterizedTestFactory

class	ParameterizedTestSuiteInfo

class	ParameterizedTestSuiteInfoBase

class	ParameterizedTestSuiteRegistry

class	ParamGenerator

class	ParamGeneratorInterface

class	ParamIterator

class	ParamIteratorInterface

struct	PointerPrinter

class	PrettyUnitTestResultPrinter

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

struct	ReturnArgAction

struct	ReturnNewAction

class	ReturnNullAction

struct	ReturnPointeeAction

class	ReturnRefAction

class	ReturnRefOfCopyAction

class	ReturnRoundRobinAction

class	ReturnVoidAction

struct	SaveArgAction

struct	SaveArgPointeeAction

class	ScopedPrematureExitFile

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	TestEventListenersAccessor

class	TestEventRepeater

class	TestFactoryBase

class	TestFactoryImpl

class	TestMetaFactory

class	TestMetaFactoryBase

class	TestSuiteNameIs

class	TestSuiteWithCommentTest

struct	ThisRefAdjuster

class	ThreadLocal

class	Timer

class	To

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	UnitTestHelper

class	UnitTestRecordPropertyTestHelper

class	UniversalPrinter

class	UniversalPrinter< const T >

class	UniversalPrinter< T & >

class	UniversalPrinter< T[N]>

class	UniversalPrinter< Wrapper< T > >

class	UniversalTersePrinter

class	UniversalTersePrinter< char * >

class	UniversalTersePrinter< char16_t * >

class	UniversalTersePrinter< char32_t * >

class	UniversalTersePrinter< const char * >

class	UniversalTersePrinter< const char16_t * >

class	UniversalTersePrinter< const char32_t * >

class	UniversalTersePrinter< T & >

class	UniversalTersePrinter< T[N]>

class	UniversalTersePrinter< wchar_t * >

class	ValueArray

class	ValuesInIteratorRangeGenerator

struct	WithArgsAction

class	WithoutMatchers

class	XmlUnitTestResultPrinter

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

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 >

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 }

enum	CharFormat { kAsIs , kHexEscape , kSpecialEscape }

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 int, 0U)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed int, 0)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (unsigned long, 0UL)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (signed long, 0L)

	GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ (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 F , typename Impl >
::testing::Action< F >	MakeAction ()

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

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	JoinAsTuple (const Strings &fields)

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

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

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

	GMOCK_DECLARE_KIND_ (bool, kBool)

	GMOCK_DECLARE_KIND_ (char, kInteger)

	GMOCK_DECLARE_KIND_ (signed char, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned char, kInteger)

	GMOCK_DECLARE_KIND_ (short, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned short, kInteger)

	GMOCK_DECLARE_KIND_ (int, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned int, kInteger)

	GMOCK_DECLARE_KIND_ (long, kInteger)

	GMOCK_DECLARE_KIND_ (unsigned long, kInteger)

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

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

GTEST_API_ ElementMatcherPairs	FindMaxBipartiteMatching (const MatchMatrix &g)

GTEST_API_	GTEST_DEFINE_STATIC_MUTEX_ (g_gmock_mutex)

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

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

CallReaction	intToCallReaction (int mock_behavior)

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

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)

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)

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

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

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

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

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

template<typename T >
TypeId	GetTypeId ()

GTEST_API_ TypeId	GetTestTypeId ()

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 (UnitTest *unit_test, 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_DEFINE_string_ (internal_run_death_test, "", "Indicates the file, line number, temporal index of " "the single death test to run, and a file descriptor to " "which a success code may be sent, all separated by " "the '\|' characters. This flag is specified if and only if the " "current process is a sub-process launched for running a thread-safe " "death test. FOR INTERNAL USE ONLY.")

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

bool	IsPrintableAscii (char32_t c)

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

void	PrintTo (wchar_t wc, ostream *os)

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

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

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

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

void	PrintTo (const char s, ostream os)

void	PrintTo (const char16_t s, ostream os)

void	PrintTo (const char32_t s, ostream os)

void	PrintTo (const wchar_t s, ostream os)

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

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

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

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

FilePath	GetCurrentExecutableName ()

TimeInMillis	GetTimeInMillis ()

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

uint32_t	ChopLowBits (uint32_t *bits, int n)

std::string	CodePointToUtf8 (uint32_t code_point)

bool	IsUtf16SurrogatePair (wchar_t first, wchar_t second)

uint32_t	CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)

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

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

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

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

bool	ShouldUseColor (bool stdout_is_tty)

std::string	FormatTimeInMillisAsSeconds (TimeInMillis ms)

std::string	FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)

void	WriteToShardStatusFileIfNeeded ()

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

int32_t	Int32FromEnvOrDie (const char *var, int32_t default_val)

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

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

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

void	ParseGoogleTestFlagsOnly (int argc, char *argv)

void	ParseGoogleTestFlagsOnly (int argc, wchar_t *argv)

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

	TEST_F (ListenerTest, DoesFoo)

	TEST_F (ListenerTest, DoesBar)

	TEST (IsXDigitTest, WorksForNarrowAscii)

	TEST (IsXDigitTest, ReturnsFalseForNarrowNonAscii)

	TEST (IsXDigitTest, WorksForWideAscii)

	TEST (IsXDigitTest, ReturnsFalseForWideNonAscii)

	TEST (ImplicitCastTest, ConvertsPointers)

	TEST (ImplicitCastTest, CanUseInheritance)

	TEST (ImplicitCastTest, CanUseNonConstCastOperator)

	TEST (ImplicitCastTest, CanUseConstCastOperatorOnConstValues)

	TEST (ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately)

	TEST (ImplicitCastTest, CanUseImplicitConstructor)

	TEST (GtestCheckSyntaxTest, BehavesLikeASingleStatement)

	TEST (GtestCheckSyntaxTest, WorksWithSwitch)

	TEST (FormatFileLocationTest, FormatsFileLocation)

	TEST (FormatFileLocationTest, FormatsUnknownFile)

	TEST (FormatFileLocationTest, FormatsUknownLine)

	TEST (FormatFileLocationTest, FormatsUknownFileAndLine)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsFileLocation)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFile)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownLine)

	TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine)

	TEST (GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads)

	TEST (GtestCheckDeathTest, DiesWithCorrectOutputOnFailure)

	TEST (RegexEngineSelectionTest, SelectsCorrectRegexEngine)

	TEST (CaptureTest, CapturesStdout)

	TEST (CaptureTest, CapturesStderr)

	TEST (CaptureTest, CapturesStdoutAndStderr)

	TEST (CaptureDeathTest, CannotReenterStdoutCapture)

	TEST (ThreadLocalTest, DefaultConstructorInitializesToDefaultValues)

	TEST (ThreadLocalTest, SingleParamConstructorInitializesToParam)

	TEST (ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion)

	TEST (ThreadLocalTest, GetAndPointerReturnSameValue)

	TEST (ThreadLocalTest, PointerAndConstPointerReturnSameValue)

	TYPED_TEST_SUITE (TestSuiteWithCommentTest, Types< int >)

	TYPED_TEST (TestSuiteWithCommentTest, Dummy)

	TEST (ApiTest, UnitTestImmutableAccessorsWork)

AssertionResult	IsNull (const char *str)

	TEST (ApiTest, TestSuiteImmutableAccessorsWork)

	TEST (ApiTest, TestSuiteDisabledAccessorsWork)

	TEST (ApiTest, DISABLED_Dummy1)

	TEST (DISABLED_Test, Dummy2)

Variables
const char	kInfoVerbosity [] = "info"

const char	kWarningVerbosity [] = "warning"

const char	kErrorVerbosity [] = "error"

GTEST_API_ ThreadLocal< Sequence * >	g_gmock_implicit_sequence

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 [] = "\nStack trace:\n"

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

const char	kPathSeparator = '/'

const char	kCurrentDirectoryString [] = "./"

const int	kStdOutFileno = STDOUT_FILENO

const int	kStdErrFileno = STDERR_FILENO

const char	kUnknownFile [] = "unknown file"

bool	g_help_flag = false

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

const TypeId	kTestTypeIdInGoogleTest = GetTestTypeId()

constexpr uint32_t	kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1

constexpr uint32_t	kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1

constexpr uint32_t	kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1

constexpr uint32_t	kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1

const int	kTypedTestSuites = 1

const int	kTypedTests = 1

Typedef Documentation

◆ BiggestInt

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

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

◆ disjunction

template<typename P , typename Q >

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

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

◆ Double

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

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

◆ Float

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

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

◆ identity_t

template<typename T >

using testing::internal::identity_t = typedef T

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

◆ IndexSequenceFor

template<typename... T>

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

Definition at line 1188 of file gtest-internal.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 187 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 154 of file gmock-internal-utils.h.

◆ MakeIndexSequence

template<size_t N>

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

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

◆ MutexLock

typedef GTestMutexLock testing::internal::MutexLock

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

◆ ParameterizedTestCaseInfo

template<class TestCase >

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

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

◆ SetUpTearDownSuiteFuncType

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

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

◆ SetUpTestSuiteFunc

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

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

◆ Strings

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

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

◆ TearDownTestSuiteFunc

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

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

◆ TimeInMillis

using testing::internal::TimeInMillis = typedef int64_t

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

◆ TypedTestCasePState

using testing::internal::TypedTestCasePState = typedef TypedTestSuitePState

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

◆ TypeId

typedef const void* testing::internal::TypeId

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

Enumeration Type Documentation

◆ CharFormat

enum testing::internal::CharFormat

Enumerator
kAsIs
kHexEscape
kSpecialEscape

Definition at line 139 of file gtest-printers.cc.

                {
  kAsIs,
  kHexEscape,
  kSpecialEscape
};

◆ GTestLogSeverity

enum testing::internal::GTestLogSeverity

Enumerator
GTEST_INFO
GTEST_WARNING
GTEST_ERROR
GTEST_FATAL

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

                      {
  GTEST_INFO,
  GTEST_WARNING,
  GTEST_ERROR,
  GTEST_FATAL
};

◆ LogSeverity

enum testing::internal::LogSeverity

Enumerator
kInfo
kWarning

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

                 {
  kInfo = 0,
  kWarning = 1
};

◆ TypeKind

enum testing::internal::TypeKind

Enumerator
kBool
kInteger
kFloatingPoint
kOther

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

              {
  kBool, kInteger, kFloatingPoint, kOther
};

Function Documentation

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )

inline

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

844{ return !AlwaysTrue(); }

testing::internal::AlwaysTrue

GTEST_API_ bool AlwaysTrue()

Definition: gtest.cc:6240

◆ AlwaysTrue()

bool testing::internal::AlwaysTrue ( )

Definition at line 6240 of file gtest.cc.

                  {
#if GTEST_HAS_EXCEPTIONS
  // This condition is always false so AlwaysTrue() never actually throws,
  // but it makes the compiler think that it may throw.
  if (IsTrue(false))
    throw ClassUniqueToAlwaysTrue();
#endif  // GTEST_HAS_EXCEPTIONS
  return true;
}

◆ AppendUserMessage()

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

Definition at line 2183 of file gtest.cc.

                                                       {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }
  if (gtest_msg.empty()) {
    return user_msg_string;
  }
  return gtest_msg + "\n" + user_msg_string;
}

◆ 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 412 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 405 of file gmock-internal-utils.h.

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

◆ ArrayAwareFind()

template<typename Iter , typename Element >

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

Definition at line 1043 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,
		const U &	rhs
	)

inline

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

1020{ return lhs == rhs; }

◆ ArrayEq() [2/3]

template<typename T , typename U >

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

Definition at line 1032 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() [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 1024 of file gtest-internal.h.

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

◆ Assert() [1/2]

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

inline

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

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

◆ Assert() [2/2]

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

inline

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

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

◆ BoolFromGTestEnv()

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

Definition at line 1365 of file gtest-port.cc.

                                                            {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == nullptr ? default_value
                                 : strcmp(string_value, "0") != 0;
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
}

◆ CanonicalizeForStdLibVersioning()

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

inline

Definition at line 55 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 1116 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
}

◆ ChopLowBits()

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

inline

Definition at line 1918 of file gtest.cc.

                                                   {
  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
  *bits >>= n;
  return low_bits;
}

◆ 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 1541 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 1522 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 1733 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 1595 of file gtest.h.

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

◆ CmpHelperSTRCASEEQ()

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

Definition at line 1676 of file gtest.cc.

                                                    {
  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   true);
}

◆ CmpHelperSTRCASENE()

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

Definition at line 1706 of file gtest.cc.

                                                   {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

◆ CmpHelperSTREQ() [1/2]

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

Definition at line 1660 of file gtest.cc.

                                                {
  if (String::CStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

◆ CmpHelperSTREQ() [2/2]

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

Definition at line 2043 of file gtest.cc.

                                                   {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }
 
  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

◆ CmpHelperSTRNE() [1/2]

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

Definition at line 1692 of file gtest.cc.

                                               {
  if (!String::CStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                              << s2_expression << "), actual: \""
                              << s1 << "\" vs \"" << s2 << "\"";
  }
}

◆ CmpHelperSTRNE() [2/2]

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

Definition at line 2059 of file gtest.cc.

                                                  {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }
 
  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

◆ CodePointToUtf8()

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

Definition at line 1930 of file gtest.cc.

                                               {
  if (code_point > kMaxCodePoint4) {
    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
  }
 
  char str[5];  // Big enough for the largest valid code point.
  if (code_point <= kMaxCodePoint1) {
    str[1] = '\0';
    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
  } else if (code_point <= kMaxCodePoint2) {
    str[2] = '\0';
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
  } else if (code_point <= kMaxCodePoint3) {
    str[3] = '\0';
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
  } else {  // code_point <= kMaxCodePoint4
    str[4] = '\0';
    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
  }
  return str;
}

◆ ConvertIdentifierNameToWords()

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

Definition at line 72 of file gmock-internal-utils.cc.

                                                                       {
  std::string result;
  char prev_char = '\0';
  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
    // We don't care about the current locale as the input is
    // guaranteed to be a valid C++ identifier name.
    const bool starts_new_word = IsUpper(*p) ||
        (!IsAlpha(prev_char) && IsLower(*p)) ||
        (!IsDigit(prev_char) && IsDigit(*p));
 
    if (IsAlNum(*p)) {
      if (starts_new_word && result != "")
        result += ' ';
      result += ToLower(*p);
    }
  }
  return result;
}

◆ CopyArray() [1/3]

template<typename T , typename U >

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

inline

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

1060{ *to = from; }

◆ CopyArray() [2/3]

template<typename T , typename U >

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

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

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

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

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

◆ CreateCodePointFromUtf16SurrogatePair()

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

inline

Definition at line 1971 of file gtest.cc.

                                                                      {
  const auto first_u = static_cast<uint32_t>(first);
  const auto second_u = static_cast<uint32_t>(second);
  const uint32_t mask = (1 << 10) - 1;
  return (sizeof(wchar_t) == 2)
             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
             :
             // This function should not be called when the condition is
             // false, but we provide a sensible default in case it is.
             first_u;
}

◆ DefaultParamName()

template<class ParamType >

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

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

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

◆ DiffStrings()

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

◆ DoubleNearPredFormat()

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

Definition at line 1563 of file gtest.cc.

                                                       {
  const double diff = fabs(val1 - val2);
  if (diff <= abs_error) return AssertionSuccess();
 
  // Find the value which is closest to zero.
  const double min_abs = std::min(fabs(val1), fabs(val2));
  // Find the distance to the next double from that value.
  const double epsilon =
      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
  // Detect the case where abs_error is so small that EXPECT_NEAR is
  // effectively the same as EXPECT_EQUAL, and give an informative error
  // message so that the situation can be more easily understood without
  // requiring exotic floating-point knowledge.
  // Don't do an epsilon check if abs_error is zero because that implies
  // that an equality check was actually intended.
  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
      abs_error < epsilon) {
    return AssertionFailure()
           << "The difference between " << expr1 << " and " << expr2 << " is "
           << diff << ", where\n"
           << expr1 << " evaluates to " << val1 << ",\n"
           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
           << abs_error_expr << " evaluates to " << abs_error
           << " which is smaller than the minimum distance between doubles for "
              "numbers of this magnitude which is "
           << epsilon
           << ", thus making this EXPECT_NEAR check equivalent to "
              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
  }
  return AssertionFailure()
      << "The difference between " << expr1 << " and " << expr2
      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
      << expr1 << " evaluates to " << val1 << ",\n"
      << expr2 << " evaluates to " << val2 << ", and\n"
      << abs_error_expr << " evaluates to " << abs_error << ".";
}

◆ DownCast_()

template<typename To , typename From >

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

inline

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

◆ EqFailure()

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

Definition at line 1512 of file gtest.cc.

                                              {
  Message msg;
  msg << "Expected equality of these values:";
  msg << "\n  " << lhs_expression;
  if (lhs_value != lhs_expression) {
    msg << "\n    Which is: " << lhs_value;
  }
  msg << "\n  " << rhs_expression;
  if (rhs_value != rhs_expression) {
    msg << "\n    Which is: " << rhs_value;
  }
 
  if (ignoring_case) {
    msg << "\nIgnoring case";
  }
 
  if (!lhs_value.empty() && !rhs_value.empty()) {
    const std::vector<std::string> lhs_lines =
        SplitEscapedString(lhs_value);
    const std::vector<std::string> rhs_lines =
        SplitEscapedString(rhs_value);
    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
      msg << "\nWith diff:\n"
          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
    }
  }
 
  return AssertionFailure() << msg;
}

◆ Expect() [1/2]

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

inline

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

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

◆ Expect() [2/2]

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

inline

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

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

◆ FindMaxBipartiteMatching()

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

Definition at line 225 of file gmock-matchers.cc.

                                                                              {
  return MaxBipartiteMatchState(g).Compute();
}

◆ FloatingPointLE()

template<typename RawType >

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

Definition at line 1608 of file gtest.cc.

                                              {
  // Returns success if val1 is less than val2,
  if (val1 < val2) {
    return AssertionSuccess();
  }
 
  // or if val1 is almost equal to val2.
  const FloatingPoint<RawType> lhs(val1), rhs(val2);
  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }
 
  // Note that the above two checks will both fail if either val1 or
  // val2 is NaN, as the IEEE floating-point standard requires that
  // any predicate involving a NaN must return false.
 
  ::std::stringstream val1_ss;
  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val1;
 
  ::std::stringstream val2_ss;
  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << val2;
 
  return AssertionFailure()
      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
      << StringStreamToString(&val2_ss);
}

◆ FlushInfoLog()

void testing::internal::FlushInfoLog ( )

inline

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

989{ fflush(nullptr); }

◆ FormatCompilerIndependentFileLocation()

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

Definition at line 1041 of file gtest-port.cc.

                                {
  const std::string file_name(file == nullptr ? kUnknownFile : file);
 
  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

◆ FormatEpochTimeInMillisAsIso8601()

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

Definition at line 4110 of file gtest.cc.

                                                            {
  struct tm time_struct;
  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
    return "";
  // YYYY-MM-DDThh:mm:ss.sss
  return StreamableToString(time_struct.tm_year + 1900) + "-" +
      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
      String::FormatIntWidth2(time_struct.tm_min) + ":" +
      String::FormatIntWidth2(time_struct.tm_sec) + "." +
      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
}

◆ FormatFileLocation()

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

Definition at line 1023 of file gtest-port.cc.

                                                                    {
  const std::string file_name(file == nullptr ? kUnknownFile : file);
 
  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

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

◆ FormatMatcherDescription()

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

Definition at line 51 of file gmock-matchers.cc.

                                                                             {
  std::string result = ConvertIdentifierNameToWords(matcher_name);
  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
  return negation ? "not (" + result + ")" : result;
}

◆ FormatTimeInMillisAsSeconds()

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

Definition at line 4083 of file gtest.cc.

                                                       {
  ::std::stringstream ss;
  ss << (static_cast<double>(ms) * 1e-3);
  return ss.str();
}

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

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

Definition at line 580 of file gtest.cc.

                                {
#if defined(GTEST_CUSTOM_GET_ARGVS_)
  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  // ::string. This code converts it to the appropriate type.
  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  return ::std::vector<std::string>(custom.begin(), custom.end());
#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  return g_argvs;
#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
}

◆ GetBoolAssertionFailureMessage()

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

Definition at line 1547 of file gtest.cc.

                                          {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

◆ GetCapturedStderr()

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

◆ GetCapturedStdout()

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

◆ GetCurrentExecutableName()

FilePath testing::internal::GetCurrentExecutableName ( )

Definition at line 593 of file gtest.cc.

                                    {
  FilePath result;
 
#if GTEST_OS_WINDOWS || GTEST_OS_OS2
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS
 
  return result.RemoveDirectoryName();
}

◆ GetCurrentOsStackTraceExceptTop()

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

Definition at line 6225 of file gtest.cc.

                                                            {
  // We pass skip_count + 1 to skip this wrapper function in addition
  // to what the user really wants to skip.
  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
}

◆ GetFailureReporter()

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

Definition at line 112 of file gmock-internal-utils.cc.

                                                          {
  // Points to the global failure reporter used by Google Mock.  gcc
  // guarantees that the following use of failure_reporter is
  // thread-safe.  We may need to add additional synchronization to
  // protect failure_reporter if we port Google Mock to other
  // compilers.
  static FailureReporterInterface* const failure_reporter =
      new GoogleTestFailureReporter();
  return failure_reporter;
}

◆ GetFileSize()

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

Definition at line 1242 of file gtest-port.cc.

                               {
  fseek(file, 0, SEEK_END);
  return static_cast<size_t>(ftell(file));
}

◆ GetIgnoredParameterizedTestSuites()

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

Definition at line 458 of file gtest.cc.

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

◆ GetNotDefaultOrNull()

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

inline

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

◆ GetRawPointer() [1/2]

template<typename Pointer >

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

inline

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

                                                                           {
  return p.get();
}

◆ GetRawPointer() [2/2]

template<typename Element >

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

inline

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

83{ return p; }

◆ GetTestTypeId()

TypeId testing::internal::GetTestTypeId ( )

Definition at line 847 of file gtest.cc.

                       {
  return GetTypeId<Test>();
}

◆ GetThreadCount()

size_t testing::internal::GetThreadCount ( )

Definition at line 273 of file gtest-port.cc.

                        {
  // There's no portable way to detect the number of threads, so we just
  // return 0 to indicate that we cannot detect it.
  return 0;
}

◆ GetTimeInMillis()

TimeInMillis testing::internal::GetTimeInMillis ( )

Definition at line 1053 of file gtest.cc.

                               {
  return std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::system_clock::now() -
             std::chrono::system_clock::from_time_t(0))
      .count();
}

◆ GetTypeId()

template<typename T >

TypeId testing::internal::GetTypeId ( )

Definition at line 435 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 93 of file gtest-type-util.h.

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

◆ GetWithoutMatchers()

GTEST_API_ WithoutMatchers testing::internal::GetWithoutMatchers ( )

Definition at line 187 of file gmock-internal-utils.cc.

187{ return WithoutMatchers(); }

testing::internal::WithoutMatchers

Definition: gmock-internal-utils.h:274

◆ GMOCK_DECLARE_KIND_() [1/16]

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

◆ GMOCK_DECLARE_KIND_() [2/16]

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

◆ GMOCK_DECLARE_KIND_() [3/16]

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

◆ GMOCK_DECLARE_KIND_() [4/16]

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

◆ GMOCK_DECLARE_KIND_() [5/16]

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

◆ GMOCK_DECLARE_KIND_() [6/16]

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

◆ GMOCK_DECLARE_KIND_() [7/16]

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

◆ GMOCK_DECLARE_KIND_() [8/16]

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

◆ GMOCK_DECLARE_KIND_() [9/16]

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

◆ GMOCK_DECLARE_KIND_() [10/16]

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

◆ GMOCK_DECLARE_KIND_() [11/16]

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

◆ GMOCK_DECLARE_KIND_() [12/16]

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

◆ GMOCK_DECLARE_KIND_() [13/16]

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

◆ GMOCK_DECLARE_KIND_() [14/16]

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

◆ GMOCK_DECLARE_KIND_() [15/16]

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

◆ GMOCK_DECLARE_KIND_() [16/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [1/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [2/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [3/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [4/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [5/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [6/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [7/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [8/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [9/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [10/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [11/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [12/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [13/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [14/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [15/16]

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

◆ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_() [16/16]

testing::internal::GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ ( void )

◆ GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_ ( internal_run_death_test )

◆ GTEST_DEFINE_STATIC_MUTEX_()

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_gmock_mutex )

◆ GTEST_DEFINE_string_()

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

◆ GTEST_DISABLE_MSC_WARNINGS_POP_()

testing::internal::GTEST_DISABLE_MSC_WARNINGS_POP_ ( ) const

Definition at line 648 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 593 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> 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_ ( char16_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [3/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char32_t )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [4/4]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( wchar_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 1294 of file gtest-internal.h.

1297 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [2/5]

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

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

1317 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [3/5]

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

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

1312 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [4/5]

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

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

1307 { return true; }

◆ GTEST_INTERNAL_DEPRECATED() [5/5]

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

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

1302 { return true; }

◆ HandleExceptionsInMethodIfSupported()

template<class T , typename Result >

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

Definition at line 2615 of file gtest.cc.

                                                          {
  // NOTE: The user code can affect the way in which Google Test handles
  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
  // after the exception is caught and either report or re-throw the
  // exception based on the flag's value:
  //
  // try {
  //   // Perform the test method.
  // } catch (...) {
  //   if (GTEST_FLAG(catch_exceptions))
  //     // Report the exception as failure.
  //   else
  //     throw;  // Re-throws the original exception.
  // }
  //
  // However, the purpose of this flag is to allow the program to drop into
  // the debugger when the exception is thrown. On most platforms, once the
  // control enters the catch block, the exception origin information is
  // lost and the debugger will stop the program at the point of the
  // re-throw in this function -- instead of at the point of the original
  // throw statement in the code under test.  For this reason, we perform
  // the check early, sacrificing the ability to affect Google Test's
  // exception handling in the method where the exception is thrown.
  if (internal::GetUnitTestImpl()->catch_exceptions()) {
#if GTEST_HAS_EXCEPTIONS
    try {
      return HandleSehExceptionsInMethodIfSupported(object, method, location);
    } catch (const AssertionException&) {  // NOLINT
      // This failure was reported already.
    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
      // This exception type can only be thrown by a failed Google
      // Test assertion with the intention of letting another testing
      // framework catch it.  Therefore we just re-throw it.
      throw;
    } catch (const std::exception& e) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(e.what(), location));
    } catch (...) {  // NOLINT
      internal::ReportFailureInUnknownLocation(
          TestPartResult::kFatalFailure,
          FormatCxxExceptionMessage(nullptr, location));
    }
    return static_cast<Result>(0);
#else
    return HandleSehExceptionsInMethodIfSupported(object, method, location);
#endif  // GTEST_HAS_EXCEPTIONS
  } else {
    return (object->*method)();
  }
}

◆ HandleSehExceptionsInMethodIfSupported()

template<class T , typename Result >

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

Definition at line 2588 of file gtest.cc.

                                                          {
#if GTEST_HAS_SEH
  __try {
    return (object->*method)();
  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
      GetExceptionCode())) {
    // We create the exception message on the heap because VC++ prohibits
    // creation of objects with destructors on stack in functions using __try
    // (see error C2712).
    std::string* exception_message = FormatSehExceptionMessage(
        GetExceptionCode(), location);
    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                             *exception_message);
    delete exception_message;
    return static_cast<Result>(0);
  }
#else
  (void)location;
  return (object->*method)();
#endif  // GTEST_HAS_SEH
}

◆ HasStrictnessModifier()

template<typename T >

constexpr bool testing::internal::HasStrictnessModifier ( )

constexpr

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

Definition at line 189 of file gmock-internal-utils.cc.

                                                             {
  internal::Assert(
      false, file, line,
      "You are using DoDefault() inside a composite action like "
      "DoAll() or WithArgs().  This is not supported for technical "
      "reasons.  Please instead spell out the default action, or "
      "assign the default action to an Action variable and use "
      "the variable in various places.");
}

◆ ImplicitCast_()

template<typename To >

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

inline

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

1067{ return x; }

x

int x

Definition: gmock-matchers_test.cc:4027

◆ InitGoogleMockImpl()

template<typename CharType >

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

Definition at line 144 of file gmock.cc.

                                                    {
  // Makes sure Google Test is initialized.  InitGoogleTest() is
  // idempotent, so it's fine if the user has already called it.
  InitGoogleTest(argc, argv);
  if (*argc <= 0) return;
 
  for (int i = 1; i != *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();
 
    // Do we see a Google Mock flag?
    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
                                &GMOCK_FLAG(catch_leaked_mocks)) ||
        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
                               &GMOCK_FLAG(default_mock_behavior))) {
      // Yes.  Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }
 
      // Decrements the argument count.
      (*argc)--;
 
      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }
}

◆ InitGoogleTestImpl()

template<typename CharType >

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

Definition at line 6630 of file gtest.cc.

                                                    {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;
 
  if (*argc <= 0) return;
 
  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }
 
#if GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());
#endif  // GTEST_HAS_ABSL
 
  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

◆ InsertSyntheticTestCase()

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

Definition at line 469 of file gtest.cc.

                                              {
  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  if (ignored.find(name) != ignored.end()) return;
 
  const char kMissingInstantiation[] =  //
      " is defined via TEST_P, but never instantiated. None of the test cases "
      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
      "ones provided expand to nothing."
      "\n\n"
      "Ideally, TEST_P definitions should only ever be included as part of "
      "binaries that intend to use them. (As opposed to, for example, being "
      "placed in a library that may be linked in to get other utilities.)";
 
  const char kMissingTestCase[] =  //
      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
      "defined via TEST_P . No test cases will run."
      "\n\n"
      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
      "code that always depend on code that provides TEST_P. Failing to do "
      "so is often an indication of dead code, e.g. the last TEST_P was "
      "removed but the rest got left behind.";
 
  std::string message =
      "Parameterized test suite " + name +
      (has_test_p ? kMissingInstantiation : kMissingTestCase) +
      "\n\n"
      "To suppress this error for this test suite, insert the following line "
      "(in a non-header) in the namespace it is defined in:"
      "\n\n"
      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
 
  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
  RegisterTest(  //
      "GoogleTestVerification", full_name.c_str(),
      nullptr,  // No type parameter.
      nullptr,  // No value parameter.
      location.file.c_str(), location.line, [message, location] {
        return new FailureTest(location, message,
                               kErrorOnUninstantiatedParameterizedTest);
      });
}

◆ Int32FromEnvOrDie()

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

Definition at line 5995 of file gtest.cc.

                                                                {
  const char* str_val = posix::GetEnv(var);
  if (str_val == nullptr) {
    return default_val;
  }
 
  int32_t result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

◆ Int32FromGTestEnv()

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

Definition at line 1379 of file gtest-port.cc.

                                                                   {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == nullptr) {
    // The environment variable is not set.
    return default_value;
  }
 
  int32_t result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }
 
  return result;
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
}

◆ intToCallReaction()

CallReaction testing::internal::intToCallReaction ( int mock_behavior )

Definition at line 570 of file gmock-spec-builders.cc.

                                                  {
  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
    return static_cast<internal::CallReaction>(mock_behavior);
  }
  return kWarn;
}

◆ Invalid()

template<typename T >

T testing::internal::Invalid ( )

inline

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

                   {
  Assert(false, "", -1, "Internal error: attempt to return invalid value");
  // This statement is unreachable, and would never terminate even if it
  // could be reached. It is provided only to placate compiler warnings
  // about missing return statements.
  return Invalid<T>();
}

◆ InvokeArgument()

template<typename F , typename... Args>

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

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

                                                               {
  return f(args...);
}

◆ IsAlNum()

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

inline

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

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

◆ IsAlpha()

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

inline

Definition at line 1922 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.

957{ return '\0'; }

◆ IsDigit()

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

inline

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

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

◆ IsLower()

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

inline

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

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

◆ IsNull()

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

Definition at line 132 of file gtest-unittest-api_test.cc.

                                        {
  if (str != nullptr) {
    return testing::AssertionFailure() << "argument is " << str;
  }
  return AssertionSuccess();
}

◆ IsPrintableAscii()

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

inline

Definition at line 148 of file gtest-printers.cc.

148{ return 0x20 <= c && c <= 0x7E; }

◆ IsSpace()

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

inline

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

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

◆ IsTrue()

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

Definition at line 6238 of file gtest.cc.

6238{ return condition; }

◆ IsUpper()

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

inline

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

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

◆ IsUtf16SurrogatePair()

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

inline

Definition at line 1965 of file gtest.cc.

                                                                {
  return sizeof(wchar_t) == 2 &&
      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
}

◆ IsXDigit() [1/4]

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

inline

Definition at line 1940 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 1948 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 1952 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 1956 of file gtest-port.h.

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

◆ JoinAsTuple()

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

Definition at line 51 of file gmock-internal-utils.cc.

                                                        {
  switch (fields.size()) {
    case 0:
      return "";
    case 1:
      return fields[0];
    default:
      std::string result = "(" + fields[0];
      for (size_t i = 1; i < fields.size(); i++) {
        result += ", ";
        result += fields[i];
      }
      result += ")";
      return result;
  }
}

◆ Log()

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

Definition at line 149 of file gmock-internal-utils.cc.

                                              {
  if (!LogIsVisible(severity))
    return;
 
  // Ensures that logs from different threads don't interleave.
  MutexLock l(&g_log_mutex);
 
  if (severity == kWarning) {
    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
    std::cout << "\nGMOCK WARNING:";
  }
  // Pre-pends a new-line to message if it doesn't start with one.
  if (message.empty() || message[0] != '\n') {
    std::cout << "\n";
  }
  std::cout << message;
  if (stack_frames_to_skip >= 0) {
#ifdef NDEBUG
    // In opt mode, we have to be conservative and skip no stack frame.
    const int actual_to_skip = 0;
#else
    // In dbg mode, we can do what the caller tell us to do (plus one
    // for skipping this function's stack frame).
    const int actual_to_skip = stack_frames_to_skip + 1;
#endif  // NDEBUG
 
    // Appends a new-line to message if it doesn't end with one.
    if (!message.empty() && *message.rbegin() != '\n') {
      std::cout << "\n";
    }
    std::cout << "Stack trace:\n"
         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
             ::testing::UnitTest::GetInstance(), actual_to_skip);
  }
  std::cout << ::std::flush;
}

◆ LogIsVisible()

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

Definition at line 128 of file gmock-internal-utils.cc.

                                                   {
  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
    // Always show the log if --gmock_verbose=info.
    return true;
  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
    // Always hide it if --gmock_verbose=error.
    return false;
  } else {
    // If --gmock_verbose is neither "info" nor "error", we treat it
    // as "warning" (its default value).
    return severity == kWarning;
  }
}

◆ LogToStderr()

void testing::internal::LogToStderr ( )

inline

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

988{}

◆ LogWithLocation()

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

Definition at line 72 of file gmock-spec-builders.cc.

                                                          {
  ::std::ostringstream s;
  s << internal::FormatFileLocation(file, line) << " " << message
    << ::std::endl;
  Log(severity, s.str(), 0);
}

◆ MakeAction() [1/2]

template<typename F , typename Impl >

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

Definition at line 1536 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 1542 of file gmock-actions.h.

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

◆ MakeAndRegisterTestInfo()

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
	)

Definition at line 2756 of file gtest.cc.

                                                                  {
  TestInfo* const test_info =
      new TestInfo(test_suite_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

◆ operator!=()

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

inline

Definition at line 1537 of file gtest.h.

1537{ return false; }

◆ operator==()

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

inline

Definition at line 1536 of file gtest.h.

1536{ return true; }

◆ OutputFlagAlsoCheckEnvVar()

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

Definition at line 1411 of file gtest-port.cc.

                                     {
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (nullptr != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

◆ ParseGoogleTestFlagsOnly() [1/2]

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

Definition at line 6607 of file gtest.cc.

                                                      {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
 
  // Fix the value of *_NSGetArgc() on macOS, but if and only if
  // *_NSGetArgv() == argv
  // Only applicable to char** version of argv
#if GTEST_OS_MAC
#ifndef GTEST_OS_IOS
  if (*_NSGetArgv() == argv) {
    *_NSGetArgc() = *argc;
  }
#endif
#endif
}

◆ ParseGoogleTestFlagsOnly() [2/2]

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

Definition at line 6621 of file gtest.cc.

                                                         {
  ParseGoogleTestFlagsOnlyImpl(argc, argv);
}

◆ ParseGoogleTestFlagsOnlyImpl()

template<typename CharType >

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

Definition at line 6554 of file gtest.cc.

                                                              {
  for (int i = 1; i < *argc; i++) {
    const std::string arg_string = StreamableToString(argv[i]);
    const char* const arg = arg_string.c_str();
 
    using internal::ParseBoolFlag;
    using internal::ParseInt32Flag;
    using internal::ParseStringFlag;
 
    bool remove_flag = false;
    if (ParseGoogleTestFlag(arg)) {
      remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
      LoadFlagsFromFile(GTEST_FLAG(flagfile));
      remove_flag = true;
#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
    } else if (arg_string == "--help" || arg_string == "-h" ||
               arg_string == "-?" || arg_string == "/?" ||
               HasGoogleTestFlagPrefix(arg)) {
      // Both help flag and unrecognized Google Test flags (excluding
      // internal ones) trigger help display.
      g_help_flag = true;
    }
 
    if (remove_flag) {
      // Shift the remainder of the argv list left by one.  Note
      // that argv has (*argc + 1) elements, the last one always being
      // NULL.  The following loop moves the trailing NULL element as
      // well.
      for (int j = i; j != *argc; j++) {
        argv[j] = argv[j + 1];
      }
 
      // Decrements the argument count.
      (*argc)--;
 
      // We also need to decrement the iterator as we just removed
      // an element.
      i--;
    }
  }
 
  if (g_help_flag) {
    // We print the help here instead of in RUN_ALL_TESTS(), as the
    // latter may not be called at all if the user is using Google
    // Test with another testing framework.
    PrintColorEncoded(kColorEncodedHelpMessage);
  }
}

◆ ParseInt32()

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

Definition at line 1323 of file gtest-port.cc.

                                                                          {
  // Parses the environment variable as a decimal integer.
  char* end = nullptr;
  const long long_value = strtol(str, &end, 10);  // NOLINT
 
  // Has strtol() consumed all characters in the string?
  if (*end != '\0') {
    // No - an invalid character was encountered.
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value \"" << str << "\".\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }
 
  // Is the parsed value in the range of an int32_t?
  const auto result = static_cast<int32_t>(long_value);
  if (long_value == LONG_MAX || long_value == LONG_MIN ||
      // The parsed value overflows as a long.  (strtol() returns
      // LONG_MAX or LONG_MIN when the input overflows.)
      result != long_value
      // The parsed value overflows as an int32_t.
      ) {
    Message msg;
    msg << "WARNING: " << src_text
        << " is expected to be a 32-bit integer, but actually"
        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
  }
 
  *value = result;
  return true;
}

◆ ParseInt32Flag()

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

Definition at line 6320 of file gtest.cc.

                                                                       {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);
 
  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;
 
  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag,
                    value_str, value);
}

◆ PrintBytesInObjectTo() [1/2]

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

◆ PrintBytesInObjectTo() [2/2]

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

Definition at line 129 of file gtest-printers.cc.

                                       {
  PrintBytesInObjectToImpl(obj_bytes, count, os);
}

◆ PrintCharAndCodeTo()

template<typename Char >

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

Definition at line 270 of file gtest-printers.cc.

                                             {
  // First, print c as a literal in the most readable form we can find.
  *os << GetCharWidthPrefix(c) << "'";
  const CharFormat format = PrintAsCharLiteralTo(c, os);
  *os << "'";
 
  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);
 
  // For more convenience, we print c's code again in hexadecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
  }
  *os << ")";
}

◆ PrintRawArrayTo()

template<typename T >

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

Definition at line 539 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 601 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 612 of file gtest-printers.h.

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

◆ PrintStringTo() [1/2]

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

◆ PrintStringTo() [2/2]

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

Definition at line 503 of file gtest-printers.cc.

                                                    {
  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
    if (GTEST_FLAG(print_utf8)) {
      ConditionalPrintAsText(s.data(), s.size(), os);
    }
  }
}

◆ PrintTo() [1/34]

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

inline

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

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

◆ PrintTo() [2/34]

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

inline

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

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

◆ PrintTo() [3/34]

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() [4/34]

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

inline

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

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

◆ PrintTo() [5/34]

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() [6/34]

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

inline

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

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

◆ PrintTo() [7/34]

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

Definition at line 302 of file gtest-printers.cc.

                                         {
  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
      << static_cast<uint32_t>(c);
}

◆ PrintTo() [8/34]

template<typename T1 , typename T2 >

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

Definition at line 660 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 << ')';
}

◆ PrintTo() [9/34]

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

inline

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

                                                        {
  PrintStringTo(s, os);
}

◆ PrintTo() [10/34]

template<typename... Types>

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

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

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

◆ PrintTo() [11/34]

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

inline

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

                                                           {
  PrintU16StringTo(s, os);
}

◆ PrintTo() [12/34]

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

inline

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

                                                           {
  PrintU32StringTo(s, os);
}

◆ PrintTo() [13/34]

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

◆ PrintTo() [14/34]

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

Definition at line 415 of file gtest-printers.cc.

415{ PrintCStringTo(s, os); }

◆ PrintTo() [15/34]

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

◆ PrintTo() [16/34]

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

Definition at line 421 of file gtest-printers.cc.

421{ PrintCStringTo(s, os); }

◆ PrintTo() [17/34]

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

◆ PrintTo() [18/34]

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

Definition at line 423 of file gtest-printers.cc.

423{ PrintCStringTo(s, os); }

◆ PrintTo() [19/34]

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

inline

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

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

◆ PrintTo() [20/34]

template<typename T >

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

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

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

◆ PrintTo() [21/34]

template<typename T , typename D >

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

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

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

◆ PrintTo() [22/34]

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() [23/34]

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

inline

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

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

◆ PrintTo() [24/34]

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

◆ PrintTo() [25/34]

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

Definition at line 433 of file gtest-printers.cc.

433{ PrintCStringTo(s, os); }

◆ PrintTo() [26/34]

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

inline

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

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

◆ PrintTo() [27/34]

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

Definition at line 295 of file gtest-printers.cc.

295{ PrintCharAndCodeTo(c, os); }

testing::internal::PrintCharAndCodeTo

void PrintCharAndCodeTo(Char c, ostream *os)

Definition: gtest-printers.cc:270

◆ PrintTo() [28/34]

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

inline

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

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

◆ PrintTo() [29/34]

template<typename T >

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

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

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

◆ PrintTo() [30/34]

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

inline

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

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

◆ PrintTo() [31/34]

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

Definition at line 294 of file gtest-printers.cc.

294{ PrintCharAndCodeTo(c, os); }

◆ PrintTo() [32/34]

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

inline

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

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

◆ PrintTo() [33/34]

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

◆ PrintTo() [34/34]

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

Definition at line 299 of file gtest-printers.cc.

299{ PrintCharAndCodeTo(wc, os); }

◆ PrintTupleTo() [1/2]

template<typename T >

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

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

636 {}

◆ 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 639 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() [1/2]

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

◆ PrintU16StringTo() [2/2]

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

Definition at line 517 of file gtest-printers.cc.

                                                          {
  PrintCharsAsStringTo(s.data(), s.size(), os);
}

◆ PrintU32StringTo() [1/2]

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

◆ PrintU32StringTo() [2/2]

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

Definition at line 521 of file gtest-printers.cc.

                                                          {
  PrintCharsAsStringTo(s.data(), s.size(), 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()

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

Definition at line 1247 of file gtest-port.cc.

                                     {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];
 
  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far
 
  fseek(file, 0, SEEK_SET);
 
  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);
 
  const std::string content(buffer, bytes_read);
  delete[] buffer;
 
  return content;
}

◆ RegisterTypeParameterizedTestSuite()

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

Definition at line 512 of file gtest.cc.

                                                                    {
  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
      test_suite_name, code_location);
}

◆ RegisterTypeParameterizedTestSuiteInstantiation()

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

Definition at line 518 of file gtest.cc.

                                                                            {
  GetUnitTestImpl()
      ->type_parameterized_test_registry()
      .RegisterInstantiation(case_name);
}

◆ ReportFailureInUnknownLocation()

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

Definition at line 2455 of file gtest.cc.

                                                              {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      nullptr,  // No info about the source file where the exception occurred.
      -1,       // We have no info on which line caused the exception.
      message,
      "");  // No stack trace, either.
}

◆ ReportInvalidTestSuiteType()

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

Definition at line 2768 of file gtest.cc.

                                                            {
  Message errors;
  errors
      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
      << "All tests in the same test suite must use the same test fixture\n"
      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test suites.";
 
  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
                                          code_location.line)
                    << " " << errors.GetString();
}

◆ ReportUninterestingCall()

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

Definition at line 283 of file gmock-spec-builders.cc.

                                                                          {
  // Include a stack trace only if --gmock_verbose=info is specified.
  const int stack_frames_to_skip =
      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
  switch (reaction) {
    case kAllow:
      Log(kInfo, msg, stack_frames_to_skip);
      break;
    case kWarn:
      Log(kWarning,
          msg +
              "\nNOTE: You can safely ignore the above warning unless this "
              "call should not happen.  Do not suppress it by blindly adding "
              "an EXPECT_CALL() if you don't mean to enforce the call.  "
              "See "
              "https://github.com/google/googletest/blob/master/docs/"
              "gmock_cook_book.md#"
              "knowing-when-to-expect for details.\n",
          stack_frames_to_skip);
      break;
    default:  // FAIL
      Expect(false, nullptr, -1, msg);
  }
}

◆ ShouldRunTestOnShard()

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

Definition at line 6013 of file gtest.cc.

                                                                          {
  return (test_id % total_shards) == shard_index;
}

◆ ShouldShard()

bool testing::internal::ShouldShard	(	const char *	total_shards_env,
		const char *	shard_index_env,
		bool	in_subprocess_for_death_test
	)

Definition at line 5950 of file gtest.cc.

                                                    {
  if (in_subprocess_for_death_test) {
    return false;
  }
 
  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
 
  if (total_shards == -1 && shard_index == -1) {
    return false;
  } else if (total_shards == -1 && shard_index != -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestShardIndex << " = " << shard_index
      << ", but have left " << kTestTotalShards << " unset.\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (total_shards != -1 && shard_index == -1) {
    const Message msg = Message()
      << "Invalid environment variables: you have "
      << kTestTotalShards << " = " << total_shards
      << ", but have left " << kTestShardIndex << " unset.\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  } else if (shard_index < 0 || shard_index >= total_shards) {
    const Message msg = Message()
      << "Invalid environment variables: we require 0 <= "
      << kTestShardIndex << " < " << kTestTotalShards
      << ", but you have " << kTestShardIndex << "=" << shard_index
      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
    fflush(stdout);
    exit(EXIT_FAILURE);
  }
 
  return total_shards > 1;
}

◆ ShouldUseColor()

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

Definition at line 3234 of file gtest.cc.

                                        {
  const char* const gtest_color = GTEST_FLAG(color).c_str();
 
  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
    // On Windows the TERM variable is usually not set, but the
    // console there does support colors.
    return stdout_is_tty;
#else
    // On non-Windows platforms, we rely on the TERM variable.
    const char* const term = posix::GetEnv("TERM");
    const bool term_supports_color =
        String::CStringEquals(term, "xterm") ||
        String::CStringEquals(term, "xterm-color") ||
        String::CStringEquals(term, "xterm-256color") ||
        String::CStringEquals(term, "screen") ||
        String::CStringEquals(term, "screen-256color") ||
        String::CStringEquals(term, "tmux") ||
        String::CStringEquals(term, "tmux-256color") ||
        String::CStringEquals(term, "rxvt-unicode") ||
        String::CStringEquals(term, "rxvt-unicode-256color") ||
        String::CStringEquals(term, "linux") ||
        String::CStringEquals(term, "cygwin");
    return stdout_is_tty && term_supports_color;
#endif  // GTEST_OS_WINDOWS
  }
 
  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
      String::CStringEquals(gtest_color, "1");
  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
  // value is neither one of these nor "auto", we treat it as "no" to
  // be conservative.
}

◆ SkipPrefix()

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

Definition at line 6253 of file gtest.cc.

                                                       {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

◆ SplitString()

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

Definition at line 1132 of file gtest.cc.

                                              {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

◆ StreamableToString()

template<typename T >

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

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

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

◆ StrictnessModifierProbe() [1/4]

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

◆ 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 NiceMock< T > & )

◆ StrictnessModifierProbe() [4/4]

template<typename T >

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

◆ StringFromGTestEnv()

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

Definition at line 1422 of file gtest-port.cc.

                                                                            {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const value = posix::GetEnv(env_var.c_str());
  return value == nullptr ? default_value : value;
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
}

◆ StringStreamToString()

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

Definition at line 2164 of file gtest.cc.

                                                    {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();
 
  std::string result;
  result.reserve(static_cast<size_t>(2 * (end - start)));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }
 
  return result;
}

◆ StripTrailingSpaces()

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

inline

Definition at line 1968 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 988 of file gtest-printers.h.

989 {}

◆ 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 991 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());
}

◆ TEST() [1/37]

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

Definition at line 221 of file gtest-unittest-api_test.cc.

221{}

◆ TEST() [2/37]

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

Definition at line 200 of file gtest-unittest-api_test.cc.

                                              {
  const TestSuite* test_suite = UnitTestHelper::FindTestSuite("DISABLED_Test");
  ASSERT_TRUE(test_suite != nullptr);
 
  EXPECT_STREQ("DISABLED_Test", test_suite->name());
  EXPECT_TRUE(IsNull(test_suite->type_param()));
  EXPECT_FALSE(test_suite->should_run());
  EXPECT_EQ(1, test_suite->disabled_test_count());
  EXPECT_EQ(0, test_suite->test_to_run_count());
  ASSERT_EQ(1, test_suite->total_test_count());
 
  const TestInfo* const test_info = test_suite->GetTestInfo(0);
  EXPECT_STREQ("Dummy2", test_info->name());
  EXPECT_STREQ("DISABLED_Test", test_info->test_suite_name());
  EXPECT_TRUE(IsNull(test_info->value_param()));
  EXPECT_TRUE(IsNull(test_info->type_param()));
  EXPECT_FALSE(test_info->should_run());
}

◆ TEST() [3/37]

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

Definition at line 139 of file gtest-unittest-api_test.cc.

                                               {
  const TestSuite* test_suite = UnitTestHelper::FindTestSuite("ApiTest");
  ASSERT_TRUE(test_suite != nullptr);
 
  EXPECT_STREQ("ApiTest", test_suite->name());
  EXPECT_TRUE(IsNull(test_suite->type_param()));
  EXPECT_TRUE(test_suite->should_run());
  EXPECT_EQ(1, test_suite->disabled_test_count());
  EXPECT_EQ(3, test_suite->test_to_run_count());
  ASSERT_EQ(4, test_suite->total_test_count());
 
  const TestInfo** tests = UnitTestHelper::GetSortedTests(test_suite);
 
  EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
  EXPECT_STREQ("ApiTest", tests[0]->test_suite_name());
  EXPECT_TRUE(IsNull(tests[0]->value_param()));
  EXPECT_TRUE(IsNull(tests[0]->type_param()));
  EXPECT_FALSE(tests[0]->should_run());
 
  EXPECT_STREQ("TestSuiteDisabledAccessorsWork", tests[1]->name());
  EXPECT_STREQ("ApiTest", tests[1]->test_suite_name());
  EXPECT_TRUE(IsNull(tests[1]->value_param()));
  EXPECT_TRUE(IsNull(tests[1]->type_param()));
  EXPECT_TRUE(tests[1]->should_run());
 
  EXPECT_STREQ("TestSuiteImmutableAccessorsWork", tests[2]->name());
  EXPECT_STREQ("ApiTest", tests[2]->test_suite_name());
  EXPECT_TRUE(IsNull(tests[2]->value_param()));
  EXPECT_TRUE(IsNull(tests[2]->type_param()));
  EXPECT_TRUE(tests[2]->should_run());
 
  EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
  EXPECT_STREQ("ApiTest", tests[3]->test_suite_name());
  EXPECT_TRUE(IsNull(tests[3]->value_param()));
  EXPECT_TRUE(IsNull(tests[3]->type_param()));
  EXPECT_TRUE(tests[3]->should_run());
 
  delete[] tests;
  tests = nullptr;
 
  test_suite = UnitTestHelper::FindTestSuite("TestSuiteWithCommentTest/0");
  ASSERT_TRUE(test_suite != nullptr);
 
  EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suite->name());
  EXPECT_STREQ(GetTypeName<Types<int>>().c_str(), test_suite->type_param());
  EXPECT_TRUE(test_suite->should_run());
  EXPECT_EQ(0, test_suite->disabled_test_count());
  EXPECT_EQ(1, test_suite->test_to_run_count());
  ASSERT_EQ(1, test_suite->total_test_count());
 
  tests = UnitTestHelper::GetSortedTests(test_suite);
 
  EXPECT_STREQ("Dummy", tests[0]->name());
  EXPECT_STREQ("TestSuiteWithCommentTest/0", tests[0]->test_suite_name());
  EXPECT_TRUE(IsNull(tests[0]->value_param()));
  EXPECT_STREQ(GetTypeName<Types<int>>().c_str(), tests[0]->type_param());
  EXPECT_TRUE(tests[0]->should_run());
 
  delete[] tests;
}

◆ TEST() [4/37]

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

Definition at line 108 of file gtest-unittest-api_test.cc.

                                              {
  UnitTest* unit_test = UnitTest::GetInstance();
 
  ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count());
  EXPECT_EQ(1 + kTypedTestSuites, unit_test->test_suite_to_run_count());
  EXPECT_EQ(2, unit_test->disabled_test_count());
  EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
  EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
 
  const TestSuite** const test_suites = UnitTestHelper::GetSortedTestSuites();
 
  EXPECT_STREQ("ApiTest", test_suites[0]->name());
  EXPECT_STREQ("DISABLED_Test", test_suites[1]->name());
  EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suites[2]->name());
 
  delete[] test_suites;
 
  // The following lines initiate actions to verify certain methods in
  // FinalSuccessChecker::TearDown.
 
  // Records a test property to verify TestResult::GetTestProperty().
  RecordProperty("key", "value");
}

◆ TEST() [5/37]

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

Definition at line 929 of file googletest-port-test.cc.

                                                   {
  CaptureStdout();
  EXPECT_DEATH_IF_SUPPORTED(CaptureStdout(),
                            "Only one stdout capturer can exist at a time");
  GetCapturedStdout();
 
  // We cannot test stderr capturing using death tests as they use it
  // themselves.
}

◆ TEST() [6/37]

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

Definition at line 909 of file googletest-port-test.cc.

                                  {
  CaptureStderr();
  fprintf(stderr, "jkl");
  EXPECT_STREQ("jkl", GetCapturedStderr().c_str());
 
  CaptureStderr();
  fprintf(stderr, "jkl%cmno", '\0');
  EXPECT_EQ(::std::string("jkl\0mno", 7), ::std::string(GetCapturedStderr()));
}

◆ TEST() [7/37]

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

Definition at line 899 of file googletest-port-test.cc.

                                  {
  CaptureStdout();
  fprintf(stdout, "abc");
  EXPECT_STREQ("abc", GetCapturedStdout().c_str());
 
  CaptureStdout();
  fprintf(stdout, "def%cghi", '\0');
  EXPECT_EQ(::std::string("def\0ghi", 7), ::std::string(GetCapturedStdout()));
}

◆ TEST() [8/37]

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

Definition at line 920 of file googletest-port-test.cc.

                                           {
  CaptureStdout();
  CaptureStderr();
  fprintf(stdout, "pqr");
  fprintf(stderr, "stu");
  EXPECT_STREQ("pqr", GetCapturedStdout().c_str());
  EXPECT_STREQ("stu", GetCapturedStderr().c_str());
}

◆ TEST() [9/37]

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

Definition at line 222 of file gtest-unittest-api_test.cc.

222{}

◆ TEST() [10/37]

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

Definition at line 264 of file googletest-port-test.cc.

                                                                     {
  EXPECT_EQ("foo.cc:42", FormatCompilerIndependentFileLocation("foo.cc", 42));
}

◆ TEST() [11/37]

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

Definition at line 268 of file googletest-port-test.cc.

                                                                   {
  EXPECT_EQ("unknown file:42",
            FormatCompilerIndependentFileLocation(nullptr, 42));
}

◆ TEST() [12/37]

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

Definition at line 277 of file googletest-port-test.cc.

                                                                          {
  EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(nullptr, -1));
}

◆ TEST() [13/37]

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

Definition at line 273 of file googletest-port-test.cc.

                                                                   {
  EXPECT_EQ("foo.cc", FormatCompilerIndependentFileLocation("foo.cc", -1));
}

◆ TEST() [14/37]

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

Definition at line 244 of file googletest-port-test.cc.

                                                  {
  EXPECT_PRED_FORMAT2(IsSubstring, "foo.cc", FormatFileLocation("foo.cc", 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation("foo.cc", 42));
}

◆ TEST() [15/37]

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

Definition at line 259 of file googletest-port-test.cc.

                                                       {
  EXPECT_EQ("unknown file:", FormatFileLocation(nullptr, -1));
}

◆ TEST() [16/37]

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

Definition at line 255 of file googletest-port-test.cc.

                                                {
  EXPECT_EQ("foo.cc:", FormatFileLocation("foo.cc", -1));
}

◆ TEST() [17/37]

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

Definition at line 249 of file googletest-port-test.cc.

                                                 {
  EXPECT_PRED_FORMAT2(IsSubstring, "unknown file",
                      FormatFileLocation(nullptr, 42));
  EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(nullptr, 42));
}

◆ TEST() [18/37]

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

Definition at line 324 of file googletest-port-test.cc.

                                                              {
  EXPECT_EQ(0U, GetThreadCount());
}

◆ TEST() [19/37]

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

Definition at line 329 of file googletest-port-test.cc.

                                                          {
  const bool a_false_condition = false;
  const char regex[] =
#ifdef _MSC_VER
     "googletest-port-test\\.cc\\(\\d+\\):"
#elif GTEST_USES_POSIX_RE
     "googletest-port-test\\.cc:[0-9]+"
#else
     "googletest-port-test\\.cc:\\d+"
#endif  // _MSC_VER
     ".*a_false_condition.*Extra info.*";
 
  EXPECT_DEATH_IF_SUPPORTED(GTEST_CHECK_(a_false_condition) << "Extra info",
                            regex);
}

◆ TEST() [20/37]

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

Definition at line 211 of file googletest-port-test.cc.

                                                        {
  if (AlwaysFalse())
    GTEST_CHECK_(false) << "This should never be executed; "
                           "It's a compilation test only.";
 
  if (AlwaysTrue())
    GTEST_CHECK_(true);
  else
    ;  // NOLINT
 
  if (AlwaysFalse())
    ;  // NOLINT
  else
    GTEST_CHECK_(true) << "";
}

◆ TEST() [21/37]

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

Definition at line 230 of file googletest-port-test.cc.

                                            {
  switch (0) {
    case 1:
      break;
    default:
      GTEST_CHECK_(true);
  }
 
  switch (0)
    case 0:
      GTEST_CHECK_(true) << "Check failed in switch case";
}

◆ TEST() [22/37]

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

Definition at line 176 of file googletest-port-test.cc.

                                                                          {
  bool converted = false;
  bool const_converted = false;
  ConstAndNonConstCastable castable(&converted, &const_converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
  EXPECT_TRUE(converted);
  EXPECT_FALSE(const_converted);
 
  converted = false;
  const_converted = false;
  const ConstAndNonConstCastable const_castable(&converted, &const_converted);
  base = ::testing::internal::ImplicitCast_<Base>(const_castable);
  EXPECT_FALSE(converted);
  EXPECT_TRUE(const_converted);
}

◆ TEST() [23/37]

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

Definition at line 151 of file googletest-port-test.cc.

                                                             {
  bool converted = false;
  const ConstCastable const_castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(const_castable);
  EXPECT_TRUE(converted);
}

◆ TEST() [24/37]

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

Definition at line 197 of file googletest-port-test.cc.

                                                  {
  bool converted = false;
  To to = ::testing::internal::ImplicitCast_<To>(&converted);
  (void)to;
  EXPECT_TRUE(converted);
}

◆ TEST() [25/37]

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

Definition at line 114 of file googletest-port-test.cc.

                                          {
  Derived derived(1);
  Base base = ::testing::internal::ImplicitCast_<Base>(derived);
  EXPECT_EQ(derived.member(), base.member());
}

◆ TEST() [26/37]

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

Definition at line 132 of file googletest-port-test.cc.

                                                   {
  bool converted = false;
  Castable castable(&converted);
  Base base = ::testing::internal::ImplicitCast_<Base>(castable);
  EXPECT_TRUE(converted);
}

◆ TEST() [27/37]

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

Definition at line 109 of file googletest-port-test.cc.

                                         {
  Derived derived(0);
  EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_<Base*>(&derived));
}

◆ TEST() [28/37]

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

Definition at line 67 of file googletest-port-test.cc.

                                                  {
  EXPECT_FALSE(IsXDigit(static_cast<char>('\x80')));
  EXPECT_FALSE(IsXDigit(static_cast<char>('0' | '\x80')));
}

◆ TEST() [29/37]

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

Definition at line 85 of file googletest-port-test.cc.

                                                {
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
  EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
}

◆ TEST() [30/37]

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

Definition at line 54 of file googletest-port-test.cc.

                                        {
  EXPECT_TRUE(IsXDigit('0'));
  EXPECT_TRUE(IsXDigit('9'));
  EXPECT_TRUE(IsXDigit('A'));
  EXPECT_TRUE(IsXDigit('F'));
  EXPECT_TRUE(IsXDigit('a'));
  EXPECT_TRUE(IsXDigit('f'));
 
  EXPECT_FALSE(IsXDigit('-'));
  EXPECT_FALSE(IsXDigit('g'));
  EXPECT_FALSE(IsXDigit('G'));
}

◆ TEST() [31/37]

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

Definition at line 72 of file googletest-port-test.cc.

                                      {
  EXPECT_TRUE(IsXDigit(L'0'));
  EXPECT_TRUE(IsXDigit(L'9'));
  EXPECT_TRUE(IsXDigit(L'A'));
  EXPECT_TRUE(IsXDigit(L'F'));
  EXPECT_TRUE(IsXDigit(L'a'));
  EXPECT_TRUE(IsXDigit(L'f'));
 
  EXPECT_FALSE(IsXDigit(L'-'));
  EXPECT_FALSE(IsXDigit(L'g'));
  EXPECT_FALSE(IsXDigit(L'G'));
}

◆ TEST() [32/37]

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

Definition at line 360 of file googletest-port-test.cc.

                                                          {
#if !GTEST_USES_PCRE
# if GTEST_HAS_POSIX_RE
 
  EXPECT_TRUE(GTEST_USES_POSIX_RE);
 
# else
 
  EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
 
# endif
#endif  // !GTEST_USES_PCRE
}

◆ TEST() [33/37]

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

Definition at line 941 of file googletest-port-test.cc.

                                                                    {
  ThreadLocal<int> t1;
  EXPECT_EQ(0, t1.get());
 
  ThreadLocal<void*> t2;
  EXPECT_TRUE(t2.get() == nullptr);
}

◆ TEST() [34/37]

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

Definition at line 969 of file googletest-port-test.cc.

                                                    {
  ThreadLocal<std::string> thread_local_string;
 
  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
 
  // Verifies the condition still holds after calling set.
  thread_local_string.set("foo");
  EXPECT_EQ(thread_local_string.pointer(), &(thread_local_string.get()));
}

◆ TEST() [35/37]

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

Definition at line 979 of file googletest-port-test.cc.

                                                             {
  ThreadLocal<std::string> thread_local_string;
  const ThreadLocal<std::string>& const_thread_local_string =
      thread_local_string;
 
  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
 
  thread_local_string.set("foo");
  EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
}

◆ TEST() [36/37]

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

Definition at line 949 of file googletest-port-test.cc.

                                                                {
  ThreadLocal<int> t1(123);
  EXPECT_EQ(123, t1.get());
 
  int i = 0;
  ThreadLocal<int*> t2(&i);
  EXPECT_EQ(&i, t2.get());
}

◆ TEST() [37/37]

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

Definition at line 964 of file googletest-port-test.cc.

                                                                          {
  ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo"));
  bar.pointer();
}

◆ TEST_F() [1/2]

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

Definition at line 233 of file googletest-listener-test.cc.

                              {
  g_events->push_back("ListenerTest::* Test Body");
  SUCCEED();  // Triggers OnTestPartResult.
}

◆ TEST_F() [2/2]

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

Definition at line 226 of file googletest-listener-test.cc.

                              {
  // Test execution order within a test case is not guaranteed so we are not
  // recording the test name.
  g_events->push_back("ListenerTest::* Test Body");
  SUCCEED();  // Triggers OnTestPartResult.
}

◆ TestNotEmpty() [1/2]

template<typename T = int>

void testing::internal::TestNotEmpty ( )

Definition at line 383 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 387 of file gtest-param-util.h.

387{}

◆ ToLower()

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

inline

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

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

◆ TYPED_TEST()

testing::internal::TYPED_TEST	(	TestSuiteWithCommentTest	,
		Dummy
	)

Definition at line 100 of file gtest-unittest-api_test.cc.

100{}

◆ TYPED_TEST_SUITE()

testing::internal::TYPED_TEST_SUITE	(	TestSuiteWithCommentTest	,
		Types< int >
	)

◆ UniversalPrint()

template<typename T >

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

Definition at line 976 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/9]

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

◆ UniversalPrintArray() [2/9]

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

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

                                                                     {
  UniversalPrintCharArray(begin, len, os);
}

◆ UniversalPrintArray() [3/9]

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

◆ UniversalPrintArray() [4/9]

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

Definition at line 384 of file gtest-printers.cc.

                                                                         {
  UniversalPrintCharArray(begin, len, os);
}

◆ UniversalPrintArray() [5/9]

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

◆ UniversalPrintArray() [6/9]

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

Definition at line 390 of file gtest-printers.cc.

                                                                         {
  UniversalPrintCharArray(begin, len, os);
}

◆ UniversalPrintArray() [7/9]

template<typename T >

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

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

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

◆ UniversalPrintArray() [9/9]

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

Definition at line 396 of file gtest-printers.cc.

                                                                        {
  UniversalPrintCharArray(begin, len, os);
}

◆ UniversalTersePrint()

template<typename T >

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

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

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

◆ UniversalTersePrintTupleFieldsToStrings()

template<typename Tuple >

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

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

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

◆ VoidifyPointer() [1/2]

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

inline

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

595{ return p; }

◆ VoidifyPointer() [2/2]

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

inline

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

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

◆ WideStringToUtf8()

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

Definition at line 1997 of file gtest.cc.

                                                              {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));
 
  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    uint32_t unicode_code_point;
 
    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<uint32_t>(str[i]);
    }
 
    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

◆ WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Definition at line 5928 of file gtest.cc.

                                      {
  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
  if (test_shard_file != nullptr) {
    FILE* const file = posix::FOpen(test_shard_file, "w");
    if (file == nullptr) {
      ColoredPrintf(GTestColor::kRed,
                    "Could not write to the test shard status file \"%s\" "
                    "specified by the %s environment variable.\n",
                    test_shard_file, kTestShardStatusFile);
      fflush(stdout);
      exit(EXIT_FAILURE);
    }
    fclose(file);
  }
}

Variable Documentation

◆ g_argvs

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

Definition at line 578 of file gtest.cc.

◆ g_gmock_implicit_sequence

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

Definition at line 279 of file gmock-spec-builders.cc.

◆ g_help_flag

bool testing::internal::g_help_flag = false

Definition at line 178 of file gtest.cc.

◆ kCurrentDirectoryString

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

Definition at line 81 of file gtest-filepath.cc.

◆ kDeathTestStyleFlag

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

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

◆ kDeathTestUseFork

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

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

◆ kErrorVerbosity

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

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

◆ kInfoVerbosity

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

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

◆ kInternalRunDeathTestFlag

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

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

◆ kMaxBiggestInt

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

constexpr

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

◆ kMaxCodePoint1

constexpr uint32_t testing::internal::kMaxCodePoint1 = (static_cast<uint32_t>(1) << 7) - 1

constexpr

Definition at line 1904 of file gtest.cc.

◆ kMaxCodePoint2

constexpr uint32_t testing::internal::kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1

constexpr

Definition at line 1907 of file gtest.cc.

◆ kMaxCodePoint3

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

constexpr

Definition at line 1910 of file gtest.cc.

◆ kMaxCodePoint4

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

constexpr

Definition at line 1913 of file gtest.cc.

◆ kPathSeparator

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

Definition at line 80 of file gtest-filepath.cc.

◆ kStackTraceMarker

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

Definition at line 174 of file gtest.cc.

◆ kStdErrFileno

const int testing::internal::kStdErrFileno = STDERR_FILENO

Definition at line 98 of file gtest-port.cc.

◆ kStdOutFileno

const int testing::internal::kStdOutFileno = STDOUT_FILENO

Definition at line 97 of file gtest-port.cc.

◆ kTestTypeIdInGoogleTest

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

extern

◆ kTypedTests

const int testing::internal::kTypedTests = 1

Definition at line 103 of file gtest-unittest-api_test.cc.

◆ kTypedTestSuites

const int testing::internal::kTypedTestSuites = 1

Definition at line 102 of file gtest-unittest-api_test.cc.

◆ kUnknownFile

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

Definition at line 1019 of file gtest-port.cc.

◆ kWarningVerbosity

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

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BiggestInt

◆ disjunction

◆ Double

◆ Float

◆ identity_t

◆ IndexSequenceFor

◆ IsContainer

◆ IsNotContainer

◆ LosslessArithmeticConvertible

◆ LosslessArithmeticConvertibleImpl

◆ MakeIndexSequence

◆ MutexLock

◆ ParameterizedTestCaseInfo

◆ SetUpTearDownSuiteFuncType

◆ SetUpTestSuiteFunc

◆ Strings

◆ TearDownTestSuiteFunc

◆ TimeInMillis

◆ TypedTestCasePState

◆ TypeId

Enumeration Type Documentation

◆ CharFormat

◆ GTestLogSeverity

◆ LogSeverity

◆ TypeKind

Function Documentation

◆ AlwaysFalse()

◆ AlwaysTrue()

◆ AppendUserMessage()

◆ Apply()

◆ ApplyImpl()

◆ ArrayAwareFind()

◆ ArrayEq() [1/3]

◆ ArrayEq() [2/3]

◆ ArrayEq() [3/3]

◆ Assert() [1/2]

◆ Assert() [2/2]

◆ BoolFromGTestEnv()

◆ CanonicalizeForStdLibVersioning()

◆ CaptureStderr()

◆ CaptureStdout()

◆ CheckedDowncastToActualType()

◆ ChopLowBits()

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

◆ CreateCodePointFromUtf16SurrogatePair()

◆ DefaultParamName()

◆ DiffStrings()

◆ DoubleNearPredFormat()

◆ DownCast_()

◆ EqFailure()

◆ Expect() [1/2]

◆ Expect() [2/2]

◆ FindMaxBipartiteMatching()

◆ FloatingPointLE()

◆ FlushInfoLog()

◆ FormatCompilerIndependentFileLocation()

◆ FormatEpochTimeInMillisAsIso8601()

◆ FormatFileLocation()

◆ FormatForComparisonFailureMessage()