Classes
class	GreaterThanMatcher
class	EvenMatcherImpl
class	NewEvenMatcherImpl
class	ReferencesBarOrIsZeroImpl
class	PolymorphicIsEvenImpl
class	IntValue
struct	ConvertibleFromAny
struct	IntReferenceWrapper
class	Base
class	Derived
class	OtherDerived
class	Unprintable
struct	Type
class	IsGreaterThan
class	ConvertibleToBool
class	AllArgsHelper
class	FloatingPointTest
class	FloatingPointNearTest
class	ConstPropagatingPtr
class	Uncopyable
struct	AStruct
struct	DerivedStruct
class	AClass
class	DerivedClass
struct	Functor
struct	PolymorphicFunctor
struct	ReferencingFunctor
class	DivisibleByImpl
class	NotCopyable
class	Streamlike
class	UnorderedElementsAreTest
class	BacktrackingBPMTest
class	BipartiteTest
class	BipartiteNonSquareTest
class	BipartiteRandomTest
class	IsHalfOfMatcher
class	map
class	vector
class	MatchResultListener
class	Matcher
class	MatcherInterface
class	PolymorphicMatcher
class	StringMatchResultListener
class	DummyMatchResultListener
class	FloatingEqMatcher
class	linked_ptr
class	MatchMatrix
class	RE
class	scoped_ptr
class	StreamMatchResultListener

Typedefs
typedef ::testing::tuple< long, int >	Tuple2
typedef FloatingPointTest< float >	FloatTest
typedef FloatingPointNearTest< float >	FloatNearTest
typedef FloatingPointTest< double >	DoubleTest
typedef FloatingPointNearTest< double >	DoubleNearTest
typedef ::std::pair< size_t, size_t >	ElementMatcherPair
typedef ::std::vector< ElementMatcherPair >	ElementMatcherPairs
typedef ::std::vector< string >	Strings
typedef ::std::string	string

Functions
Matcher< int >	GreaterThan (int n)
string	OfType (const string &type_name)
template<typename T>
string	Describe (const Matcher< T > &m)
template<typename T>
string	DescribeNegation (const Matcher< T > &m)
template<typename MatcherType, typename Value>
string	Explain (const MatcherType &m, const Value &x)
	TEST (MatchResultListenerTest, StreamingWorks)
	TEST (MatchResultListenerTest, CanAccessUnderlyingStream)
	TEST (MatchResultListenerTest, IsInterestedWorks)
	TEST (MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI)
	TEST (MatcherInterfaceTest, CanBeImplementedUsingNewAPI)
	TEST (MatcherTest, CanBeDefaultConstructed)
	TEST (MatcherTest, CanBeConstructedFromMatcherInterface)
	TEST (MatcherTest, CanBeImplicitlyConstructedFromValue)
	TEST (MatcherTest, CanBeImplicitlyConstructedFromNULL)
	TEST (MatcherTest, IsCopyable)
	TEST (MatcherTest, CanDescribeItself)
	TEST (MatcherTest, MatchAndExplain)
	TEST (StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral)
	TEST (StringMatcherTest, CanBeImplicitlyConstructedFromString)
	TEST (MakeMatcherTest, ConstructsMatcherFromMatcherInterface)
PolymorphicMatcher< ReferencesBarOrIsZeroImpl >	ReferencesBarOrIsZero ()
	TEST (MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI)
PolymorphicMatcher< PolymorphicIsEvenImpl >	PolymorphicIsEven ()
	TEST (MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI)
	TEST (MatcherCastTest, FromPolymorphicMatcher)
bool	IsPositiveIntValue (const IntValue &foo)
	TEST (MatcherCastTest, FromCompatibleType)
	TEST (MatcherCastTest, FromConstReferenceToNonReference)
	TEST (MatcherCastTest, FromReferenceToNonReference)
	TEST (MatcherCastTest, FromNonReferenceToConstReference)
	TEST (MatcherCastTest, FromNonReferenceToReference)
	TEST (MatcherCastTest, FromSameType)
bool	operator== (const ConvertibleFromAny &a, const ConvertibleFromAny &b)
ostream &	operator<< (ostream &os, const ConvertibleFromAny &a)
	TEST (MatcherCastTest, ConversionConstructorIsUsed)
	TEST (MatcherCastTest, FromConvertibleFromAny)
bool	operator== (const IntReferenceWrapper &a, const IntReferenceWrapper &b)
	TEST (MatcherCastTest, ValueIsNotCopied)
	TEST (SafeMatcherCastTest, FromPolymorphicMatcher)
	TEST (SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType)
	TEST (SafeMatcherCastTest, FromBaseClass)
	TEST (SafeMatcherCastTest, FromConstReferenceToReference)
	TEST (SafeMatcherCastTest, FromNonReferenceToConstReference)
	TEST (SafeMatcherCastTest, FromNonReferenceToReference)
	TEST (SafeMatcherCastTest, FromSameType)
	TEST (SafeMatcherCastTest, ConversionConstructorIsUsed)
	TEST (SafeMatcherCastTest, FromConvertibleFromAny)
	TEST (SafeMatcherCastTest, ValueIsNotCopied)
	TEST (ExpectThat, TakesLiterals)
	TEST (ExpectThat, TakesFunctions)
	TEST (ATest, MatchesAnyValue)
	TEST (ATest, WorksForDerivedClass)
	TEST (ATest, CanDescribeSelf)
	TEST (AnTest, MatchesAnyValue)
	TEST (AnTest, CanDescribeSelf)
	TEST (UnderscoreTest, MatchesAnyValue)
	TEST (UnderscoreTest, CanDescribeSelf)
	TEST (EqTest, MatchesEqualValue)
	TEST (EqTest, CanDescribeSelf)
	TEST (EqTest, IsPolymorphic)
	TEST (TypedEqTest, ChecksEqualityForGivenType)
	TEST (TypedEqTest, CanDescribeSelf)
	TEST (TypedEqTest, HasSpecifiedType)
	TEST (GeTest, ImplementsGreaterThanOrEqual)
	TEST (GeTest, CanDescribeSelf)
	TEST (GtTest, ImplementsGreaterThan)
	TEST (GtTest, CanDescribeSelf)
	TEST (LeTest, ImplementsLessThanOrEqual)
	TEST (LeTest, CanDescribeSelf)
	TEST (LtTest, ImplementsLessThan)
	TEST (LtTest, CanDescribeSelf)
	TEST (NeTest, ImplementsNotEqual)
	TEST (NeTest, CanDescribeSelf)
	TEST (IsNullTest, MatchesNullPointer)
	TEST (IsNullTest, LinkedPtr)
	TEST (IsNullTest, ReferenceToConstLinkedPtr)
	TEST (IsNullTest, CanDescribeSelf)
	TEST (NotNullTest, MatchesNonNullPointer)
	TEST (NotNullTest, LinkedPtr)
	TEST (NotNullTest, ReferenceToConstLinkedPtr)
	TEST (NotNullTest, CanDescribeSelf)
	TEST (RefTest, MatchesSameVariable)
	TEST (RefTest, CanDescribeSelf)
	TEST (RefTest, CanBeUsedAsMatcherForConstReference)
	TEST (RefTest, IsCovariant)
	TEST (RefTest, ExplainsResult)
	TEST (StrEqTest, MatchesEqualString)
	TEST (StrEqTest, CanDescribeSelf)
	TEST (StrNeTest, MatchesUnequalString)
	TEST (StrNeTest, CanDescribeSelf)
	TEST (StrCaseEqTest, MatchesEqualStringIgnoringCase)
	TEST (StrCaseEqTest, MatchesEqualStringWith0IgnoringCase)
	TEST (StrCaseEqTest, CanDescribeSelf)
	TEST (StrCaseNeTest, MatchesUnequalStringIgnoringCase)
	TEST (StrCaseNeTest, CanDescribeSelf)
	TEST (HasSubstrTest, WorksForStringClasses)
	TEST (HasSubstrTest, WorksForCStrings)
	TEST (HasSubstrTest, CanDescribeSelf)
	TEST (KeyTest, CanDescribeSelf)
	TEST (KeyTest, ExplainsResult)
	TEST (KeyTest, MatchesCorrectly)
	TEST (KeyTest, SafelyCastsInnerMatcher)
	TEST (KeyTest, InsideContainsUsingMap)
	TEST (KeyTest, InsideContainsUsingMultimap)
	TEST (PairTest, Typing)
	TEST (PairTest, CanDescribeSelf)
	TEST (PairTest, CanExplainMatchResultTo)
	TEST (PairTest, MatchesCorrectly)
	TEST (PairTest, SafelyCastsInnerMatchers)
	TEST (PairTest, InsideContainsUsingMap)
	TEST (StartsWithTest, MatchesStringWithGivenPrefix)
	TEST (StartsWithTest, CanDescribeSelf)
	TEST (EndsWithTest, MatchesStringWithGivenSuffix)
	TEST (EndsWithTest, CanDescribeSelf)
	TEST (MatchesRegexTest, MatchesStringMatchingGivenRegex)
	TEST (MatchesRegexTest, CanDescribeSelf)
	TEST (ContainsRegexTest, MatchesStringContainingGivenRegex)
	TEST (ContainsRegexTest, CanDescribeSelf)
	TEST (Eq2Test, MatchesEqualArguments)
	TEST (Eq2Test, CanDescribeSelf)
	TEST (Ge2Test, MatchesGreaterThanOrEqualArguments)
	TEST (Ge2Test, CanDescribeSelf)
	TEST (Gt2Test, MatchesGreaterThanArguments)
	TEST (Gt2Test, CanDescribeSelf)
	TEST (Le2Test, MatchesLessThanOrEqualArguments)
	TEST (Le2Test, CanDescribeSelf)
	TEST (Lt2Test, MatchesLessThanArguments)
	TEST (Lt2Test, CanDescribeSelf)
	TEST (Ne2Test, MatchesUnequalArguments)
	TEST (Ne2Test, CanDescribeSelf)
	TEST (NotTest, NegatesMatcher)
	TEST (NotTest, CanDescribeSelf)
	TEST (NotTest, NotMatcherSafelyCastsMonomorphicMatchers)
void	AllOfMatches (int num, const Matcher< int > &m)
	TEST (AllOfTest, MatchesWhenAllMatch)
	TEST (AllOfTest, CanDescribeSelf)
	TEST (AllOfTest, CanDescribeNegation)
	TEST (AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers)
	TEST (AllOfTest, ExplainsResult)
void	AnyOfMatches (int num, const Matcher< int > &m)
	TEST (AnyOfTest, MatchesWhenAnyMatches)
	TEST (AnyOfTest, CanDescribeSelf)
	TEST (AnyOfTest, CanDescribeNegation)
	TEST (AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers)
	TEST (AnyOfTest, ExplainsResult)
int	IsPositive (double x)
bool	ReferencesFooAndIsZero (const int &n)
	TEST (TrulyTest, MatchesWhatSatisfiesThePredicate)
	TEST (TrulyTest, CanBeUsedWithFunctor)
ConvertibleToBool	IsNotZero (int number)
	TEST (TrulyTest, PredicateCanReturnAClassConvertibleToBool)
	TEST (TrulyTest, CanDescribeSelf)
	TEST (TrulyTest, WorksForByRefArguments)
	TEST (MatchesTest, IsSatisfiedByWhatMatchesTheMatcher)
	TEST (MatchesTest, WorksOnByRefArguments)
	TEST (MatchesTest, WorksWithMatcherOnNonRefType)
	TEST (ValueTest, WorksWithPolymorphicMatcher)
	TEST (ValueTest, WorksWithMonomorphicMatcher)
	TEST (ExplainMatchResultTest, WorksWithPolymorphicMatcher)
	TEST (ExplainMatchResultTest, WorksWithMonomorphicMatcher)
	MATCHER_P (Really, inner_matcher, "")
	TEST (ExplainMatchResultTest, WorksInsideMATCHER)
	TEST (AllArgsTest, WorksForTuple)
	TEST (AllArgsTest, WorksForNonTuple)
	TEST (AllArgsTest, WorksInWithClause)
	TEST (MatcherAssertionTest, WorksWhenMatcherIsSatisfied)
	TEST (MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied)
	TEST (MatcherAssertionTest, WorksForByRefArguments)
	TEST (MatcherAssertionTest, WorksForMonomorphicMatcher)
	TEST_F (FloatTest, FloatEqApproximatelyMatchesFloats)
	TEST_F (FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats)
	TEST_F (FloatTest, FloatEqCannotMatchNaN)
	TEST_F (FloatTest, NanSensitiveFloatEqCanMatchNaN)
	TEST_F (FloatTest, FloatEqCanDescribeSelf)
	TEST_F (FloatTest, NanSensitiveFloatEqCanDescribeSelf)
	TEST_F (FloatNearTest, FloatNearMatches)
	TEST_F (FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloats)
	TEST_F (FloatNearTest, FloatNearCanDescribeSelf)
	TEST_F (FloatNearTest, NanSensitiveFloatNearCanDescribeSelf)
	TEST_F (FloatNearTest, FloatNearCannotMatchNaN)
	TEST_F (FloatNearTest, NanSensitiveFloatNearCanMatchNaN)
	TEST_F (DoubleTest, DoubleEqApproximatelyMatchesDoubles)
	TEST_F (DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles)
	TEST_F (DoubleTest, DoubleEqCannotMatchNaN)
	TEST_F (DoubleTest, NanSensitiveDoubleEqCanMatchNaN)
	TEST_F (DoubleTest, DoubleEqCanDescribeSelf)
	TEST_F (DoubleTest, NanSensitiveDoubleEqCanDescribeSelf)
	TEST_F (DoubleNearTest, DoubleNearMatches)
	TEST_F (DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDoubles)
	TEST_F (DoubleNearTest, DoubleNearCanDescribeSelf)
	TEST_F (DoubleNearTest, ExplainsResultWhenMatchFails)
	TEST_F (DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf)
	TEST_F (DoubleNearTest, DoubleNearCannotMatchNaN)
	TEST_F (DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN)
	TEST (PointeeTest, RawPointer)
	TEST (PointeeTest, RawPointerToConst)
	TEST (PointeeTest, ReferenceToConstRawPointer)
	TEST (PointeeTest, ReferenceToNonConstRawPointer)
	MATCHER_P (FieldIIs, inner_matcher, "")
	TEST (PointeeTest, WorksWithConstPropagatingPointers)
	TEST (PointeeTest, NeverMatchesNull)
	TEST (PointeeTest, MatchesAgainstAValue)
	TEST (PointeeTest, CanDescribeSelf)
	TEST (PointeeTest, CanExplainMatchResult)
	TEST (PointeeTest, AlwaysExplainsPointee)
bool	ValueIsPositive (const Uncopyable &x)
	MATCHER_P (UncopyableIs, inner_matcher, "")
	TEST (FieldTest, WorksForNonConstField)
	TEST (FieldTest, WorksForConstField)
	TEST (FieldTest, WorksForUncopyableField)
	TEST (FieldTest, WorksForPointerField)
	TEST (FieldTest, WorksForByRefArgument)
	TEST (FieldTest, WorksForArgumentOfSubType)
	TEST (FieldTest, WorksForCompatibleMatcherType)
	TEST (FieldTest, CanDescribeSelf)
	TEST (FieldTest, CanExplainMatchResult)
	TEST (FieldForPointerTest, WorksForPointerToConst)
	TEST (FieldForPointerTest, WorksForPointerToNonConst)
	TEST (FieldForPointerTest, WorksForReferenceToConstPointer)
	TEST (FieldForPointerTest, DoesNotMatchNull)
	TEST (FieldForPointerTest, WorksForArgumentOfSubType)
	TEST (FieldForPointerTest, CanDescribeSelf)
	TEST (FieldForPointerTest, CanExplainMatchResult)
	TEST (PropertyTest, WorksForNonReferenceProperty)
	TEST (PropertyTest, WorksForReferenceToConstProperty)
	TEST (PropertyTest, WorksForReferenceToNonConstProperty)
	TEST (PropertyTest, WorksForByValueArgument)
	TEST (PropertyTest, WorksForArgumentOfSubType)
	TEST (PropertyTest, WorksForCompatibleMatcherType)
	TEST (PropertyTest, CanDescribeSelf)
	TEST (PropertyTest, CanExplainMatchResult)
	TEST (PropertyForPointerTest, WorksForPointerToConst)
	TEST (PropertyForPointerTest, WorksForPointerToNonConst)
	TEST (PropertyForPointerTest, WorksForReferenceToConstPointer)
	TEST (PropertyForPointerTest, WorksForReferenceToNonConstProperty)
	TEST (PropertyForPointerTest, WorksForArgumentOfSubType)
	TEST (PropertyForPointerTest, CanDescribeSelf)
	TEST (PropertyForPointerTest, CanExplainMatchResult)
string	IntToStringFunction (int input)
	TEST (ResultOfTest, WorksForFunctionPointers)
	TEST (ResultOfTest, CanDescribeItself)
int	IntFunction (int input)
	TEST (ResultOfTest, CanExplainMatchResult)
	TEST (ResultOfTest, WorksForNonReferenceResults)
double &	DoubleFunction (double &input)
Uncopyable &	RefUncopyableFunction (Uncopyable &obj)
	TEST (ResultOfTest, WorksForReferenceToNonConstResults)
const string &	StringFunction (const string &input)
	TEST (ResultOfTest, WorksForReferenceToConstResults)
	TEST (ResultOfTest, WorksForCompatibleMatcherTypes)
	TEST (ResultOfDeathTest, DiesOnNullFunctionPointers)
	TEST (ResultOfTest, WorksForFunctionReferences)
	TEST (ResultOfTest, WorksForFunctors)
	TEST (ResultOfTest, WorksForPolymorphicFunctors)
const int *	ReferencingFunction (const int &n)
	TEST (ResultOfTest, WorksForReferencingCallables)
PolymorphicMatcher< DivisibleByImpl >	DivisibleBy (int n)
	TEST (ExplainMatchResultTest, AllOf_False_False)
	TEST (ExplainMatchResultTest, AllOf_False_True)
	TEST (ExplainMatchResultTest, AllOf_True_False)
	TEST (ExplainMatchResultTest, AllOf_True_True)
	TEST (ExplainMatchResultTest, AllOf_True_True_2)
	TEST (ExplainmatcherResultTest, MonomorphicMatcher)
	TEST (ByRefTest, AllowsNotCopyableConstValueInMatchers)
	TEST (ByRefTest, AllowsNotCopyableValueInMatchers)
	TEST (IsEmptyTest, ImplementsIsEmpty)
	TEST (IsEmptyTest, WorksWithString)
	TEST (IsEmptyTest, CanDescribeSelf)
	TEST (IsEmptyTest, ExplainsResult)
	TEST (SizeIsTest, ImplementsSizeIs)
	TEST (SizeIsTest, WorksWithMap)
	TEST (SizeIsTest, WorksWithReferences)
	TEST (SizeIsTest, CanDescribeSelf)
	TEST (SizeIsTest, ExplainsResult)
	TEST (ContainerEqExtraTest, MultipleValuesMissing)
	TEST (ContainerEqExtraTest, MultipleValuesAdded)
	TEST (ContainerEqExtraTest, MultipleValuesAddedAndRemoved)
	TEST (ContainerEqExtraTest, MultiSetOfIntDuplicateDifference)
	TEST (ContainerEqExtraTest, WorksForMaps)
	TEST (ContainerEqExtraTest, WorksForNativeArray)
	TEST (ContainerEqExtraTest, WorksForTwoDimensionalNativeArray)
	TEST (ContainerEqExtraTest, WorksForNativeArrayAsTuple)
	TEST (ContainerEqExtraTest, CopiesNativeArrayParameter)
	TEST (WhenSortedByTest, WorksForEmptyContainer)
	TEST (WhenSortedByTest, WorksForNonEmptyContainer)
	TEST (WhenSortedByTest, WorksForNonVectorContainer)
	TEST (WhenSortedByTest, WorksForNativeArray)
	TEST (WhenSortedByTest, CanDescribeSelf)
	TEST (WhenSortedByTest, ExplainsMatchResult)
	TEST (WhenSortedTest, WorksForEmptyContainer)
	TEST (WhenSortedTest, WorksForNonEmptyContainer)
	TEST (WhenSortedTest, WorksForMapTypes)
	TEST (WhenSortedTest, WorksForMultiMapTypes)
	TEST (WhenSortedTest, WorksForPolymorphicMatcher)
	TEST (WhenSortedTest, WorksForVectorConstRefMatcher)
	TEST (StreamlikeTest, Iteration)
	TEST (BeginEndDistanceIsTest, WorksWithNonStdList)
	TEST (BeginEndDistanceIsTest, CanDescribeSelf)
	TEST (BeginEndDistanceIsTest, ExplainsResult)
	TEST (WhenSortedTest, WorksForStreamlike)
	TEST (WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike)
	TEST (ElemensAreStreamTest, WorksForStreamlike)
	TEST (ElemensAreArrayStreamTest, WorksForStreamlike)
	TEST (ElementsAreTest, WorksWithUncopyable)
	TEST (ElementsAreTest, TakesStlContainer)
	TEST (UnorderedElementsAreArrayTest, SucceedsWhenExpected)
	TEST (UnorderedElementsAreArrayTest, VectorBool)
	TEST (UnorderedElementsAreArrayTest, WorksForStreamlike)
	TEST (UnorderedElementsAreArrayTest, TakesStlContainer)
	TEST_F (UnorderedElementsAreTest, WorksWithUncopyable)
	TEST_F (UnorderedElementsAreTest, SucceedsWhenExpected)
	TEST_F (UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher)
	TEST_F (UnorderedElementsAreTest, WorksForStreamlike)
	TEST_F (UnorderedElementsAreTest, Performance)
	TEST_F (UnorderedElementsAreTest, PerformanceHalfStrict)
	TEST_F (UnorderedElementsAreTest, FailMessageCountWrong)
	TEST_F (UnorderedElementsAreTest, FailMessageCountWrongZero)
	TEST_F (UnorderedElementsAreTest, FailMessageUnmatchedMatchers)
	TEST_F (UnorderedElementsAreTest, FailMessageUnmatchedElements)
	TEST_F (UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndElement)
static string	EMString (int element, int matcher)
	TEST_F (UnorderedElementsAreTest, FailMessageImperfectMatchOnly)
	TEST_F (UnorderedElementsAreTest, Describe)
	TEST_F (UnorderedElementsAreTest, DescribeNegation)
template<typename Graph>
ElementMatcherPairs	FindBacktrackingMaxBPM (const Graph &g)
	TEST_P (BipartiteTest, Exhaustive)
	INSTANTIATE_TEST_CASE_P (AllGraphs, BipartiteTest, ::testing::Range(0, 5))
	TEST_F (BipartiteNonSquareTest, SimpleBacktracking)
	TEST_P (BipartiteNonSquareTest, Exhaustive)
	INSTANTIATE_TEST_CASE_P (AllGraphs, BipartiteNonSquareTest, testing::Values(std::make_pair(1, 2), std::make_pair(2, 1), std::make_pair(3, 2), std::make_pair(2, 3), std::make_pair(4, 1), std::make_pair(1, 4), std::make_pair(4, 3), std::make_pair(3, 4)))
	TEST_P (BipartiteRandomTest, LargerNets)
	INSTANTIATE_TEST_CASE_P (Samples, BipartiteRandomTest, testing::Values(std::make_pair(5, 10000), std::make_pair(6, 5000), std::make_pair(7, 2000), std::make_pair(8, 500), std::make_pair(9, 100)))
	TEST (IsReadableTypeNameTest, ReturnsTrueForShortNames)
	TEST (IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctionNames)
	TEST (IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames)
	TEST (IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames)
	TEST (JoinAsTupleTest, JoinsEmptyTuple)
	TEST (JoinAsTupleTest, JoinsOneTuple)
	TEST (JoinAsTupleTest, JoinsTwoTuple)
	TEST (JoinAsTupleTest, JoinsTenTuple)
	TEST (FormatMatcherDescriptionTest, WorksForEmptyDescription)
	TEST (PolymorphicMatcherTest, CanAccessMutableImpl)
	TEST (PolymorphicMatcherTest, CanAccessImpl)
	TEST (MatcherTupleTest, ExplainsMatchFailure)
	TEST (EachTest, ExplainsMatchResultCorrectly)
	TEST (EachTest, DescribesItselfCorrectly)
	TEST (EachTest, MatchesVectorWhenAllElementsMatch)
	TEST (EachTest, MatchesMapWhenAllElementsMatch)
	TEST (EachTest, AcceptsMatcher)
	TEST (EachTest, WorksForNativeArrayAsTuple)
PolymorphicMatcher< IsHalfOfMatcher >	IsHalfOf ()
	TEST (PointwiseTest, DescribesSelf)
	TEST (PointwiseTest, MakesCopyOfRhs)
	TEST (PointwiseTest, WorksForLhsNativeArray)
	TEST (PointwiseTest, WorksForRhsNativeArray)
	TEST (PointwiseTest, RejectsWrongSize)
	TEST (PointwiseTest, RejectsWrongContent)
	TEST (PointwiseTest, AcceptsCorrectContent)
	TEST (PointwiseTest, AllowsMonomorphicInnerMatcher)
	TEST (UnorderedPointwiseTest, DescribesSelf)
	TEST (UnorderedPointwiseTest, MakesCopyOfRhs)
	TEST (UnorderedPointwiseTest, WorksForLhsNativeArray)
	TEST (UnorderedPointwiseTest, WorksForRhsNativeArray)
	TEST (UnorderedPointwiseTest, RejectsWrongSize)
	TEST (UnorderedPointwiseTest, RejectsWrongContent)
	TEST (UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder)
	TEST (UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder)
	TEST (UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher)
template<typename InnerMatcher>
InnerMatcher	AllArgs (const InnerMatcher &matcher)
template<typename M1, typename M2>
internal::AllOfResult2< M1, M2 >::type	AllOf (M1 m1, M2 m2)
template<typename T>
Matcher< T >	An ()
template<typename M1, typename M2>
internal::AnyOfResult2< M1, M2 >::type	AnyOf (M1 m1, M2 m2)
PolymorphicMatcher< internal::MatchesRegexMatcher >	ContainsRegex (const internal::RE *regex)
internal::FloatingEqMatcher< double >	DoubleEq (double rhs)
internal::FloatingEqMatcher< double >	DoubleNear (double rhs, double max_abs_error)
PolymorphicMatcher< internal::EndsWithMatcher< internal::string > >	EndsWith (const internal::string &suffix)
template<typename T>
internal::EqMatcher< T >	Eq (T x)
template<typename T, typename M>
bool	ExplainMatchResult (M matcher, const T &value, MatchResultListener *listener)
template<typename Class, typename FieldType, typename FieldMatcher>
PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > >	Field (FieldType Class::*field, const FieldMatcher &matcher)
internal::FloatingEqMatcher< float >	FloatEq (float rhs)
internal::FloatingEqMatcher< float >	FloatNear (float rhs, float max_abs_error)
template<typename Rhs>
internal::GeMatcher< Rhs >	Ge (Rhs x)
template<typename Rhs>
internal::GtMatcher< Rhs >	Gt (Rhs x)
PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > >	HasSubstr (const internal::string &substring)
PolymorphicMatcher< internal::IsNullMatcher >	IsNull ()
template<typename M>
internal::KeyMatcher< M >	Key (M inner_matcher)
template<typename Rhs>
internal::LeMatcher< Rhs >	Le (Rhs x)
template<typename Rhs>
internal::LtMatcher< Rhs >	Lt (Rhs x)
template<typename T>
Matcher< T >	MakeMatcher (const MatcherInterface< T > *impl)
template<class Impl>
PolymorphicMatcher< Impl >	MakePolymorphicMatcher (const Impl &impl)
template<typename T, typename M>
Matcher< T >	MatcherCast (const M &matcher)
template<typename M>
internal::MatcherAsPredicate< M >	Matches (M matcher)
PolymorphicMatcher< internal::MatchesRegexMatcher >	MatchesRegex (const internal::RE *regex)
internal::FloatingEqMatcher< double >	NanSensitiveDoubleEq (double rhs)
internal::FloatingEqMatcher< double >	NanSensitiveDoubleNear (double rhs, double max_abs_error)
internal::FloatingEqMatcher< float >	NanSensitiveFloatEq (float rhs)
internal::FloatingEqMatcher< float >	NanSensitiveFloatNear (float rhs, float max_abs_error)
template<typename Rhs>
internal::NeMatcher< Rhs >	Ne (Rhs x)
template<typename InnerMatcher>
internal::NotMatcher< InnerMatcher >	Not (InnerMatcher m)
PolymorphicMatcher< internal::NotNullMatcher >	NotNull ()
template<typename FirstMatcher, typename SecondMatcher>
internal::PairMatcher< FirstMatcher, SecondMatcher >	Pair (FirstMatcher first_matcher, SecondMatcher second_matcher)
template<typename TupleMatcher, typename Container>
internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)>	Pointwise (const TupleMatcher &tuple_matcher, const Container &rhs)
template<typename T>
internal::RefMatcher< T & >	Ref (T &x)
template<typename Callable, typename ResultOfMatcher>
internal::ResultOfMatcher< Callable >	ResultOf (Callable callable, const ResultOfMatcher &matcher)
template<typename SizeMatcher>
internal::SizeIsMatcher< SizeMatcher >	SizeIs (const SizeMatcher &size_matcher)
PolymorphicMatcher< internal::StartsWithMatcher< internal::string > >	StartsWith (const internal::string &prefix)
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrCaseEq (const internal::string &str)
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrCaseNe (const internal::string &str)
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrEq (const internal::string &str)
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > >	StrNe (const internal::string &str)
template<typename Predicate>
PolymorphicMatcher< internal::TrulyMatcher< Predicate > >	Truly (Predicate pred)
template<typename Lhs, typename Rhs>
Matcher< Lhs >	TypedEq (const Rhs &rhs)
template<typename Tuple2Matcher, typename RhsContainer>
internal::UnorderedElementsAreArrayMatcher< typename internal::BoundSecondMatcher< Tuple2Matcher, typename internal::StlContainerView< GTEST_REMOVE_CONST_(RhsContainer)>::type::value_type > >	UnorderedPointwise (const Tuple2Matcher &tuple2_matcher, const RhsContainer &rhs_container)
template<typename ContainerMatcher>
internal::WhenSortedByMatcher< internal::LessComparator, ContainerMatcher >	WhenSorted (const ContainerMatcher &container_matcher)
template<typename Comparator, typename ContainerMatcher>
internal::WhenSortedByMatcher< Comparator, ContainerMatcher >	WhenSortedBy (const Comparator &comparator, const ContainerMatcher &container_matcher)
template<typename MatcherTuple, typename ValueTuple>
void	ExplainMatchFailureTupleTo (const MatcherTuple &matchers, const ValueTuple &values, ::std::ostream *os)
GTEST_API_ string	FormatMatcherDescription (bool negation, const char *matcher_name, const Strings &param_values)
bool	IsReadableTypeName (const string &type_name)
GTEST_API_ string	JoinAsTuple (const Strings &fields)

Variables
const int	g_bar = 1
const int	foo = 0
const internal::AnythingMatcher	_

Typedef Documentation

◆ DoubleNearTest

typedef FloatingPointNearTest<double> testing::gmock_matchers_test::DoubleNearTest

◆ DoubleTest

typedef FloatingPointTest<double> testing::gmock_matchers_test::DoubleTest

◆ ElementMatcherPair

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

◆ ElementMatcherPairs

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

◆ FloatNearTest

typedef FloatingPointNearTest<float> testing::gmock_matchers_test::FloatNearTest

◆ FloatTest

typedef FloatingPointTest<float> testing::gmock_matchers_test::FloatTest

◆ string

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

◆ Strings

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

◆ Tuple2

typedef ::testing::tuple<long, int> testing::gmock_matchers_test::Tuple2

Function Documentation

◆ AllArgs()

template<typename InnerMatcher>

InnerMatcher testing::AllArgs ( const InnerMatcher & matcher )

inline

◆ AllOf()

template<typename M1, typename M2>

internal::AllOfResult2< M1, M2 >::type testing::AllOf	(	M1	m1,
		M2	m2 )

inline

◆ AllOfMatches()

void testing::gmock_matchers_test::AllOfMatches	(	int	num,
		const Matcher< int > &	m )

◆ An()

template<typename T>

Matcher< T > testing::An ( )

inline

◆ AnyOf()

template<typename M1, typename M2>

internal::AnyOfResult2< M1, M2 >::type testing::AnyOf	(	M1	m1,
		M2	m2 )

inline

◆ AnyOfMatches()

void testing::gmock_matchers_test::AnyOfMatches	(	int	num,
		const Matcher< int > &	m )

◆ ContainsRegex()

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::ContainsRegex ( const internal::RE * regex )

inline

◆ Describe()

template<typename T>

string testing::gmock_matchers_test::Describe ( const Matcher< T > & m )

◆ DescribeNegation()

template<typename T>

string testing::gmock_matchers_test::DescribeNegation ( const Matcher< T > & m )

◆ DivisibleBy()

PolymorphicMatcher< DivisibleByImpl > testing::gmock_matchers_test::DivisibleBy ( int n )

◆ DoubleEq()

internal::FloatingEqMatcher< double > testing::DoubleEq ( double rhs )

inline

◆ DoubleFunction()

double & testing::gmock_matchers_test::DoubleFunction ( double & input )

◆ DoubleNear()

internal::FloatingEqMatcher< double > testing::DoubleNear	(	double	rhs,
		double	max_abs_error )

inline

◆ EMString()

string testing::gmock_matchers_test::EMString	(	int	element,
		int	matcher )

static

◆ EndsWith()

PolymorphicMatcher< internal::EndsWithMatcher< internal::string > > testing::EndsWith ( const internal::string & suffix )

inline

◆ Eq()

template<typename T>

internal::EqMatcher< T > testing::Eq ( T x )

inline

◆ Explain()

template<typename MatcherType, typename Value>

string testing::gmock_matchers_test::Explain	(	const MatcherType &	m,
		const Value &	x )

◆ ExplainMatchFailureTupleTo()

template<typename MatcherTuple, typename ValueTuple>

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

◆ ExplainMatchResult()

template<typename T, typename M>

bool testing::ExplainMatchResult	(	M	matcher,
		const T &	value,
		MatchResultListener *	listener )

inline

◆ Field()

template<typename Class, typename FieldType, typename FieldMatcher>

PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > > testing::Field	(	FieldType Class::*	field,
		const FieldMatcher &	matcher )

inline

◆ FindBacktrackingMaxBPM()

template<typename Graph>

ElementMatcherPairs testing::gmock_matchers_test::FindBacktrackingMaxBPM ( const Graph & g )

◆ FloatEq()

internal::FloatingEqMatcher< float > testing::FloatEq ( float rhs )

inline

◆ FloatNear()

internal::FloatingEqMatcher< float > testing::FloatNear	(	float	rhs,
		float	max_abs_error )

inline

◆ FormatMatcherDescription()

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

◆ Ge()

template<typename Rhs>

internal::GeMatcher< Rhs > testing::Ge ( Rhs x )

inline

◆ GreaterThan()

Matcher< int > testing::gmock_matchers_test::GreaterThan ( int n )

◆ Gt()

template<typename Rhs>

internal::GtMatcher< Rhs > testing::Gt ( Rhs x )

inline

◆ HasSubstr()

PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > > testing::HasSubstr ( const internal::string & substring )

inline

◆ INSTANTIATE_TEST_CASE_P() [1/3]

testing::gmock_matchers_test::INSTANTIATE_TEST_CASE_P	(	AllGraphs	,
		BipartiteNonSquareTest	,
		testing::Values(std::make_pair(1, 2), std::make_pair(2, 1), std::make_pair(3, 2), std::make_pair(2, 3), std::make_pair(4, 1), std::make_pair(1, 4), std::make_pair(4, 3), std::make_pair(3, 4))	)

◆ INSTANTIATE_TEST_CASE_P() [2/3]

testing::gmock_matchers_test::INSTANTIATE_TEST_CASE_P	(	AllGraphs	,
		BipartiteTest	,
		::testing::Range(0, 5)	)

◆ INSTANTIATE_TEST_CASE_P() [3/3]

testing::gmock_matchers_test::INSTANTIATE_TEST_CASE_P	(	Samples	,
		BipartiteRandomTest	,
		testing::Values(std::make_pair(5, 10000), std::make_pair(6, 5000), std::make_pair(7, 2000), std::make_pair(8, 500), std::make_pair(9, 100))	)

◆ IntFunction()

int testing::gmock_matchers_test::IntFunction ( int input )

◆ IntToStringFunction()

string testing::gmock_matchers_test::IntToStringFunction ( int input )

◆ IsHalfOf()

PolymorphicMatcher< IsHalfOfMatcher > testing::gmock_matchers_test::IsHalfOf ( )

◆ IsNotZero()

ConvertibleToBool testing::gmock_matchers_test::IsNotZero ( int number )

◆ IsNull()

PolymorphicMatcher< internal::IsNullMatcher > testing::IsNull ( )

inline

◆ IsPositive()

int testing::gmock_matchers_test::IsPositive ( double x )

◆ IsPositiveIntValue()

bool testing::gmock_matchers_test::IsPositiveIntValue ( const IntValue & foo )

◆ IsReadableTypeName()

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

inline

◆ JoinAsTuple()

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

◆ Key()

template<typename M>

internal::KeyMatcher< M > testing::Key ( M inner_matcher )

inline

◆ Le()

template<typename Rhs>

internal::LeMatcher< Rhs > testing::Le ( Rhs x )

inline

◆ Lt()

template<typename Rhs>

internal::LtMatcher< Rhs > testing::Lt ( Rhs x )

inline

◆ MakeMatcher()

template<typename T>

Matcher< T > testing::MakeMatcher ( const MatcherInterface< T > * impl )

inline

◆ MakePolymorphicMatcher()

template<class Impl>

PolymorphicMatcher< Impl > testing::MakePolymorphicMatcher ( const Impl & impl )

inline

◆ MATCHER_P() [1/3]

testing::gmock_matchers_test::MATCHER_P	(	FieldIIs	,
		inner_matcher	,
		""	)

◆ MATCHER_P() [2/3]

testing::gmock_matchers_test::MATCHER_P	(	Really	,
		inner_matcher	,
		""	)

◆ MATCHER_P() [3/3]

testing::gmock_matchers_test::MATCHER_P	(	UncopyableIs	,
		inner_matcher	,
		""	)

◆ MatcherCast()

template<typename T, typename M>

Matcher< T > testing::MatcherCast ( const M & matcher )

inline

◆ Matches()

template<typename M>

internal::MatcherAsPredicate< M > testing::Matches ( M matcher )

inline

◆ MatchesRegex()

PolymorphicMatcher< internal::MatchesRegexMatcher > testing::MatchesRegex ( const internal::RE * regex )

inline

◆ NanSensitiveDoubleEq()

internal::FloatingEqMatcher< double > testing::NanSensitiveDoubleEq ( double rhs )

inline

◆ NanSensitiveDoubleNear()

internal::FloatingEqMatcher< double > testing::NanSensitiveDoubleNear	(	double	rhs,
		double	max_abs_error )

inline

◆ NanSensitiveFloatEq()

internal::FloatingEqMatcher< float > testing::NanSensitiveFloatEq ( float rhs )

inline

◆ NanSensitiveFloatNear()

internal::FloatingEqMatcher< float > testing::NanSensitiveFloatNear	(	float	rhs,
		float	max_abs_error )

inline

◆ Ne()

template<typename Rhs>

internal::NeMatcher< Rhs > testing::Ne ( Rhs x )

inline

◆ Not()

template<typename InnerMatcher>

internal::NotMatcher< InnerMatcher > testing::Not ( InnerMatcher m )

inline

◆ NotNull()

PolymorphicMatcher< internal::NotNullMatcher > testing::NotNull ( )

inline

◆ OfType()

string testing::gmock_matchers_test::OfType ( const string & type_name )

◆ operator<<()

ostream & testing::gmock_matchers_test::operator<<	(	ostream &	os,
		const ConvertibleFromAny &	a )

◆ operator==() [1/2]

bool testing::gmock_matchers_test::operator==	(	const ConvertibleFromAny &	a,
		const ConvertibleFromAny &	b )

◆ operator==() [2/2]

bool testing::gmock_matchers_test::operator==	(	const IntReferenceWrapper &	a,
		const IntReferenceWrapper &	b )

◆ Pair()

template<typename FirstMatcher, typename SecondMatcher>

internal::PairMatcher< FirstMatcher, SecondMatcher > testing::Pair	(	FirstMatcher	first_matcher,
		SecondMatcher	second_matcher )

inline

◆ Pointwise()

template<typename TupleMatcher, typename Container>

internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)> testing::Pointwise	(	const TupleMatcher &	tuple_matcher,
		const Container &	rhs )

inline

◆ PolymorphicIsEven()

PolymorphicMatcher< PolymorphicIsEvenImpl > testing::gmock_matchers_test::PolymorphicIsEven ( )

◆ Ref()

template<typename T>

internal::RefMatcher< T & > testing::Ref ( T & x )

inline

◆ ReferencesBarOrIsZero()

PolymorphicMatcher< ReferencesBarOrIsZeroImpl > testing::gmock_matchers_test::ReferencesBarOrIsZero ( )

◆ ReferencesFooAndIsZero()

bool testing::gmock_matchers_test::ReferencesFooAndIsZero ( const int & n )

◆ ReferencingFunction()

const int * testing::gmock_matchers_test::ReferencingFunction ( const int & n )

◆ RefUncopyableFunction()

Uncopyable & testing::gmock_matchers_test::RefUncopyableFunction ( Uncopyable & obj )

◆ ResultOf()

template<typename Callable, typename ResultOfMatcher>

internal::ResultOfMatcher< Callable > testing::ResultOf	(	Callable	callable,
		const ResultOfMatcher &	matcher )

◆ SizeIs()

template<typename SizeMatcher>

internal::SizeIsMatcher< SizeMatcher > testing::SizeIs ( const SizeMatcher & size_matcher )

inline

◆ StartsWith()

PolymorphicMatcher< internal::StartsWithMatcher< internal::string > > testing::StartsWith ( const internal::string & prefix )

inline

◆ StrCaseEq()

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrCaseEq ( const internal::string & str )

inline

◆ StrCaseNe()

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrCaseNe ( const internal::string & str )

inline

◆ StrEq()

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrEq ( const internal::string & str )

inline

◆ StringFunction()

const string & testing::gmock_matchers_test::StringFunction ( const string & input )

◆ StrNe()

PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > testing::StrNe ( const internal::string & str )

inline

◆ TEST() [1/292]

testing::gmock_matchers_test::TEST	(	AllArgsTest	,
		WorksForNonTuple	)

◆ TEST() [2/292]

testing::gmock_matchers_test::TEST	(	AllArgsTest	,
		WorksForTuple	)

◆ TEST() [3/292]

testing::gmock_matchers_test::TEST	(	AllArgsTest	,
		WorksInWithClause	)

◆ TEST() [4/292]

testing::gmock_matchers_test::TEST	(	AllOfTest	,
		AllOfMatcherSafelyCastsMonomorphicMatchers	)

◆ TEST() [5/292]

testing::gmock_matchers_test::TEST	(	AllOfTest	,
		CanDescribeNegation	)

◆ TEST() [6/292]

testing::gmock_matchers_test::TEST	(	AllOfTest	,
		CanDescribeSelf	)

◆ TEST() [7/292]

testing::gmock_matchers_test::TEST	(	AllOfTest	,
		ExplainsResult	)

◆ TEST() [8/292]

testing::gmock_matchers_test::TEST	(	AllOfTest	,
		MatchesWhenAllMatch	)

◆ TEST() [9/292]

testing::gmock_matchers_test::TEST	(	AnTest	,
		CanDescribeSelf	)

◆ TEST() [10/292]

testing::gmock_matchers_test::TEST	(	AnTest	,
		MatchesAnyValue	)

◆ TEST() [11/292]

testing::gmock_matchers_test::TEST	(	AnyOfTest	,
		AnyOfMatcherSafelyCastsMonomorphicMatchers	)

◆ TEST() [12/292]

testing::gmock_matchers_test::TEST	(	AnyOfTest	,
		CanDescribeNegation	)

◆ TEST() [13/292]

testing::gmock_matchers_test::TEST	(	AnyOfTest	,
		CanDescribeSelf	)

◆ TEST() [14/292]

testing::gmock_matchers_test::TEST	(	AnyOfTest	,
		ExplainsResult	)

◆ TEST() [15/292]

testing::gmock_matchers_test::TEST	(	AnyOfTest	,
		MatchesWhenAnyMatches	)

◆ TEST() [16/292]

testing::gmock_matchers_test::TEST	(	ATest	,
		CanDescribeSelf	)

◆ TEST() [17/292]

testing::gmock_matchers_test::TEST	(	ATest	,
		MatchesAnyValue	)

◆ TEST() [18/292]

testing::gmock_matchers_test::TEST	(	ATest	,
		WorksForDerivedClass	)

◆ TEST() [19/292]

testing::gmock_matchers_test::TEST	(	BeginEndDistanceIsTest	,
		CanDescribeSelf	)

◆ TEST() [20/292]

testing::gmock_matchers_test::TEST	(	BeginEndDistanceIsTest	,
		ExplainsResult	)

◆ TEST() [21/292]

testing::gmock_matchers_test::TEST	(	BeginEndDistanceIsTest	,
		WorksWithNonStdList	)

◆ TEST() [22/292]

testing::gmock_matchers_test::TEST	(	ByRefTest	,
		AllowsNotCopyableConstValueInMatchers	)

◆ TEST() [23/292]

testing::gmock_matchers_test::TEST	(	ByRefTest	,
		AllowsNotCopyableValueInMatchers	)

◆ TEST() [24/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		CopiesNativeArrayParameter	)

◆ TEST() [25/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		MultipleValuesAdded	)

◆ TEST() [26/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		MultipleValuesAddedAndRemoved	)

◆ TEST() [27/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		MultipleValuesMissing	)

◆ TEST() [28/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		MultiSetOfIntDuplicateDifference	)

◆ TEST() [29/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		WorksForMaps	)

◆ TEST() [30/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		WorksForNativeArray	)

◆ TEST() [31/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		WorksForNativeArrayAsTuple	)

◆ TEST() [32/292]

testing::gmock_matchers_test::TEST	(	ContainerEqExtraTest	,
		WorksForTwoDimensionalNativeArray	)

◆ TEST() [33/292]

testing::gmock_matchers_test::TEST	(	ContainsRegexTest	,
		CanDescribeSelf	)

◆ TEST() [34/292]

testing::gmock_matchers_test::TEST	(	ContainsRegexTest	,
		MatchesStringContainingGivenRegex	)

◆ TEST() [35/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		AcceptsMatcher	)

◆ TEST() [36/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		DescribesItselfCorrectly	)

◆ TEST() [37/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		ExplainsMatchResultCorrectly	)

◆ TEST() [38/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		MatchesMapWhenAllElementsMatch	)

◆ TEST() [39/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		MatchesVectorWhenAllElementsMatch	)

◆ TEST() [40/292]

testing::gmock_matchers_test::TEST	(	EachTest	,
		WorksForNativeArrayAsTuple	)

◆ TEST() [41/292]

testing::gmock_matchers_test::TEST	(	ElemensAreArrayStreamTest	,
		WorksForStreamlike	)

◆ TEST() [42/292]

testing::gmock_matchers_test::TEST	(	ElemensAreStreamTest	,
		WorksForStreamlike	)

◆ TEST() [43/292]

testing::gmock_matchers_test::TEST	(	ElementsAreTest	,
		TakesStlContainer	)

◆ TEST() [44/292]

testing::gmock_matchers_test::TEST	(	ElementsAreTest	,
		WorksWithUncopyable	)

◆ TEST() [45/292]

testing::gmock_matchers_test::TEST	(	EndsWithTest	,
		CanDescribeSelf	)

◆ TEST() [46/292]

testing::gmock_matchers_test::TEST	(	EndsWithTest	,
		MatchesStringWithGivenSuffix	)

◆ TEST() [47/292]

testing::gmock_matchers_test::TEST	(	Eq2Test	,
		CanDescribeSelf	)

◆ TEST() [48/292]

testing::gmock_matchers_test::TEST	(	Eq2Test	,
		MatchesEqualArguments	)

◆ TEST() [49/292]

testing::gmock_matchers_test::TEST	(	EqTest	,
		CanDescribeSelf	)

◆ TEST() [50/292]

testing::gmock_matchers_test::TEST	(	EqTest	,
		IsPolymorphic	)

◆ TEST() [51/292]

testing::gmock_matchers_test::TEST	(	EqTest	,
		MatchesEqualValue	)

◆ TEST() [52/292]

testing::gmock_matchers_test::TEST	(	ExpectThat	,
		TakesFunctions	)

◆ TEST() [53/292]

testing::gmock_matchers_test::TEST	(	ExpectThat	,
		TakesLiterals	)

◆ TEST() [54/292]

testing::gmock_matchers_test::TEST	(	ExplainmatcherResultTest	,
		MonomorphicMatcher	)

◆ TEST() [55/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		AllOf_False_False	)

◆ TEST() [56/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		AllOf_False_True	)

◆ TEST() [57/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		AllOf_True_False	)

◆ TEST() [58/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		AllOf_True_True	)

◆ TEST() [59/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		AllOf_True_True_2	)

◆ TEST() [60/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		WorksInsideMATCHER	)

◆ TEST() [61/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		WorksWithMonomorphicMatcher	)

◆ TEST() [62/292]

testing::gmock_matchers_test::TEST	(	ExplainMatchResultTest	,
		WorksWithPolymorphicMatcher	)

◆ TEST() [63/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		CanDescribeSelf	)

◆ TEST() [64/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		CanExplainMatchResult	)

◆ TEST() [65/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		DoesNotMatchNull	)

◆ TEST() [66/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		WorksForArgumentOfSubType	)

◆ TEST() [67/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		WorksForPointerToConst	)

◆ TEST() [68/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		WorksForPointerToNonConst	)

◆ TEST() [69/292]

testing::gmock_matchers_test::TEST	(	FieldForPointerTest	,
		WorksForReferenceToConstPointer	)

◆ TEST() [70/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		CanDescribeSelf	)

◆ TEST() [71/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		CanExplainMatchResult	)

◆ TEST() [72/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForArgumentOfSubType	)

◆ TEST() [73/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForByRefArgument	)

◆ TEST() [74/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForCompatibleMatcherType	)

◆ TEST() [75/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForConstField	)

◆ TEST() [76/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForNonConstField	)

◆ TEST() [77/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForPointerField	)

◆ TEST() [78/292]

testing::gmock_matchers_test::TEST	(	FieldTest	,
		WorksForUncopyableField	)

◆ TEST() [79/292]

testing::gmock_matchers_test::TEST	(	FormatMatcherDescriptionTest	,
		WorksForEmptyDescription	)

◆ TEST() [80/292]

testing::gmock_matchers_test::TEST	(	Ge2Test	,
		CanDescribeSelf	)

◆ TEST() [81/292]

testing::gmock_matchers_test::TEST	(	Ge2Test	,
		MatchesGreaterThanOrEqualArguments	)

◆ TEST() [82/292]

testing::gmock_matchers_test::TEST	(	GeTest	,
		CanDescribeSelf	)

◆ TEST() [83/292]

testing::gmock_matchers_test::TEST	(	GeTest	,
		ImplementsGreaterThanOrEqual	)

◆ TEST() [84/292]

testing::gmock_matchers_test::TEST	(	Gt2Test	,
		CanDescribeSelf	)

◆ TEST() [85/292]

testing::gmock_matchers_test::TEST	(	Gt2Test	,
		MatchesGreaterThanArguments	)

◆ TEST() [86/292]

testing::gmock_matchers_test::TEST	(	GtTest	,
		CanDescribeSelf	)

◆ TEST() [87/292]

testing::gmock_matchers_test::TEST	(	GtTest	,
		ImplementsGreaterThan	)

◆ TEST() [88/292]

testing::gmock_matchers_test::TEST	(	HasSubstrTest	,
		CanDescribeSelf	)

◆ TEST() [89/292]

testing::gmock_matchers_test::TEST	(	HasSubstrTest	,
		WorksForCStrings	)

◆ TEST() [90/292]

testing::gmock_matchers_test::TEST	(	HasSubstrTest	,
		WorksForStringClasses	)

◆ TEST() [91/292]

testing::gmock_matchers_test::TEST	(	IsEmptyTest	,
		CanDescribeSelf	)

◆ TEST() [92/292]

testing::gmock_matchers_test::TEST	(	IsEmptyTest	,
		ExplainsResult	)

◆ TEST() [93/292]

testing::gmock_matchers_test::TEST	(	IsEmptyTest	,
		ImplementsIsEmpty	)

◆ TEST() [94/292]

testing::gmock_matchers_test::TEST	(	IsEmptyTest	,
		WorksWithString	)

◆ TEST() [95/292]

testing::gmock_matchers_test::TEST	(	IsNullTest	,
		CanDescribeSelf	)

◆ TEST() [96/292]

testing::gmock_matchers_test::TEST	(	IsNullTest	,
		LinkedPtr	)

◆ TEST() [97/292]

testing::gmock_matchers_test::TEST	(	IsNullTest	,
		MatchesNullPointer	)

◆ TEST() [98/292]

testing::gmock_matchers_test::TEST	(	IsNullTest	,
		ReferenceToConstLinkedPtr	)

◆ TEST() [99/292]

testing::gmock_matchers_test::TEST	(	IsReadableTypeNameTest	,
		ReturnsFalseForLongFunctionTypeNames	)

◆ TEST() [100/292]

testing::gmock_matchers_test::TEST	(	IsReadableTypeNameTest	,
		ReturnsFalseForLongTemplateNames	)

◆ TEST() [101/292]

testing::gmock_matchers_test::TEST	(	IsReadableTypeNameTest	,
		ReturnsTrueForLongNonTemplateNonFunctionNames	)

◆ TEST() [102/292]

testing::gmock_matchers_test::TEST	(	IsReadableTypeNameTest	,
		ReturnsTrueForShortNames	)

◆ TEST() [103/292]

testing::gmock_matchers_test::TEST	(	JoinAsTupleTest	,
		JoinsEmptyTuple	)

◆ TEST() [104/292]

testing::gmock_matchers_test::TEST	(	JoinAsTupleTest	,
		JoinsOneTuple	)

◆ TEST() [105/292]

testing::gmock_matchers_test::TEST	(	JoinAsTupleTest	,
		JoinsTenTuple	)

◆ TEST() [106/292]

testing::gmock_matchers_test::TEST	(	JoinAsTupleTest	,
		JoinsTwoTuple	)

◆ TEST() [107/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		CanDescribeSelf	)

◆ TEST() [108/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		ExplainsResult	)

◆ TEST() [109/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		InsideContainsUsingMap	)

◆ TEST() [110/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		InsideContainsUsingMultimap	)

◆ TEST() [111/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		MatchesCorrectly	)

◆ TEST() [112/292]

testing::gmock_matchers_test::TEST	(	KeyTest	,
		SafelyCastsInnerMatcher	)

◆ TEST() [113/292]

testing::gmock_matchers_test::TEST	(	Le2Test	,
		CanDescribeSelf	)

◆ TEST() [114/292]

testing::gmock_matchers_test::TEST	(	Le2Test	,
		MatchesLessThanOrEqualArguments	)

◆ TEST() [115/292]

testing::gmock_matchers_test::TEST	(	LeTest	,
		CanDescribeSelf	)

◆ TEST() [116/292]

testing::gmock_matchers_test::TEST	(	LeTest	,
		ImplementsLessThanOrEqual	)

◆ TEST() [117/292]

testing::gmock_matchers_test::TEST	(	Lt2Test	,
		CanDescribeSelf	)

◆ TEST() [118/292]

testing::gmock_matchers_test::TEST	(	Lt2Test	,
		MatchesLessThanArguments	)

◆ TEST() [119/292]

testing::gmock_matchers_test::TEST	(	LtTest	,
		CanDescribeSelf	)

◆ TEST() [120/292]

testing::gmock_matchers_test::TEST	(	LtTest	,
		ImplementsLessThan	)

◆ TEST() [121/292]

testing::gmock_matchers_test::TEST	(	MakeMatcherTest	,
		ConstructsMatcherFromMatcherInterface	)

◆ TEST() [122/292]

testing::gmock_matchers_test::TEST	(	MakePolymorphicMatcherTest	,
		ConstructsMatcherUsingNewAPI	)

◆ TEST() [123/292]

testing::gmock_matchers_test::TEST	(	MakePolymorphicMatcherTest	,
		ConstructsMatcherUsingOldAPI	)

◆ TEST() [124/292]

testing::gmock_matchers_test::TEST	(	MatcherAssertionTest	,
		WorksForByRefArguments	)

◆ TEST() [125/292]

testing::gmock_matchers_test::TEST	(	MatcherAssertionTest	,
		WorksForMonomorphicMatcher	)

◆ TEST() [126/292]

testing::gmock_matchers_test::TEST	(	MatcherAssertionTest	,
		WorksWhenMatcherIsNotSatisfied	)

◆ TEST() [127/292]

testing::gmock_matchers_test::TEST	(	MatcherAssertionTest	,
		WorksWhenMatcherIsSatisfied	)

◆ TEST() [128/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		ConversionConstructorIsUsed	)

◆ TEST() [129/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromCompatibleType	)

◆ TEST() [130/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromConstReferenceToNonReference	)

◆ TEST() [131/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromConvertibleFromAny	)

◆ TEST() [132/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromNonReferenceToConstReference	)

◆ TEST() [133/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromNonReferenceToReference	)

◆ TEST() [134/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromPolymorphicMatcher	)

◆ TEST() [135/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromReferenceToNonReference	)

◆ TEST() [136/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		FromSameType	)

◆ TEST() [137/292]

testing::gmock_matchers_test::TEST	(	MatcherCastTest	,
		ValueIsNotCopied	)

◆ TEST() [138/292]

testing::gmock_matchers_test::TEST	(	MatcherInterfaceTest	,
		CanBeImplementedUsingNewAPI	)

◆ TEST() [139/292]

testing::gmock_matchers_test::TEST	(	MatcherInterfaceTest	,
		CanBeImplementedUsingPublishedAPI	)

◆ TEST() [140/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		CanBeConstructedFromMatcherInterface	)

◆ TEST() [141/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		CanBeDefaultConstructed	)

◆ TEST() [142/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		CanBeImplicitlyConstructedFromNULL	)

◆ TEST() [143/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		CanBeImplicitlyConstructedFromValue	)

◆ TEST() [144/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		CanDescribeItself	)

◆ TEST() [145/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		IsCopyable	)

◆ TEST() [146/292]

testing::gmock_matchers_test::TEST	(	MatcherTest	,
		MatchAndExplain	)

◆ TEST() [147/292]

testing::gmock_matchers_test::TEST	(	MatcherTupleTest	,
		ExplainsMatchFailure	)

◆ TEST() [148/292]

testing::gmock_matchers_test::TEST	(	MatchesRegexTest	,
		CanDescribeSelf	)

◆ TEST() [149/292]

testing::gmock_matchers_test::TEST	(	MatchesRegexTest	,
		MatchesStringMatchingGivenRegex	)

◆ TEST() [150/292]

testing::gmock_matchers_test::TEST	(	MatchesTest	,
		IsSatisfiedByWhatMatchesTheMatcher	)

◆ TEST() [151/292]

testing::gmock_matchers_test::TEST	(	MatchesTest	,
		WorksOnByRefArguments	)

◆ TEST() [152/292]

testing::gmock_matchers_test::TEST	(	MatchesTest	,
		WorksWithMatcherOnNonRefType	)

◆ TEST() [153/292]

testing::gmock_matchers_test::TEST	(	MatchResultListenerTest	,
		CanAccessUnderlyingStream	)

◆ TEST() [154/292]

testing::gmock_matchers_test::TEST	(	MatchResultListenerTest	,
		IsInterestedWorks	)

◆ TEST() [155/292]

testing::gmock_matchers_test::TEST	(	MatchResultListenerTest	,
		StreamingWorks	)

◆ TEST() [156/292]

testing::gmock_matchers_test::TEST	(	Ne2Test	,
		CanDescribeSelf	)

◆ TEST() [157/292]

testing::gmock_matchers_test::TEST	(	Ne2Test	,
		MatchesUnequalArguments	)

◆ TEST() [158/292]

testing::gmock_matchers_test::TEST	(	NeTest	,
		CanDescribeSelf	)

◆ TEST() [159/292]

testing::gmock_matchers_test::TEST	(	NeTest	,
		ImplementsNotEqual	)

◆ TEST() [160/292]

testing::gmock_matchers_test::TEST	(	NotNullTest	,
		CanDescribeSelf	)

◆ TEST() [161/292]

testing::gmock_matchers_test::TEST	(	NotNullTest	,
		LinkedPtr	)

◆ TEST() [162/292]

testing::gmock_matchers_test::TEST	(	NotNullTest	,
		MatchesNonNullPointer	)

◆ TEST() [163/292]

testing::gmock_matchers_test::TEST	(	NotNullTest	,
		ReferenceToConstLinkedPtr	)

◆ TEST() [164/292]

testing::gmock_matchers_test::TEST	(	NotTest	,
		CanDescribeSelf	)

◆ TEST() [165/292]

testing::gmock_matchers_test::TEST	(	NotTest	,
		NegatesMatcher	)

◆ TEST() [166/292]

testing::gmock_matchers_test::TEST	(	NotTest	,
		NotMatcherSafelyCastsMonomorphicMatchers	)

◆ TEST() [167/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		CanDescribeSelf	)

◆ TEST() [168/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		CanExplainMatchResultTo	)

◆ TEST() [169/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		InsideContainsUsingMap	)

◆ TEST() [170/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		MatchesCorrectly	)

◆ TEST() [171/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		SafelyCastsInnerMatchers	)

◆ TEST() [172/292]

testing::gmock_matchers_test::TEST	(	PairTest	,
		Typing	)

◆ TEST() [173/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		AlwaysExplainsPointee	)

◆ TEST() [174/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		CanDescribeSelf	)

◆ TEST() [175/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		CanExplainMatchResult	)

◆ TEST() [176/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		MatchesAgainstAValue	)

◆ TEST() [177/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		NeverMatchesNull	)

◆ TEST() [178/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		RawPointer	)

◆ TEST() [179/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		RawPointerToConst	)

◆ TEST() [180/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		ReferenceToConstRawPointer	)

◆ TEST() [181/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		ReferenceToNonConstRawPointer	)

◆ TEST() [182/292]

testing::gmock_matchers_test::TEST	(	PointeeTest	,
		WorksWithConstPropagatingPointers	)

◆ TEST() [183/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		AcceptsCorrectContent	)

◆ TEST() [184/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		AllowsMonomorphicInnerMatcher	)

◆ TEST() [185/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		DescribesSelf	)

◆ TEST() [186/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		MakesCopyOfRhs	)

◆ TEST() [187/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		RejectsWrongContent	)

◆ TEST() [188/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		RejectsWrongSize	)

◆ TEST() [189/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		WorksForLhsNativeArray	)

◆ TEST() [190/292]

testing::gmock_matchers_test::TEST	(	PointwiseTest	,
		WorksForRhsNativeArray	)

◆ TEST() [191/292]

testing::gmock_matchers_test::TEST	(	PolymorphicMatcherTest	,
		CanAccessImpl	)

◆ TEST() [192/292]

testing::gmock_matchers_test::TEST	(	PolymorphicMatcherTest	,
		CanAccessMutableImpl	)

◆ TEST() [193/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		CanDescribeSelf	)

◆ TEST() [194/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		CanExplainMatchResult	)

◆ TEST() [195/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		WorksForArgumentOfSubType	)

◆ TEST() [196/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		WorksForPointerToConst	)

◆ TEST() [197/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		WorksForPointerToNonConst	)

◆ TEST() [198/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		WorksForReferenceToConstPointer	)

◆ TEST() [199/292]

testing::gmock_matchers_test::TEST	(	PropertyForPointerTest	,
		WorksForReferenceToNonConstProperty	)

◆ TEST() [200/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		CanDescribeSelf	)

◆ TEST() [201/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		CanExplainMatchResult	)

◆ TEST() [202/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForArgumentOfSubType	)

◆ TEST() [203/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForByValueArgument	)

◆ TEST() [204/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForCompatibleMatcherType	)

◆ TEST() [205/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForNonReferenceProperty	)

◆ TEST() [206/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForReferenceToConstProperty	)

◆ TEST() [207/292]

testing::gmock_matchers_test::TEST	(	PropertyTest	,
		WorksForReferenceToNonConstProperty	)

◆ TEST() [208/292]

testing::gmock_matchers_test::TEST	(	RefTest	,
		CanBeUsedAsMatcherForConstReference	)

◆ TEST() [209/292]

testing::gmock_matchers_test::TEST	(	RefTest	,
		CanDescribeSelf	)

◆ TEST() [210/292]

testing::gmock_matchers_test::TEST	(	RefTest	,
		ExplainsResult	)

◆ TEST() [211/292]

testing::gmock_matchers_test::TEST	(	RefTest	,
		IsCovariant	)

◆ TEST() [212/292]

testing::gmock_matchers_test::TEST	(	RefTest	,
		MatchesSameVariable	)

◆ TEST() [213/292]

testing::gmock_matchers_test::TEST	(	ResultOfDeathTest	,
		DiesOnNullFunctionPointers	)

◆ TEST() [214/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		CanDescribeItself	)

◆ TEST() [215/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		CanExplainMatchResult	)

◆ TEST() [216/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForCompatibleMatcherTypes	)

◆ TEST() [217/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForFunctionPointers	)

◆ TEST() [218/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForFunctionReferences	)

◆ TEST() [219/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForFunctors	)

◆ TEST() [220/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForNonReferenceResults	)

◆ TEST() [221/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForPolymorphicFunctors	)

◆ TEST() [222/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForReferenceToConstResults	)

◆ TEST() [223/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForReferenceToNonConstResults	)

◆ TEST() [224/292]

testing::gmock_matchers_test::TEST	(	ResultOfTest	,
		WorksForReferencingCallables	)

◆ TEST() [225/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		ConversionConstructorIsUsed	)

◆ TEST() [226/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromBaseClass	)

◆ TEST() [227/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromConstReferenceToReference	)

◆ TEST() [228/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromConvertibleFromAny	)

◆ TEST() [229/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromLosslesslyConvertibleArithmeticType	)

◆ TEST() [230/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromNonReferenceToConstReference	)

◆ TEST() [231/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromNonReferenceToReference	)

◆ TEST() [232/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromPolymorphicMatcher	)

◆ TEST() [233/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		FromSameType	)

◆ TEST() [234/292]

testing::gmock_matchers_test::TEST	(	SafeMatcherCastTest	,
		ValueIsNotCopied	)

◆ TEST() [235/292]

testing::gmock_matchers_test::TEST	(	SizeIsTest	,
		CanDescribeSelf	)

◆ TEST() [236/292]

testing::gmock_matchers_test::TEST	(	SizeIsTest	,
		ExplainsResult	)

◆ TEST() [237/292]

testing::gmock_matchers_test::TEST	(	SizeIsTest	,
		ImplementsSizeIs	)

◆ TEST() [238/292]

testing::gmock_matchers_test::TEST	(	SizeIsTest	,
		WorksWithMap	)

◆ TEST() [239/292]

testing::gmock_matchers_test::TEST	(	SizeIsTest	,
		WorksWithReferences	)

◆ TEST() [240/292]

testing::gmock_matchers_test::TEST	(	StartsWithTest	,
		CanDescribeSelf	)

◆ TEST() [241/292]

testing::gmock_matchers_test::TEST	(	StartsWithTest	,
		MatchesStringWithGivenPrefix	)

◆ TEST() [242/292]

testing::gmock_matchers_test::TEST	(	StrCaseEqTest	,
		CanDescribeSelf	)

◆ TEST() [243/292]

testing::gmock_matchers_test::TEST	(	StrCaseEqTest	,
		MatchesEqualStringIgnoringCase	)

◆ TEST() [244/292]

testing::gmock_matchers_test::TEST	(	StrCaseEqTest	,
		MatchesEqualStringWith0IgnoringCase	)

◆ TEST() [245/292]

testing::gmock_matchers_test::TEST	(	StrCaseNeTest	,
		CanDescribeSelf	)

◆ TEST() [246/292]

testing::gmock_matchers_test::TEST	(	StrCaseNeTest	,
		MatchesUnequalStringIgnoringCase	)

◆ TEST() [247/292]

testing::gmock_matchers_test::TEST	(	StreamlikeTest	,
		Iteration	)

◆ TEST() [248/292]

testing::gmock_matchers_test::TEST	(	StrEqTest	,
		CanDescribeSelf	)

◆ TEST() [249/292]

testing::gmock_matchers_test::TEST	(	StrEqTest	,
		MatchesEqualString	)

◆ TEST() [250/292]

testing::gmock_matchers_test::TEST	(	StringMatcherTest	,
		CanBeImplicitlyConstructedFromCStringLiteral	)

◆ TEST() [251/292]

testing::gmock_matchers_test::TEST	(	StringMatcherTest	,
		CanBeImplicitlyConstructedFromString	)

◆ TEST() [252/292]

testing::gmock_matchers_test::TEST	(	StrNeTest	,
		CanDescribeSelf	)

◆ TEST() [253/292]

testing::gmock_matchers_test::TEST	(	StrNeTest	,
		MatchesUnequalString	)

◆ TEST() [254/292]

testing::gmock_matchers_test::TEST	(	TrulyTest	,
		CanBeUsedWithFunctor	)

◆ TEST() [255/292]

testing::gmock_matchers_test::TEST	(	TrulyTest	,
		CanDescribeSelf	)

◆ TEST() [256/292]

testing::gmock_matchers_test::TEST	(	TrulyTest	,
		MatchesWhatSatisfiesThePredicate	)

◆ TEST() [257/292]

testing::gmock_matchers_test::TEST	(	TrulyTest	,
		PredicateCanReturnAClassConvertibleToBool	)

◆ TEST() [258/292]

testing::gmock_matchers_test::TEST	(	TrulyTest	,
		WorksForByRefArguments	)

◆ TEST() [259/292]

testing::gmock_matchers_test::TEST	(	TypedEqTest	,
		CanDescribeSelf	)

◆ TEST() [260/292]

testing::gmock_matchers_test::TEST	(	TypedEqTest	,
		ChecksEqualityForGivenType	)

◆ TEST() [261/292]

testing::gmock_matchers_test::TEST	(	TypedEqTest	,
		HasSpecifiedType	)

◆ TEST() [262/292]

testing::gmock_matchers_test::TEST	(	UnderscoreTest	,
		CanDescribeSelf	)

◆ TEST() [263/292]

testing::gmock_matchers_test::TEST	(	UnderscoreTest	,
		MatchesAnyValue	)

◆ TEST() [264/292]

testing::gmock_matchers_test::TEST	(	UnorderedElementsAreArrayTest	,
		SucceedsWhenExpected	)

◆ TEST() [265/292]

testing::gmock_matchers_test::TEST	(	UnorderedElementsAreArrayTest	,
		TakesStlContainer	)

◆ TEST() [266/292]

testing::gmock_matchers_test::TEST	(	UnorderedElementsAreArrayTest	,
		VectorBool	)

◆ TEST() [267/292]

testing::gmock_matchers_test::TEST	(	UnorderedElementsAreArrayTest	,
		WorksForStreamlike	)

◆ TEST() [268/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		AcceptsCorrectContentInDifferentOrder	)

◆ TEST() [269/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		AcceptsCorrectContentInSameOrder	)

◆ TEST() [270/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		AllowsMonomorphicInnerMatcher	)

◆ TEST() [271/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		DescribesSelf	)

◆ TEST() [272/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		MakesCopyOfRhs	)

◆ TEST() [273/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		RejectsWrongContent	)

◆ TEST() [274/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		RejectsWrongSize	)

◆ TEST() [275/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		WorksForLhsNativeArray	)

◆ TEST() [276/292]

testing::gmock_matchers_test::TEST	(	UnorderedPointwiseTest	,
		WorksForRhsNativeArray	)

◆ TEST() [277/292]

testing::gmock_matchers_test::TEST	(	ValueTest	,
		WorksWithMonomorphicMatcher	)

◆ TEST() [278/292]

testing::gmock_matchers_test::TEST	(	ValueTest	,
		WorksWithPolymorphicMatcher	)

◆ TEST() [279/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		CanDescribeSelf	)

◆ TEST() [280/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		ExplainsMatchResult	)

◆ TEST() [281/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		WorksForEmptyContainer	)

◆ TEST() [282/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		WorksForNativeArray	)

◆ TEST() [283/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		WorksForNonEmptyContainer	)

◆ TEST() [284/292]

testing::gmock_matchers_test::TEST	(	WhenSortedByTest	,
		WorksForNonVectorContainer	)

◆ TEST() [285/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForEmptyContainer	)

◆ TEST() [286/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForMapTypes	)

◆ TEST() [287/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForMultiMapTypes	)

◆ TEST() [288/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForNonEmptyContainer	)

◆ TEST() [289/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForPolymorphicMatcher	)

◆ TEST() [290/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForStreamlike	)

◆ TEST() [291/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForVectorConstRefMatcher	)

◆ TEST() [292/292]

testing::gmock_matchers_test::TEST	(	WhenSortedTest	,
		WorksForVectorConstRefMatcherOnStreamlike	)

◆ TEST_F() [1/40]

testing::gmock_matchers_test::TEST_F	(	BipartiteNonSquareTest	,
		SimpleBacktracking	)

◆ TEST_F() [2/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		DoubleNearCanDescribeSelf	)

◆ TEST_F() [3/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		DoubleNearCannotMatchNaN	)

◆ TEST_F() [4/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		DoubleNearMatches	)

◆ TEST_F() [5/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		ExplainsResultWhenMatchFails	)

◆ TEST_F() [6/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		NanSensitiveDoubleNearApproximatelyMatchesDoubles	)

◆ TEST_F() [7/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		NanSensitiveDoubleNearCanDescribeSelf	)

◆ TEST_F() [8/40]

testing::gmock_matchers_test::TEST_F	(	DoubleNearTest	,
		NanSensitiveDoubleNearCanMatchNaN	)

◆ TEST_F() [9/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		DoubleEqApproximatelyMatchesDoubles	)

◆ TEST_F() [10/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		DoubleEqCanDescribeSelf	)

◆ TEST_F() [11/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		DoubleEqCannotMatchNaN	)

◆ TEST_F() [12/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		NanSensitiveDoubleEqApproximatelyMatchesDoubles	)

◆ TEST_F() [13/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		NanSensitiveDoubleEqCanDescribeSelf	)

◆ TEST_F() [14/40]

testing::gmock_matchers_test::TEST_F	(	DoubleTest	,
		NanSensitiveDoubleEqCanMatchNaN	)

◆ TEST_F() [15/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		FloatNearCanDescribeSelf	)

◆ TEST_F() [16/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		FloatNearCannotMatchNaN	)

◆ TEST_F() [17/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		FloatNearMatches	)

◆ TEST_F() [18/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		NanSensitiveFloatNearApproximatelyMatchesFloats	)

◆ TEST_F() [19/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		NanSensitiveFloatNearCanDescribeSelf	)

◆ TEST_F() [20/40]

testing::gmock_matchers_test::TEST_F	(	FloatNearTest	,
		NanSensitiveFloatNearCanMatchNaN	)

◆ TEST_F() [21/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		FloatEqApproximatelyMatchesFloats	)

◆ TEST_F() [22/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		FloatEqCanDescribeSelf	)

◆ TEST_F() [23/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		FloatEqCannotMatchNaN	)

◆ TEST_F() [24/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		NanSensitiveFloatEqApproximatelyMatchesFloats	)

◆ TEST_F() [25/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		NanSensitiveFloatEqCanDescribeSelf	)

◆ TEST_F() [26/40]

testing::gmock_matchers_test::TEST_F	(	FloatTest	,
		NanSensitiveFloatEqCanMatchNaN	)

◆ TEST_F() [27/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		Describe	)

◆ TEST_F() [28/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		DescribeNegation	)

◆ TEST_F() [29/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageCountWrong	)

◆ TEST_F() [30/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageCountWrongZero	)

◆ TEST_F() [31/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageImperfectMatchOnly	)

◆ TEST_F() [32/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageUnmatchedElements	)

◆ TEST_F() [33/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageUnmatchedMatcherAndElement	)

◆ TEST_F() [34/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailMessageUnmatchedMatchers	)

◆ TEST_F() [35/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		FailsWhenAnElementMatchesNoMatcher	)

◆ TEST_F() [36/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		Performance	)

◆ TEST_F() [37/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		PerformanceHalfStrict	)

◆ TEST_F() [38/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		SucceedsWhenExpected	)

◆ TEST_F() [39/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		WorksForStreamlike	)

◆ TEST_F() [40/40]

testing::gmock_matchers_test::TEST_F	(	UnorderedElementsAreTest	,
		WorksWithUncopyable	)

◆ TEST_P() [1/3]

testing::gmock_matchers_test::TEST_P	(	BipartiteNonSquareTest	,
		Exhaustive	)

◆ TEST_P() [2/3]

testing::gmock_matchers_test::TEST_P	(	BipartiteRandomTest	,
		LargerNets	)

◆ TEST_P() [3/3]

testing::gmock_matchers_test::TEST_P	(	BipartiteTest	,
		Exhaustive	)

◆ Truly()

template<typename Predicate>

PolymorphicMatcher< internal::TrulyMatcher< Predicate > > testing::Truly ( Predicate pred )

inline

◆ TypedEq()

template<typename Lhs, typename Rhs>

Matcher< Lhs > testing::TypedEq ( const Rhs & rhs )

inline

◆ UnorderedPointwise()

template<typename Tuple2Matcher, typename RhsContainer>

internal::UnorderedElementsAreArrayMatcher< typename internal::BoundSecondMatcher< Tuple2Matcher, typename internal::StlContainerView< GTEST_REMOVE_CONST_(RhsContainer)>::type::value_type > > testing::UnorderedPointwise	(	const Tuple2Matcher &	tuple2_matcher,
		const RhsContainer &	rhs_container )

inline

◆ ValueIsPositive()

bool testing::gmock_matchers_test::ValueIsPositive ( const Uncopyable & x )

◆ WhenSorted()

template<typename ContainerMatcher>

internal::WhenSortedByMatcher< internal::LessComparator, ContainerMatcher > testing::WhenSorted ( const ContainerMatcher & container_matcher )

inline

◆ WhenSortedBy()

template<typename Comparator, typename ContainerMatcher>

internal::WhenSortedByMatcher< Comparator, ContainerMatcher > testing::WhenSortedBy	(	const Comparator &	comparator,
		const ContainerMatcher &	container_matcher )

inline

Variable Documentation

◆ _

const internal::AnythingMatcher testing::_

◆ foo

const int testing::gmock_matchers_test::foo = 0

◆ g_bar

const int testing::gmock_matchers_test::g_bar = 1

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ DoubleNearTest

◆ DoubleTest

◆ ElementMatcherPair

◆ ElementMatcherPairs

◆ FloatNearTest

◆ FloatTest

◆ string

◆ Strings

◆ Tuple2

Function Documentation

◆ AllArgs()

◆ AllOf()

◆ AllOfMatches()

◆ An()

◆ AnyOf()

◆ AnyOfMatches()

◆ ContainsRegex()

◆ Describe()

◆ DescribeNegation()

◆ DivisibleBy()

◆ DoubleEq()

◆ DoubleFunction()

◆ DoubleNear()

◆ EMString()

◆ EndsWith()

◆ Eq()

◆ Explain()

◆ ExplainMatchFailureTupleTo()

◆ ExplainMatchResult()

◆ Field()

◆ FindBacktrackingMaxBPM()

◆ FloatEq()

◆ FloatNear()

◆ FormatMatcherDescription()

◆ Ge()

◆ GreaterThan()

◆ Gt()

◆ HasSubstr()

◆ INSTANTIATE_TEST_CASE_P() [1/3]

◆ INSTANTIATE_TEST_CASE_P() [2/3]

◆ INSTANTIATE_TEST_CASE_P() [3/3]

◆ IntFunction()

◆ IntToStringFunction()

◆ IsHalfOf()

◆ IsNotZero()

◆ IsNull()

◆ IsPositive()

◆ IsPositiveIntValue()

◆ IsReadableTypeName()

◆ JoinAsTuple()

◆ Key()

◆ Le()

◆ Lt()

◆ MakeMatcher()

◆ MakePolymorphicMatcher()

◆ MATCHER_P() [1/3]

◆ MATCHER_P() [2/3]

◆ MATCHER_P() [3/3]

◆ MatcherCast()

◆ Matches()

◆ MatchesRegex()

◆ NanSensitiveDoubleEq()

◆ NanSensitiveDoubleNear()

◆ NanSensitiveFloatEq()

◆ NanSensitiveFloatNear()

◆ Ne()

◆ Not()

◆ NotNull()

◆ OfType()

◆ operator<<()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ Pair()

◆ Pointwise()

◆ PolymorphicIsEven()