proxygen: testing::gmock_matchers_test Namespace Reference

Classes
class	AClass

class	AllArgsHelper

struct	AStruct

class	BacktrackingBPMTest

class	Base

class	BipartiteNonSquareTest

class	BipartiteRandomTest

class	BipartiteTest

class	ConstPropagatingPtr

struct	ConvertibleFromAny

class	ConvertibleToBool

class	Derived

class	DerivedClass

struct	DerivedStruct

class	DivisibleByImpl

class	EvenMatcherImpl

class	FloatingPointNearTest

class	FloatingPointTest

struct	Functor

class	GreaterThanMatcher

struct	IntReferenceWrapper

class	IntValue

class	IsGreaterThan

class	IsHalfOfMatcher

class	NewEvenMatcherImpl

class	NotCopyable

class	OtherDerived

struct	PolymorphicFunctor

class	PolymorphicIsEvenImpl

class	ReferencesBarOrIsZeroImpl

struct	ReferencingFunctor

class	Streamlike

struct	Type

class	Uncopyable

class	UnorderedElementsAreTest

class	Unprintable

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

typedef FloatingPointTest< float >	FloatTest

typedef FloatingPointNearTest< float >	FloatNearTest

typedef FloatingPointTest< double >	DoubleTest

typedef FloatingPointNearTest< double >	DoubleNearTest

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)

bool	operator== (const Unprintable &, const Unprintable &)

	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)

static string	EMString (int element, int matcher)

static string	EMString (int element, int matcher)

Variables
const int	g_bar = 1

const int	foo = 0

Typedef Documentation

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

Definition at line 3071 of file gmock-matchers_test.cc.

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

Definition at line 3015 of file gmock-matchers_test.cc.

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

Definition at line 2956 of file gmock-matchers_test.cc.

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

Definition at line 2900 of file gmock-matchers_test.cc.

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

Definition at line 1930 of file gmock-matchers_test.cc.

Function Documentation

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

Definition at line 2046 of file gmock-matchers_test.cc.

References Describe(), EXPECT_FALSE, EXPECT_TRUE, i, testing::internal::MatcherBase< T >::Matches(), and SCOPED_TRACE.

Referenced by testing::gmock_matchers_test::Type< T >::IsTypeOf(), and TEST().

                                                   {
   SCOPED_TRACE(Describe(m));
   EXPECT_TRUE(m.Matches(0));
   for (int i = 1; i <= num; ++i) {
     EXPECT_FALSE(m.Matches(i));
   }
   EXPECT_TRUE(m.Matches(num + 1));
 }

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

Definition at line 2244 of file gmock-matchers_test.cc.

References Describe(), EXPECT_FALSE, EXPECT_TRUE, i, testing::internal::MatcherBase< T >::Matches(), and SCOPED_TRACE.

Referenced by testing::gmock_matchers_test::Type< T >::IsTypeOf(), and TEST().

                                                   {
   SCOPED_TRACE(Describe(m));
   EXPECT_FALSE(m.Matches(0));
   for (int i = 1; i <= num; ++i) {
     EXPECT_TRUE(m.Matches(i));
   }
   EXPECT_FALSE(m.Matches(num + 1));
 }

template<typename T >

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

Definition at line 202 of file gmock-matchers_test.cc.

References testing::internal::MatcherBase< T >::DescribeTo().

                                      {
   stringstream ss;
   m.DescribeTo(&ss);
   return ss.str();
 }

template<typename T >

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

Definition at line 210 of file gmock-matchers_test.cc.

References testing::internal::MatcherBase< T >::DescribeNegationTo().

                                              {
   stringstream ss;
   m.DescribeNegationTo(&ss);
   return ss.str();
 }

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

Definition at line 3990 of file gmock-matchers_test.cc.

References testing::MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::DivisibleByImpl::divider(), and TEST().

                                                        {
   return MakePolymorphicMatcher(DivisibleByImpl(n));
 }

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

Definition at line 3845 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), and TEST().

3845 { return input; } // NOLINT

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

static

Definition at line 4940 of file gmock-matchers_test.cc.

                                                  {
   stringstream ss;
   ss << "(element #" << element << ", matcher #" << matcher << ")";
   return ss.str();
 }

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

static

Definition at line 4940 of file gmock-matchers_test.cc.

References testing::AnyOf(), best_so_far_, Describe(), DescribeNegation(), EMString(), testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), g(), graph_, kUnused, lhs_used_, matches_, prefix(), rhs_used_, testing::StringMatchResultListener::str(), testing::internal::TEST_F(), testing::UnorderedElementsAre(), and v.

                                                  {
   stringstream ss;
   ss << "(element #" << element << ", matcher #" << matcher << ")";
   return ss.str();
 }

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

static

Definition at line 4940 of file gmock-matchers_test.cc.

References testing::AnyOf(), best_so_far_, Describe(), DescribeNegation(), testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), g(), graph_, kUnused, lhs_used_, matches_, prefix(), rhs_used_, testing::StringMatchResultListener::str(), testing::internal::TEST_F(), testing::UnorderedElementsAre(), and v.

Referenced by EMString(), and TEST_F().

                                                  {
   stringstream ss;
   ss << "(element #" << element << ", matcher #" << matcher << ")";
   return ss.str();
 }

template<typename MatcherType , typename Value >

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

Definition at line 218 of file gmock-matchers_test.cc.

References testing::ExplainMatchResult(), and testing::StringMatchResultListener::str().

                                                      {
   StringMatchResultListener listener;
   ExplainMatchResult(m, x, &listener);
   return listener.str();
 }

template<typename Graph >

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

Definition at line 5091 of file gmock-matchers_test.cc.

References g().

Referenced by TEST_F(), and TEST_P().

                                        {
   return BacktrackingMaxBPMState<Graph>(&g).Compute();
 }

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

Definition at line 188 of file gmock-matchers_test.cc.

References testing::MakeMatcher().

Referenced by testing::gmock_matchers_test::AStruct::AStruct(), testing::gmock_matchers_test::NewEvenMatcherImpl::DescribeTo(), testing::gmock_matchers_test::DivisibleByImpl::divider(), testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::DerivedClass::k(), testing::gmock_matchers_test::GreaterThanMatcher::MatchAndExplain(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), testing::gmock_matchers_test::NotCopyable::operator>=(), and TEST().

                                 {
   return MakeMatcher(new GreaterThanMatcher(n));
 }

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

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

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

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

Definition at line 3822 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), and TEST().

3822 { return input == 42 ? 80 : 90; }

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

Definition at line 3802 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), testing::gmock_matchers_test::Functor::operator()(), and TEST().

3802 { return input == 1 ? "foo" : "bar"; }

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

Definition at line 5433 of file gmock-matchers_test.cc.

References testing::MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::IsHalfOfMatcher::DescribeNegationTo(), and TEST().

                                                {
   return MakePolymorphicMatcher(IsHalfOfMatcher());
 }

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

Definition at line 2485 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::ConvertibleToBool::operator bool(), and TEST().

                                         {
   return ConvertibleToBool(number);
 }

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

Definition at line 2435 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::Type< T >::IsTypeOf(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::IsGreaterThan::operator()(), operator<<(), and TEST().

                          {
   return x > 0 ? 1 : 0;
 }

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

Definition at line 549 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::IntValue::value().

Referenced by TEST(), and testing::gmock_matchers_test::IntValue::value().

                                              {
   return foo.value() > 0;
 }

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

Definition at line 2578 of file gmock-matchers_test.cc.

References testing::ExplainMatchResult().

                                      {
   return ExplainMatchResult(inner_matcher, arg, result_listener);
 }

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

Definition at line 3184 of file gmock-matchers_test.cc.

References testing::_, Describe(), DescribeNegation(), EXPECT_EQ, EXPECT_THAT, EXPECT_TRUE, Explain(), testing::ExplainMatchResult(), testing::HasSubstr(), testing::gmock_matchers_test::Derived::i, testing::internal::IsNull(), testing::internal::MatcherBase< T >::Matches(), testing::Not(), testing::Pointee(), prefix(), and testing::internal::TEST().

                                        {
   return ExplainMatchResult(inner_matcher, arg.i, result_listener);
 }

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

Definition at line 3373 of file gmock-matchers_test.cc.

References testing::ExplainMatchResult().

Referenced by testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::Uncopyable::set_value(), and testing::gmock_matchers_test::FloatingPointNearTest< RawType >::TestNearMatches().

                                            {
   return ExplainMatchResult(inner_matcher, arg.value(), result_listener);
 }

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

Definition at line 192 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::AllArgsHelper::AllArgsHelper(), testing::gmock_matchers_test::AStruct::AStruct(), testing::gmock_matchers_test::DerivedClass::k(), testing::gmock_matchers_test::GreaterThanMatcher::MatchAndExplain(), testing::gmock_matchers_test::ConstPropagatingPtr< T >::operator*(), and TEST().

                                        {
 #if GTEST_HAS_RTTI
   return " (of type " + type_name + ")";
 #else
   return "";
 #endif
 }

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

Definition at line 626 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::ConvertibleFromAny::value.

                                                               {
   return os << a.value;
 }

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

Definition at line 622 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::ConvertibleFromAny::value.

                                                                           {
   return a.value == b.value;
 }

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

Definition at line 648 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::IntReferenceWrapper::value.

                                                                             {
   return a.value == b.value;
 }

bool testing::gmock_matchers_test::operator==	(	const Unprintable &	,
		const Unprintable &
	)

inline

Definition at line 874 of file gmock-matchers_test.cc.

                                              { 
     return true; 
 }

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

Definition at line 501 of file gmock-matchers_test.cc.

References testing::MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::PolymorphicIsEvenImpl::MatchAndExplain(), testing::gmock_matchers_test::ConvertibleToBool::operator bool(), and TEST().

                                                               {
   return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
 }

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

Definition at line 458 of file gmock-matchers_test.cc.

References testing::MakePolymorphicMatcher().

Referenced by testing::gmock_matchers_test::ReferencesBarOrIsZeroImpl::DescribeNegationTo(), and TEST().

                                                                       {
   return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
 }

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

Definition at line 2456 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::ConvertibleToBool::operator bool(), testing::gmock_matchers_test::IsGreaterThan::operator()(), and TEST().

                                           {
   return (&n == &foo) && (n == 0);
 }

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

Definition at line 3944 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::PolymorphicFunctor::operator()(), testing::gmock_matchers_test::ReferencingFunctor::operator()(), and TEST().

3944 { return &n; }

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

Definition at line 3847 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), and TEST().

                                                    {  // NOLINT
   return obj;
 }

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

Definition at line 3871 of file gmock-matchers_test.cc.

Referenced by testing::gmock_matchers_test::DerivedClass::k(), and TEST().

3871 { return input; }

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

Definition at line 224 of file gmock-matchers_test.cc.

References testing::StringMatchResultListener::Clear(), dummy(), EXPECT_EQ, and testing::StringMatchResultListener::str().

                                               {
   StringMatchResultListener listener;
   listener << "hi" << 5;
   EXPECT_EQ("hi5", listener.str());
 
   listener.Clear();
   EXPECT_EQ("", listener.str());
 
   listener << 42;
   EXPECT_EQ("42", listener.str());
 
   // Streaming shouldn't crash when the underlying ostream is NULL.
   DummyMatchResultListener dummy;
   dummy << "hi" << 5;
 }

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

Definition at line 240 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_TRUE, and stream.

                                                          {
   EXPECT_TRUE(DummyMatchResultListener().stream() == NULL);
   EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL);
 
   EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
 }

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

Definition at line 247 of file gmock-matchers_test.cc.

References EXPECT_FALSE, and EXPECT_TRUE.

                                                  {
   EXPECT_TRUE(StringMatchResultListener().IsInterested());
   EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
 
   EXPECT_FALSE(DummyMatchResultListener().IsInterested());
   EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested());
 }

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

Definition at line 274 of file gmock-matchers_test.cc.

References m.

                                                               {
   EvenMatcherImpl m;
 }

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

Definition at line 299 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, Explain(), m, testing::MakeMatcher(), and testing::internal::MatcherBase< T >::Matches().

                                                         {
   Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
   EXPECT_TRUE(m.Matches(2));
   EXPECT_FALSE(m.Matches(3));
   EXPECT_EQ("value % 2 == 0", Explain(m, 2));
   EXPECT_EQ("value % 2 == 1", Explain(m, 3));
 }

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

Definition at line 308 of file gmock-matchers_test.cc.

References m.

                                            {
   Matcher<double> m;
 }

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

Definition at line 313 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                                         {
   const MatcherInterface<int>* impl = new EvenMatcherImpl;
   Matcher<int> m(impl);
   EXPECT_TRUE(m.Matches(4));
   EXPECT_FALSE(m.Matches(5));
 }

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

Definition at line 321 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                        {
   Matcher<int> m1 = 5;
   EXPECT_TRUE(m1.Matches(5));
   EXPECT_FALSE(m1.Matches(6));
 }

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

Definition at line 328 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                       {
   Matcher<int*> m1 = NULL;
   EXPECT_TRUE(m1.Matches(NULL));
   int n = 0;
   EXPECT_FALSE(m1.Matches(&n));
 }

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

Definition at line 336 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                               {
   // Tests the copy constructor.
   Matcher<bool> m1 = Eq(false);
   EXPECT_TRUE(m1.Matches(false));
   EXPECT_FALSE(m1.Matches(true));
 
   // Tests the assignment operator.
   m1 = Eq(true);
   EXPECT_TRUE(m1.Matches(true));
   EXPECT_FALSE(m1.Matches(false));
 }

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

Definition at line 350 of file gmock-matchers_test.cc.

References Describe(), and EXPECT_EQ.

                                      {
   EXPECT_EQ("is an even number",
             Describe(Matcher<int>(new EvenMatcherImpl)));
 }

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

Definition at line 356 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, GreaterThan(), m, testing::internal::MatcherBase< T >::MatchAndExplain(), and testing::StringMatchResultListener::str().

                                    {
   Matcher<int> m = GreaterThan(0);
   StringMatchResultListener listener1;
   EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
   EXPECT_EQ("which is 42 more than 0", listener1.str());
 
   StringMatchResultListener listener2;
   EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
   EXPECT_EQ("which is 9 less than 0", listener2.str());
 }

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

Definition at line 369 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                                       {
   Matcher<string> m1 = "hi";
   EXPECT_TRUE(m1.Matches("hi"));
   EXPECT_FALSE(m1.Matches("hello"));
 
   Matcher<const string&> m2 = "hi";
   EXPECT_TRUE(m2.Matches("hi"));
   EXPECT_FALSE(m2.Matches("hello"));
 }

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

Definition at line 381 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::internal::TEST().

                                                               {
   Matcher<string> m1 = string("hi");
   EXPECT_TRUE(m1.Matches("hi"));
   EXPECT_FALSE(m1.Matches("hello"));
 
   Matcher<const string&> m2 = string("hi");
   EXPECT_TRUE(m2.Matches("hi"));
   EXPECT_FALSE(m2.Matches("hello"));
 }

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

Definition at line 432 of file gmock-matchers_test.cc.

References m, and testing::MakeMatcher().

                                                              {
   const MatcherInterface<int>* dummy_impl = NULL;
   Matcher<int> m = MakeMatcher(dummy_impl);
 }

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

Definition at line 462 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and ReferencesBarOrIsZero().

                                                                {
   // Using a polymorphic matcher to match a reference type.
   Matcher<const int&> m1 = ReferencesBarOrIsZero();
   EXPECT_TRUE(m1.Matches(0));
   // Verifies that the identity of a by-reference argument is preserved.
   EXPECT_TRUE(m1.Matches(g_bar));
   EXPECT_FALSE(m1.Matches(1));
   EXPECT_EQ("g_bar or zero", Describe(m1));
 
   // Using a polymorphic matcher to match a value type.
   Matcher<double> m2 = ReferencesBarOrIsZero();
   EXPECT_TRUE(m2.Matches(0.0));
   EXPECT_FALSE(m2.Matches(0.1));
   EXPECT_EQ("g_bar or zero", Describe(m2));
 }

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

Definition at line 505 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, Explain(), testing::internal::MatcherBase< T >::Matches(), testing::Not(), and PolymorphicIsEven().

                                                                {
   // Using PolymorphicIsEven() as a Matcher<int>.
   const Matcher<int> m1 = PolymorphicIsEven();
   EXPECT_TRUE(m1.Matches(42));
   EXPECT_FALSE(m1.Matches(43));
   EXPECT_EQ("is even", Describe(m1));
 
   const Matcher<int> not_m1 = Not(m1);
   EXPECT_EQ("is odd", Describe(not_m1));
 
   EXPECT_EQ("% 2 == 0", Explain(m1, 42));
 
   // Using PolymorphicIsEven() as a Matcher<char>.
   const Matcher<char> m2 = PolymorphicIsEven();
   EXPECT_TRUE(m2.Matches('\x42'));
   EXPECT_FALSE(m2.Matches('\x43'));
   EXPECT_EQ("is even", Describe(m2));
 
   const Matcher<char> not_m2 = Not(m2);
   EXPECT_EQ("is odd", Describe(not_m2));
 
   EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
 }

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

Definition at line 530 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                               {
   Matcher<int> m = MatcherCast<int>(Eq(5));
   EXPECT_TRUE(m.Matches(5));
   EXPECT_FALSE(m.Matches(6));
 }

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

Definition at line 555 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, IsPositiveIntValue(), testing::internal::MatcherBase< T >::Matches(), and testing::Truly().

                                           {
   Matcher<double> m1 = Eq(2.0);
   Matcher<int> m2 = MatcherCast<int>(m1);
   EXPECT_TRUE(m2.Matches(2));
   EXPECT_FALSE(m2.Matches(3));
 
   Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
   Matcher<int> m4 = MatcherCast<int>(m3);
   // In the following, the arguments 1 and 0 are statically converted
   // to IntValue objects, and then tested by the IsPositiveIntValue()
   // predicate.
   EXPECT_TRUE(m4.Matches(1));
   EXPECT_FALSE(m4.Matches(0));
 }

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

Definition at line 571 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                         {
   Matcher<const int&> m1 = Eq(0);
   Matcher<int> m2 = MatcherCast<int>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 579 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                    {
   Matcher<int&> m1 = Eq(0);
   Matcher<int> m2 = MatcherCast<int>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 587 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                         {
   Matcher<int> m1 = Eq(0);
   Matcher<const int&> m2 = MatcherCast<const int&>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 595 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                    {
   Matcher<int> m1 = Eq(0);
   Matcher<int&> m2 = MatcherCast<int&>(m1);
   int n = 0;
   EXPECT_TRUE(m2.Matches(n));
   n = 1;
   EXPECT_FALSE(m2.Matches(n));
 }

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

Definition at line 605 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                     {
   Matcher<int> m1 = Eq(0);
   Matcher<int> m2 = MatcherCast<int>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 630 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                                    {
   Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
   EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
   EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
 }

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

Definition at line 636 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                               {
   Matcher<ConvertibleFromAny> m =
       MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
   EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
   EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
 }

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

Definition at line 652 of file gmock-matchers_test.cc.

References EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                         {
   int n = 42;
   Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
   // Verify that the matcher holds a reference to n, not to its temporary copy.
   EXPECT_TRUE(m.Matches(n));
 }

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

Definition at line 676 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                   {
   Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
   EXPECT_TRUE(m2.Matches(' '));
   EXPECT_FALSE(m2.Matches('\n'));
 }

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

Definition at line 685 of file gmock-matchers_test.cc.

References testing::DoubleEq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                                    {
   Matcher<double> m1 = DoubleEq(1.0);
   Matcher<float> m2 = SafeMatcherCast<float>(m1);
   EXPECT_TRUE(m2.Matches(1.0f));
   EXPECT_FALSE(m2.Matches(2.0f));
 
   Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
   EXPECT_TRUE(m3.Matches('a'));
   EXPECT_FALSE(m3.Matches('b'));
 }

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

Definition at line 698 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::Ref().

                                          {
   Derived d, d2;
   Matcher<Base*> m1 = Eq(&d);
   Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
   EXPECT_TRUE(m2.Matches(&d));
   EXPECT_FALSE(m2.Matches(&d2));
 
   Matcher<Base&> m3 = Ref(d);
   Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
   EXPECT_TRUE(m4.Matches(d));
   EXPECT_FALSE(m4.Matches(d2));
 }

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

Definition at line 712 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::Ref().

                                                          {
   int n = 0;
   Matcher<const int&> m1 = Ref(n);
   Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
   int n1 = 0;
   EXPECT_TRUE(m2.Matches(n));
   EXPECT_FALSE(m2.Matches(n1));
 }

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

Definition at line 722 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                             {
   Matcher<int> m1 = Eq(0);
   Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 730 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                        {
   Matcher<int> m1 = Eq(0);
   Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
   int n = 0;
   EXPECT_TRUE(m2.Matches(n));
   n = 1;
   EXPECT_FALSE(m2.Matches(n));
 }

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

Definition at line 740 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                         {
   Matcher<int> m1 = Eq(0);
   Matcher<int> m2 = SafeMatcherCast<int>(m1);
   EXPECT_TRUE(m2.Matches(0));
   EXPECT_FALSE(m2.Matches(1));
 }

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

Definition at line 747 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                                        {
   Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
   EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
   EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
 }

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

Definition at line 753 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                                   {
   Matcher<ConvertibleFromAny> m =
       SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
   EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
   EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
 }

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

Definition at line 760 of file gmock-matchers_test.cc.

References EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                             {
   int n = 42;
   Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
   // Verify that the matcher holds a reference to n, not to its temporary copy.
   EXPECT_TRUE(m.Matches(n));
 }

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

Definition at line 767 of file gmock-matchers_test.cc.

References EXPECT_THAT.

                                 {
   EXPECT_THAT(1, 1);
   EXPECT_THAT(1.0, 1.0);
   EXPECT_THAT(string(), "");
 }

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

Definition at line 773 of file gmock-matchers_test.cc.

References EXPECT_THAT.

                                  {
   struct Helper {
     static void Func() {}
   };
   void (*func)() = Helper::Func;
   EXPECT_THAT(func, Helper::Func);
   EXPECT_THAT(func, &Helper::Func);
 }

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

Definition at line 783 of file gmock-matchers_test.cc.

References a, b, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                              {
   // Tests a matcher for a value type.
   Matcher<double> m1 = A<double>();
   EXPECT_TRUE(m1.Matches(91.43));
   EXPECT_TRUE(m1.Matches(-15.32));
 
   // Tests a matcher for a reference type.
   int a = 2;
   int b = -6;
   Matcher<int&> m2 = A<int&>();
   EXPECT_TRUE(m2.Matches(a));
   EXPECT_TRUE(m2.Matches(b));
 }

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

Definition at line 797 of file gmock-matchers_test.cc.

References EXPECT_THAT.

                                   {
   Base base;
   Derived derived;
   EXPECT_THAT(&base, A<Base*>());
   // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
   EXPECT_THAT(&derived, A<Base*>());
   EXPECT_THAT(&derived, A<Derived*>());
 }

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

Definition at line 807 of file gmock-matchers_test.cc.

References Describe(), and EXPECT_EQ.

                              {
   EXPECT_EQ("is anything", Describe(A<bool>()));
 }

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

Definition at line 812 of file gmock-matchers_test.cc.

References a, b, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                               {
   // Tests a matcher for a value type.
   Matcher<int> m1 = An<int>();
   EXPECT_TRUE(m1.Matches(9143));
   EXPECT_TRUE(m1.Matches(-1532));
 
   // Tests a matcher for a reference type.
   int a = 2;
   int b = -6;
   Matcher<int&> m2 = An<int&>();
   EXPECT_TRUE(m2.Matches(a));
   EXPECT_TRUE(m2.Matches(b));
 }

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

Definition at line 827 of file gmock-matchers_test.cc.

References Describe(), and EXPECT_EQ.

                               {
   EXPECT_EQ("is anything", Describe(An<int>()));
 }

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

Definition at line 833 of file gmock-matchers_test.cc.

References testing::_, a, b, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                       {
   // Uses _ as a matcher for a value type.
   Matcher<int> m1 = _;
   EXPECT_TRUE(m1.Matches(123));
   EXPECT_TRUE(m1.Matches(-242));
 
   // Uses _ as a matcher for a reference type.
   bool a = false;
   const bool b = true;
   Matcher<const bool&> m2 = _;
   EXPECT_TRUE(m2.Matches(a));
   EXPECT_TRUE(m2.Matches(b));
 }

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

Definition at line 848 of file gmock-matchers_test.cc.

References testing::_, Describe(), EXPECT_EQ, and m.

                                       {
   Matcher<int> m = _;
   EXPECT_EQ("is anything", Describe(m));
 }

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

Definition at line 854 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                 {
   // 2 C-strings with same content but different addresses.
   const char a1[] = "hi";
   const char a2[] = "hi";
 
   Matcher<const char*> m1 = Eq(a1);
   EXPECT_TRUE(m1.Matches(a1));
   EXPECT_FALSE(m1.Matches(a2));
 }

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

Definition at line 879 of file gmock-matchers_test.cc.

References Describe(), testing::Eq(), EXPECT_EQ, and m.

                               {
   Matcher<Unprintable> m = Eq(Unprintable());
   EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
 }

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

Definition at line 886 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                             {
   Matcher<int> m1 = Eq(1);
   EXPECT_TRUE(m1.Matches(1));
   EXPECT_FALSE(m1.Matches(2));
 
   Matcher<char> m2 = Eq(1);
   EXPECT_TRUE(m2.Matches('\1'));
   EXPECT_FALSE(m2.Matches('a'));
 }

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

Definition at line 897 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                               {
   Matcher<char> m1 = TypedEq<char>('a');
   EXPECT_TRUE(m1.Matches('a'));
   EXPECT_FALSE(m1.Matches('b'));
 
   Matcher<int> m2 = TypedEq<int>(6);
   EXPECT_TRUE(m2.Matches(6));
   EXPECT_FALSE(m2.Matches(7));
 }

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

Definition at line 908 of file gmock-matchers_test.cc.

References Describe(), and EXPECT_EQ.

                                    {
   EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
 }

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

Definition at line 926 of file gmock-matchers_test.cc.

                                     {
   // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
   Type<Matcher<int> >::IsTypeOf(TypedEq<int>(5));
   Type<Matcher<double> >::IsTypeOf(TypedEq<double>(5));
 }

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

Definition at line 933 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), and testing::internal::MatcherBase< T >::Matches().

                                            {
   Matcher<int> m1 = Ge(0);
   EXPECT_TRUE(m1.Matches(1));
   EXPECT_TRUE(m1.Matches(0));
   EXPECT_FALSE(m1.Matches(-1));
 }

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

Definition at line 941 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Ge(), and m.

                               {
   Matcher<int> m = Ge(5);
   EXPECT_EQ("is >= 5", Describe(m));
 }

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

Definition at line 947 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Gt(), and testing::internal::MatcherBase< T >::Matches().

                                     {
   Matcher<double> m1 = Gt(0);
   EXPECT_TRUE(m1.Matches(1.0));
   EXPECT_FALSE(m1.Matches(0.0));
   EXPECT_FALSE(m1.Matches(-1.0));
 }

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

Definition at line 955 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Gt(), and m.

                               {
   Matcher<int> m = Gt(5);
   EXPECT_EQ("is > 5", Describe(m));
 }

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

Definition at line 961 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Le(), and testing::internal::MatcherBase< T >::Matches().

                                         {
   Matcher<char> m1 = Le('b');
   EXPECT_TRUE(m1.Matches('a'));
   EXPECT_TRUE(m1.Matches('b'));
   EXPECT_FALSE(m1.Matches('c'));
 }

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

Definition at line 969 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Le(), and m.

                               {
   Matcher<int> m = Le(5);
   EXPECT_EQ("is <= 5", Describe(m));
 }

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

Definition at line 975 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Lt(), and testing::internal::MatcherBase< T >::Matches().

                                  {
   Matcher<const string&> m1 = Lt("Hello");
   EXPECT_TRUE(m1.Matches("Abc"));
   EXPECT_FALSE(m1.Matches("Hello"));
   EXPECT_FALSE(m1.Matches("Hello, world!"));
 }

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

Definition at line 983 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Lt(), and m.

                               {
   Matcher<int> m = Lt(5);
   EXPECT_EQ("is < 5", Describe(m));
 }

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

Definition at line 989 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::Ne().

                                  {
   Matcher<int> m1 = Ne(0);
   EXPECT_TRUE(m1.Matches(1));
   EXPECT_TRUE(m1.Matches(-1));
   EXPECT_FALSE(m1.Matches(0));
 }

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

Definition at line 997 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::Ne().

                               {
   Matcher<int> m = Ne(5);
   EXPECT_EQ("isn't equal to 5", Describe(m));
 }

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

Definition at line 1003 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::IsNull(), and testing::internal::MatcherBase< T >::Matches().

                                      {
   Matcher<int*> m1 = IsNull();
   int* p1 = NULL;
   int n = 0;
   EXPECT_TRUE(m1.Matches(p1));
   EXPECT_FALSE(m1.Matches(&n));
 
   Matcher<const char*> m2 = IsNull();
   const char* p2 = NULL;
   EXPECT_TRUE(m2.Matches(p2));
   EXPECT_FALSE(m2.Matches("hi"));
 
 #if !GTEST_OS_SYMBIAN
   // Nokia's Symbian compiler generates:
   // gmock-matchers.h: ambiguous access to overloaded function
   // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(void *)'
   // gmock-matchers.h: 'testing::Matcher<void *>::Matcher(const testing::
   //     MatcherInterface<void *> *)'
   // gmock-matchers.h:  (point of instantiation: 'testing::
   //     gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
   // gmock-matchers.h:   (instantiating: 'testing::PolymorphicMatc
   Matcher<void*> m3 = IsNull();
   void* p3 = NULL;
   EXPECT_TRUE(m3.Matches(p3));
   EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
 #endif
 }

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

Definition at line 1031 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::IsNull(), m, and testing::internal::MatcherBase< T >::Matches().

                             {
   const Matcher<linked_ptr<int> > m = IsNull();
   const linked_ptr<int> null_p;
   const linked_ptr<int> non_null_p(new int);
 
   EXPECT_TRUE(m.Matches(null_p));
   EXPECT_FALSE(m.Matches(non_null_p));
 }

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

Definition at line 1040 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::IsNull(), m, testing::internal::MatcherBase< T >::Matches(), and testing::internal::TEST().

                                             {
   const Matcher<const linked_ptr<double>&> m = IsNull();
   const linked_ptr<double> null_p;
   const linked_ptr<double> non_null_p(new double);
 
   EXPECT_TRUE(m.Matches(null_p));
   EXPECT_FALSE(m.Matches(non_null_p));
 }

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

Definition at line 1059 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::internal::IsNull(), and m.

                                   {
   Matcher<int*> m = IsNull();
   EXPECT_EQ("is NULL", Describe(m));
   EXPECT_EQ("isn't NULL", DescribeNegation(m));
 }

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

Definition at line 1066 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::NotNull().

                                          {
   Matcher<int*> m1 = NotNull();
   int* p1 = NULL;
   int n = 0;
   EXPECT_FALSE(m1.Matches(p1));
   EXPECT_TRUE(m1.Matches(&n));
 
   Matcher<const char*> m2 = NotNull();
   const char* p2 = NULL;
   EXPECT_FALSE(m2.Matches(p2));
   EXPECT_TRUE(m2.Matches("hi"));
 }

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

Definition at line 1079 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::NotNull().

                              {
   const Matcher<linked_ptr<int> > m = NotNull();
   const linked_ptr<int> null_p;
   const linked_ptr<int> non_null_p(new int);
 
   EXPECT_FALSE(m.Matches(null_p));
   EXPECT_TRUE(m.Matches(non_null_p));
 }

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

Definition at line 1088 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::NotNull(), and testing::internal::TEST().

                                              {
   const Matcher<const linked_ptr<double>&> m = NotNull();
   const linked_ptr<double> null_p;
   const linked_ptr<double> non_null_p(new double);
 
   EXPECT_FALSE(m.Matches(null_p));
   EXPECT_TRUE(m.Matches(non_null_p));
 }

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

Definition at line 1107 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::NotNull().

                                    {
   Matcher<int*> m = NotNull();
   EXPECT_EQ("isn't NULL", Describe(m));
 }

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

Definition at line 1114 of file gmock-matchers_test.cc.

References a, b, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Ref().

                                    {
   int a = 0;
   int b = 0;
   Matcher<int&> m = Ref(a);
   EXPECT_TRUE(m.Matches(a));
   EXPECT_FALSE(m.Matches(b));
 }

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

Definition at line 1123 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::Ref().

                                {
   int n = 5;
   Matcher<int&> m = Ref(n);
   stringstream ss;
   ss << "references the variable @" << &n << " 5";
   EXPECT_EQ(string(ss.str()), Describe(m));
 }

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

Definition at line 1133 of file gmock-matchers_test.cc.

References a, b, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Ref().

                                                    {
   int a = 0;
   int b = 0;
   Matcher<const int&> m = Ref(a);
   EXPECT_TRUE(m.Matches(a));
   EXPECT_FALSE(m.Matches(b));
 }

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

Definition at line 1145 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::Ref().

                            {
   Base base, base2;
   Derived derived;
   Matcher<const Base&> m1 = Ref(base);
   EXPECT_TRUE(m1.Matches(base));
   EXPECT_FALSE(m1.Matches(base2));
   EXPECT_FALSE(m1.Matches(derived));
 
   m1 = Ref(derived);
   EXPECT_TRUE(m1.Matches(derived));
   EXPECT_FALSE(m1.Matches(base));
   EXPECT_FALSE(m1.Matches(base2));
 }

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

Definition at line 1159 of file gmock-matchers_test.cc.

References EXPECT_THAT, Explain(), m, testing::Ref(), and testing::StartsWith().

                               {
   int n = 0;
   EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
               StartsWith("which is located @"));
 
   int m = 0;
   EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
               StartsWith("which is located @"));
 }

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

Definition at line 1171 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::StrEq().

                                     {
   Matcher<const char*> m = StrEq(string("Hello"));
   EXPECT_TRUE(m.Matches("Hello"));
   EXPECT_FALSE(m.Matches("hello"));
   EXPECT_FALSE(m.Matches(NULL));
 
   Matcher<const string&> m2 = StrEq("Hello");
   EXPECT_TRUE(m2.Matches("Hello"));
   EXPECT_FALSE(m2.Matches("Hi"));
 }

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

Definition at line 1182 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::StrEq().

                                  {
   Matcher<string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
   EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
       Describe(m));
 
   string str("01204500800");
   str[3] = '\0';
   Matcher<string> m2 = StrEq(str);
   EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
   str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
   Matcher<string> m3 = StrEq(str);
   EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
 }

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

Definition at line 1196 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::StrNe().

                                       {
   Matcher<const char*> m = StrNe("Hello");
   EXPECT_TRUE(m.Matches(""));
   EXPECT_TRUE(m.Matches(NULL));
   EXPECT_FALSE(m.Matches("Hello"));
 
   Matcher<string> m2 = StrNe(string("Hello"));
   EXPECT_TRUE(m2.Matches("hello"));
   EXPECT_FALSE(m2.Matches("Hello"));
 }

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

Definition at line 1207 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::StrNe().

                                  {
   Matcher<const char*> m = StrNe("Hi");
   EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
 }

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

Definition at line 1212 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::StrCaseEq().

                                                     {
   Matcher<const char*> m = StrCaseEq(string("Hello"));
   EXPECT_TRUE(m.Matches("Hello"));
   EXPECT_TRUE(m.Matches("hello"));
   EXPECT_FALSE(m.Matches("Hi"));
   EXPECT_FALSE(m.Matches(NULL));
 
   Matcher<const string&> m2 = StrCaseEq("Hello");
   EXPECT_TRUE(m2.Matches("hello"));
   EXPECT_FALSE(m2.Matches("Hi"));
 }

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

Definition at line 1224 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::StrCaseEq().

                                                          {
   string str1("oabocdooeoo");
   string str2("OABOCDOOEOO");
   Matcher<const string&> m0 = StrCaseEq(str1);
   EXPECT_FALSE(m0.Matches(str2 + string(1, '\0')));
 
   str1[3] = str2[3] = '\0';
   Matcher<const string&> m1 = StrCaseEq(str1);
   EXPECT_TRUE(m1.Matches(str2));
 
   str1[0] = str1[6] = str1[7] = str1[10] = '\0';
   str2[0] = str2[6] = str2[7] = str2[10] = '\0';
   Matcher<const string&> m2 = StrCaseEq(str1);
   str1[9] = str2[9] = '\0';
   EXPECT_FALSE(m2.Matches(str2));
 
   Matcher<const string&> m3 = StrCaseEq(str1);
   EXPECT_TRUE(m3.Matches(str2));
 
   EXPECT_FALSE(m3.Matches(str2 + "x"));
   str2.append(1, '\0');
   EXPECT_FALSE(m3.Matches(str2));
   EXPECT_FALSE(m3.Matches(string(str2, 0, 9)));
 }

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

Definition at line 1249 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::StrCaseEq().

                                      {
   Matcher<string> m = StrCaseEq("Hi");
   EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
 }

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

Definition at line 1254 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::StrCaseNe().

                                                       {
   Matcher<const char*> m = StrCaseNe("Hello");
   EXPECT_TRUE(m.Matches("Hi"));
   EXPECT_TRUE(m.Matches(NULL));
   EXPECT_FALSE(m.Matches("Hello"));
   EXPECT_FALSE(m.Matches("hello"));
 
   Matcher<string> m2 = StrCaseNe(string("Hello"));
   EXPECT_TRUE(m2.Matches(""));
   EXPECT_FALSE(m2.Matches("Hello"));
 }

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

Definition at line 1266 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::StrCaseNe().

                                      {
   Matcher<const char*> m = StrCaseNe("Hi");
   EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
 }

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

Definition at line 1272 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::HasSubstr(), testing::internal::MatcherBase< T >::Matches(), and string.

                                            {
   const Matcher<string> m1 = HasSubstr("foo");
   EXPECT_TRUE(m1.Matches(string("I love food.")));
   EXPECT_FALSE(m1.Matches(string("tofo")));
 
   const Matcher<const std::string&> m2 = HasSubstr("foo");
   EXPECT_TRUE(m2.Matches(std::string("I love food.")));
   EXPECT_FALSE(m2.Matches(std::string("tofo")));
 }

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

Definition at line 1283 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::HasSubstr(), and testing::internal::MatcherBase< T >::Matches().

                                       {
   const Matcher<char*> m1 = HasSubstr("foo");
   EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
   EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
   EXPECT_FALSE(m1.Matches(NULL));
 
   const Matcher<const char*> m2 = HasSubstr("foo");
   EXPECT_TRUE(m2.Matches("I love food."));
   EXPECT_FALSE(m2.Matches("tofo"));
   EXPECT_FALSE(m2.Matches(NULL));
 }

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

Definition at line 1296 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::HasSubstr(), and m.

                                      {
   Matcher<string> m = HasSubstr("foo\n\"");
   EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
 }

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

Definition at line 1301 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Key(), and m.

                                {
   Matcher<const pair<std::string, int>&> m = Key("foo");
   EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
   EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
 }

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

Definition at line 1307 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), GreaterThan(), testing::Key(), and m.

                               {
   Matcher<pair<int, bool> > m = Key(GreaterThan(10));
   EXPECT_EQ("whose first field is a value which is 5 less than 10",
             Explain(m, make_pair(5, true)));
   EXPECT_EQ("whose first field is a value which is 5 more than 10",
             Explain(m, make_pair(15, true)));
 }

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

Definition at line 1315 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Ge(), testing::Key(), testing::Lt(), and testing::Not().

                                 {
   pair<int, std::string> p(25, "foo");
   EXPECT_THAT(p, Key(25));
   EXPECT_THAT(p, Not(Key(42)));
   EXPECT_THAT(p, Key(Ge(20)));
   EXPECT_THAT(p, Not(Key(Lt(25))));
 }

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

Definition at line 1323 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Gt(), folly::is_negative(), folly::is_positive(), testing::Key(), testing::Lt(), and testing::Not().

                                        {
   Matcher<int> is_positive = Gt(0);
   Matcher<int> is_negative = Lt(0);
   pair<char, bool> p('a', true);
   EXPECT_THAT(p, Key(is_positive));
   EXPECT_THAT(p, Not(Key(is_negative)));
 }

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

Definition at line 1331 of file gmock-matchers_test.cc.

References testing::Contains(), EXPECT_THAT, testing::Key(), and testing::Not().

                                       {
   map<int, char> container;
   container.insert(make_pair(1, 'a'));
   container.insert(make_pair(2, 'b'));
   container.insert(make_pair(4, 'c'));
   EXPECT_THAT(container, Contains(Key(1)));
   EXPECT_THAT(container, Not(Contains(Key(3))));
 }

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

Definition at line 1340 of file gmock-matchers_test.cc.

References testing::Contains(), EXPECT_THAT, testing::Key(), and testing::Not().

                                            {
   multimap<int, char> container;
   container.insert(make_pair(1, 'a'));
   container.insert(make_pair(2, 'b'));
   container.insert(make_pair(4, 'c'));
 
   EXPECT_THAT(container, Not(Contains(Key(25))));
   container.insert(make_pair(25, 'd'));
   EXPECT_THAT(container, Contains(Key(25)));
   container.insert(make_pair(25, 'e'));
   EXPECT_THAT(container, Contains(Key(25)));
 
   EXPECT_THAT(container, Contains(Key(1)));
   EXPECT_THAT(container, Not(Contains(Key(3))));
 }

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

Definition at line 1356 of file gmock-matchers_test.cc.

References testing::Pair().

                        {
   // Test verifies the following type conversions can be compiled.
   Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
   Matcher<const pair<const char*, int> > m2 = Pair("foo", 42);
   Matcher<pair<const char*, int> > m3 = Pair("foo", 42);
 
   Matcher<pair<int, const std::string> > m4 = Pair(25, "42");
   Matcher<pair<const std::string, int> > m5 = Pair("25", 42);
 }

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

Definition at line 1366 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Not(), and testing::Pair().

                                 {
   Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
   EXPECT_EQ("has a first field that is equal to \"foo\""
             ", and has a second field that is equal to 42",
             Describe(m1));
   EXPECT_EQ("has a first field that isn't equal to \"foo\""
             ", or has a second field that isn't equal to 42",
             DescribeNegation(m1));
   // Double and triple negation (1 or 2 times not and description of negation).
   Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
   EXPECT_EQ("has a first field that isn't equal to 13"
             ", and has a second field that is equal to 42",
             DescribeNegation(m2));
 }

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

Definition at line 1381 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), GreaterThan(), m, and testing::Pair().

                                         {
   // If neither field matches, Pair() should explain about the first
   // field.
   const Matcher<pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
   EXPECT_EQ("whose first field does not match, which is 1 less than 0",
             Explain(m, make_pair(-1, -2)));
 
   // If the first field matches but the second doesn't, Pair() should
   // explain about the second field.
   EXPECT_EQ("whose second field does not match, which is 2 less than 0",
             Explain(m, make_pair(1, -2)));
 
   // If the first field doesn't match but the second does, Pair()
   // should explain about the first field.
   EXPECT_EQ("whose first field does not match, which is 1 less than 0",
             Explain(m, make_pair(-1, 2)));
 
   // If both fields match, Pair() should explain about them both.
   EXPECT_EQ("whose both fields match, where the first field is a value "
             "which is 1 more than 0, and the second field is a value "
             "which is 2 more than 0",
             Explain(m, make_pair(1, 2)));
 
   // If only the first match has an explanation, only this explanation should
   // be printed.
   const Matcher<pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
   EXPECT_EQ("whose both fields match, where the first field is a value "
             "which is 1 more than 0",
             Explain(explain_first, make_pair(1, 0)));
 
   // If only the second match has an explanation, only this explanation should
   // be printed.
   const Matcher<pair<int, int> > explain_second = Pair(0, GreaterThan(0));
   EXPECT_EQ("whose both fields match, where the second field is a value "
             "which is 1 more than 0",
             Explain(explain_second, make_pair(0, 1)));
 }

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

Definition at line 1419 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Ge(), testing::HasSubstr(), testing::Lt(), testing::Not(), and testing::Pair().

                                  {
   pair<int, std::string> p(25, "foo");
 
   // Both fields match.
   EXPECT_THAT(p, Pair(25, "foo"));
   EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
 
   // 'first' doesnt' match, but 'second' matches.
   EXPECT_THAT(p, Not(Pair(42, "foo")));
   EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
 
   // 'first' matches, but 'second' doesn't match.
   EXPECT_THAT(p, Not(Pair(25, "bar")));
   EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
 
   // Neither field matches.
   EXPECT_THAT(p, Not(Pair(13, "bar")));
   EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
 }

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

Definition at line 1439 of file gmock-matchers_test.cc.

References testing::_, EXPECT_THAT, testing::Gt(), folly::is_negative(), folly::is_positive(), testing::Lt(), testing::Not(), and testing::Pair().

                                          {
   Matcher<int> is_positive = Gt(0);
   Matcher<int> is_negative = Lt(0);
   pair<char, bool> p('a', true);
   EXPECT_THAT(p, Pair(is_positive, _));
   EXPECT_THAT(p, Not(Pair(is_negative, _)));
   EXPECT_THAT(p, Pair(_, is_positive));
   EXPECT_THAT(p, Not(Pair(_, is_negative)));
 }

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

Definition at line 1449 of file gmock-matchers_test.cc.

References testing::_, testing::Contains(), EXPECT_THAT, testing::Not(), and testing::Pair().

                                        {
   map<int, char> container;
   container.insert(make_pair(1, 'a'));
   container.insert(make_pair(2, 'b'));
   container.insert(make_pair(4, 'c'));
   EXPECT_THAT(container, Contains(Pair(1, 'a')));
   EXPECT_THAT(container, Contains(Pair(1, _)));
   EXPECT_THAT(container, Contains(Pair(_, 'a')));
   EXPECT_THAT(container, Not(Contains(Pair(3, _))));
 }

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

Definition at line 1462 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::StartsWith().

                                                    {
   const Matcher<const char*> m1 = StartsWith(string(""));
   EXPECT_TRUE(m1.Matches("Hi"));
   EXPECT_TRUE(m1.Matches(""));
   EXPECT_FALSE(m1.Matches(NULL));
 
   const Matcher<const string&> m2 = StartsWith("Hi");
   EXPECT_TRUE(m2.Matches("Hi"));
   EXPECT_TRUE(m2.Matches("Hi Hi!"));
   EXPECT_TRUE(m2.Matches("High"));
   EXPECT_FALSE(m2.Matches("H"));
   EXPECT_FALSE(m2.Matches(" Hi"));
 }

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

Definition at line 1476 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::StartsWith().

                                       {
   Matcher<const std::string> m = StartsWith("Hi");
   EXPECT_EQ("starts with \"Hi\"", Describe(m));
 }

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

Definition at line 1483 of file gmock-matchers_test.cc.

References testing::EndsWith(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                  {
   const Matcher<const char*> m1 = EndsWith("");
   EXPECT_TRUE(m1.Matches("Hi"));
   EXPECT_TRUE(m1.Matches(""));
   EXPECT_FALSE(m1.Matches(NULL));
 
   const Matcher<const string&> m2 = EndsWith(string("Hi"));
   EXPECT_TRUE(m2.Matches("Hi"));
   EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
   EXPECT_TRUE(m2.Matches("Super Hi"));
   EXPECT_FALSE(m2.Matches("i"));
   EXPECT_FALSE(m2.Matches("Hi "));
 }

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

Definition at line 1497 of file gmock-matchers_test.cc.

References Describe(), testing::EndsWith(), EXPECT_EQ, and m.

                                     {
   Matcher<const std::string> m = EndsWith("Hi");
   EXPECT_EQ("ends with \"Hi\"", Describe(m));
 }

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

Definition at line 1504 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::MatchesRegex().

                                                         {
   const Matcher<const char*> m1 = MatchesRegex("a.*z");
   EXPECT_TRUE(m1.Matches("az"));
   EXPECT_TRUE(m1.Matches("abcz"));
   EXPECT_FALSE(m1.Matches(NULL));
 
   const Matcher<const string&> m2 = MatchesRegex(new RE("a.*z"));
   EXPECT_TRUE(m2.Matches("azbz"));
   EXPECT_FALSE(m2.Matches("az1"));
   EXPECT_FALSE(m2.Matches("1az"));
 }

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

Definition at line 1516 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, and testing::MatchesRegex().

                                         {
   Matcher<const std::string> m1 = MatchesRegex(string("Hi.*"));
   EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
 
   Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
   EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
 }

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

Definition at line 1526 of file gmock-matchers_test.cc.

References testing::ContainsRegex(), EXPECT_FALSE, EXPECT_TRUE, and testing::internal::MatcherBase< T >::Matches().

                                                            {
   const Matcher<const char*> m1 = ContainsRegex(string("a.*z"));
   EXPECT_TRUE(m1.Matches("az"));
   EXPECT_TRUE(m1.Matches("0abcz1"));
   EXPECT_FALSE(m1.Matches(NULL));
 
   const Matcher<const string&> m2 = ContainsRegex(new RE("a.*z"));
   EXPECT_TRUE(m2.Matches("azbz"));
   EXPECT_TRUE(m2.Matches("az1"));
   EXPECT_FALSE(m2.Matches("1a"));
 }

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

Definition at line 1538 of file gmock-matchers_test.cc.

References testing::ContainsRegex(), Describe(), testing::EndsWith(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::HasSubstr(), m, testing::internal::MatcherBase< T >::Matches(), testing::StartsWith(), testing::StrCaseEq(), testing::StrCaseNe(), testing::StrEq(), testing::StrNe(), and testing::internal::TEST().

                                          {
   Matcher<const std::string> m1 = ContainsRegex("Hi.*");
   EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
 
   Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
   EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
 }

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

Definition at line 1934 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                      {
   Matcher<const Tuple2&> m = Eq();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }

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

Definition at line 1941 of file gmock-matchers_test.cc.

References Describe(), testing::Eq(), EXPECT_EQ, and m.

                                {
   Matcher<const Tuple2&> m = Eq();
   EXPECT_EQ("are an equal pair", Describe(m));
 }

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

Definition at line 1948 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, and testing::internal::MatcherBase< T >::Matches().

                                                   {
   Matcher<const Tuple2&> m = Ge();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }

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

Definition at line 1956 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Ge(), and m.

                                {
   Matcher<const Tuple2&> m = Ge();
   EXPECT_EQ("are a pair where the first >= the second", Describe(m));
 }

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

Definition at line 1963 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Gt(), m, and testing::internal::MatcherBase< T >::Matches().

                                            {
   Matcher<const Tuple2&> m = Gt();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 6)));
 }

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

Definition at line 1971 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Gt(), and m.

                                {
   Matcher<const Tuple2&> m = Gt();
   EXPECT_EQ("are a pair where the first > the second", Describe(m));
 }

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

Definition at line 1978 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Le(), m, and testing::internal::MatcherBase< T >::Matches().

                                                {
   Matcher<const Tuple2&> m = Le();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
 }

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

Definition at line 1986 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Le(), and m.

                                {
   Matcher<const Tuple2&> m = Le();
   EXPECT_EQ("are a pair where the first <= the second", Describe(m));
 }

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

Definition at line 1993 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Lt(), m, and testing::internal::MatcherBase< T >::Matches().

                                         {
   Matcher<const Tuple2&> m = Lt();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 4)));
 }

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

Definition at line 2001 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, testing::Lt(), and m.

                                {
   Matcher<const Tuple2&> m = Lt();
   EXPECT_EQ("are a pair where the first < the second", Describe(m));
 }

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

Definition at line 2008 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Ne().

                                        {
   Matcher<const Tuple2&> m = Ne();
   EXPECT_TRUE(m.Matches(Tuple2(5L, 6)));
   EXPECT_TRUE(m.Matches(Tuple2(5L, 4)));
   EXPECT_FALSE(m.Matches(Tuple2(5L, 5)));
 }

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

Definition at line 2016 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, m, and testing::Ne().

                                {
   Matcher<const Tuple2&> m = Ne();
   EXPECT_EQ("are an unequal pair", Describe(m));
 }

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

Definition at line 2022 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Not().

                               {
   Matcher<int> m;
   m = Not(Eq(2));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
 }

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

Definition at line 2030 of file gmock-matchers_test.cc.

References Describe(), testing::Eq(), EXPECT_EQ, m, and testing::Not().

                                {
   Matcher<int> m = Not(Eq(5));
   EXPECT_EQ("isn't equal to 5", Describe(m));
 }

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

Definition at line 2036 of file gmock-matchers_test.cc.

References testing::Gt(), m, and testing::Not().

                                                         {
   // greater_than_5 is a monomorphic matcher.
   Matcher<int> greater_than_5 = Gt(5);
 
   Matcher<const int&> m = Not(greater_than_5);
   Matcher<int&> m2 = Not(greater_than_5);
   Matcher<int&> m3 = Not(m);
 }

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

Definition at line 2057 of file gmock-matchers_test.cc.

References testing::AllOf(), AllOfMatches(), Describe(), testing::EndsWith(), EXPECT_FALSE, EXPECT_THAT, EXPECT_TRUE, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), m, testing::internal::MatcherBase< T >::Matches(), testing::Ne(), and testing::internal::TEST().

                                      {
   Matcher<int> m;
   m = AllOf(Le(2), Ge(1));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_TRUE(m.Matches(2));
   EXPECT_FALSE(m.Matches(0));
   EXPECT_FALSE(m.Matches(3));
 
   m = AllOf(Gt(0), Ne(1), Ne(2));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
   EXPECT_FALSE(m.Matches(1));
   EXPECT_FALSE(m.Matches(0));
 
   m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
   EXPECT_TRUE(m.Matches(4));
   EXPECT_FALSE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
   EXPECT_FALSE(m.Matches(1));
   EXPECT_FALSE(m.Matches(0));
 
   m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
   EXPECT_TRUE(m.Matches(0));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_FALSE(m.Matches(3));
 
   // The following tests for varying number of sub-matchers. Due to the way
   // the sub-matchers are handled it is enough to test every sub-matcher once
   // with sub-matchers using the same matcher type. Varying matcher types are
   // checked for above.
   AllOfMatches(2, AllOf(Ne(1), Ne(2)));
   AllOfMatches(3, AllOf(Ne(1), Ne(2), Ne(3)));
   AllOfMatches(4, AllOf(Ne(1), Ne(2), Ne(3), Ne(4)));
   AllOfMatches(5, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5)));
   AllOfMatches(6, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6)));
   AllOfMatches(7, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7)));
   AllOfMatches(8, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
                         Ne(8)));
   AllOfMatches(9, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7),
                         Ne(8), Ne(9)));
   AllOfMatches(10, AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8),
                          Ne(9), Ne(10)));
 }

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

Definition at line 2124 of file gmock-matchers_test.cc.

References testing::AllOf(), Describe(), EXPECT_EQ, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), m, and testing::Ne().

                                  {
   Matcher<int> m;
   m = AllOf(Le(2), Ge(1));
   EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
 
   m = AllOf(Gt(0), Ne(1), Ne(2));
   EXPECT_EQ("(is > 0) and "
             "((isn't equal to 1) and "
             "(isn't equal to 2))",
             Describe(m));
 
 
   m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
   EXPECT_EQ("((is > 0) and "
             "(isn't equal to 1)) and "
             "((isn't equal to 2) and "
             "(isn't equal to 3))",
             Describe(m));
 
 
   m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
   EXPECT_EQ("((is >= 0) and "
             "(is < 10)) and "
             "((isn't equal to 3) and "
             "((isn't equal to 5) and "
             "(isn't equal to 7)))",
             Describe(m));
 }

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

Definition at line 2154 of file gmock-matchers_test.cc.

References testing::AllOf(), DescribeNegation(), EXPECT_EQ, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), m, and testing::Ne().

                                      {
   Matcher<int> m;
   m = AllOf(Le(2), Ge(1));
   EXPECT_EQ("(isn't <= 2) or "
             "(isn't >= 1)",
             DescribeNegation(m));
 
   m = AllOf(Gt(0), Ne(1), Ne(2));
   EXPECT_EQ("(isn't > 0) or "
             "((is equal to 1) or "
             "(is equal to 2))",
             DescribeNegation(m));
 
 
   m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
   EXPECT_EQ("((isn't > 0) or "
             "(is equal to 1)) or "
             "((is equal to 2) or "
             "(is equal to 3))",
             DescribeNegation(m));
 
 
   m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
   EXPECT_EQ("((isn't >= 0) or "
             "(isn't < 10)) or "
             "((is equal to 3) or "
             "((is equal to 5) or "
             "(is equal to 7)))",
             DescribeNegation(m));
 }

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

Definition at line 2186 of file gmock-matchers_test.cc.

References testing::AllOf(), testing::Gt(), testing::Lt(), and m.

                                                             {
   // greater_than_5 and less_than_10 are monomorphic matchers.
   Matcher<int> greater_than_5 = Gt(5);
   Matcher<int> less_than_10 = Lt(10);
 
   Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
   Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
   Matcher<int&> m3 = AllOf(greater_than_5, m2);
 
   // Tests that BothOf works when composing itself.
   Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
   Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
 }

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

Definition at line 2200 of file gmock-matchers_test.cc.

References testing::AllOf(), EXPECT_EQ, Explain(), GreaterThan(), testing::Lt(), and m.

                                 {
   Matcher<int> m;
 
   // Successful match.  Both matchers need to explain.  The second
   // matcher doesn't give an explanation, so only the first matcher's
   // explanation is printed.
   m = AllOf(GreaterThan(10), Lt(30));
   EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
 
   // Successful match.  Both matchers need to explain.
   m = AllOf(GreaterThan(10), GreaterThan(20));
   EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
             Explain(m, 30));
 
   // Successful match.  All matchers need to explain.  The second
   // matcher doesn't given an explanation.
   m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
   EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
             Explain(m, 25));
 
   // Successful match.  All matchers need to explain.
   m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
   EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
             "and which is 10 more than 30",
             Explain(m, 40));
 
   // Failed match.  The first matcher, which failed, needs to
   // explain.
   m = AllOf(GreaterThan(10), GreaterThan(20));
   EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
 
   // Failed match.  The second matcher, which failed, needs to
   // explain.  Since it doesn't given an explanation, nothing is
   // printed.
   m = AllOf(GreaterThan(10), Lt(30));
   EXPECT_EQ("", Explain(m, 40));
 
   // Failed match.  The second matcher, which failed, needs to
   // explain.
   m = AllOf(GreaterThan(10), GreaterThan(20));
   EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
 }

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

Definition at line 2255 of file gmock-matchers_test.cc.

References testing::AnyOf(), AnyOfMatches(), Describe(), testing::EndsWith(), testing::Eq(), EXPECT_FALSE, EXPECT_THAT, EXPECT_TRUE, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), m, testing::internal::MatcherBase< T >::Matches(), and testing::internal::TEST().

                                        {
   Matcher<int> m;
   m = AnyOf(Le(1), Ge(3));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_TRUE(m.Matches(4));
   EXPECT_FALSE(m.Matches(2));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2));
   EXPECT_TRUE(m.Matches(-1));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_TRUE(m.Matches(2));
   EXPECT_FALSE(m.Matches(0));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
   EXPECT_TRUE(m.Matches(-1));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_TRUE(m.Matches(2));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(0));
 
   m = AnyOf(Le(0), Gt(10), 3, 5, 7);
   EXPECT_TRUE(m.Matches(0));
   EXPECT_TRUE(m.Matches(11));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
 
   // The following tests for varying number of sub-matchers. Due to the way
   // the sub-matchers are handled it is enough to test every sub-matcher once
   // with sub-matchers using the same matcher type. Varying matcher types are
   // checked for above.
   AnyOfMatches(2, AnyOf(1, 2));
   AnyOfMatches(3, AnyOf(1, 2, 3));
   AnyOfMatches(4, AnyOf(1, 2, 3, 4));
   AnyOfMatches(5, AnyOf(1, 2, 3, 4, 5));
   AnyOfMatches(6, AnyOf(1, 2, 3, 4, 5, 6));
   AnyOfMatches(7, AnyOf(1, 2, 3, 4, 5, 6, 7));
   AnyOfMatches(8, AnyOf(1, 2, 3, 4, 5, 6, 7, 8));
   AnyOfMatches(9, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9));
   AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
 }

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

Definition at line 2315 of file gmock-matchers_test.cc.

References testing::AnyOf(), Describe(), testing::Eq(), EXPECT_EQ, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), and m.

                                  {
   Matcher<int> m;
   m = AnyOf(Le(1), Ge(3));
   EXPECT_EQ("(is <= 1) or (is >= 3)",
             Describe(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2));
   EXPECT_EQ("(is < 0) or "
             "((is equal to 1) or (is equal to 2))",
             Describe(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
   EXPECT_EQ("((is < 0) or "
             "(is equal to 1)) or "
             "((is equal to 2) or "
             "(is equal to 3))",
             Describe(m));
 
   m = AnyOf(Le(0), Gt(10), 3, 5, 7);
   EXPECT_EQ("((is <= 0) or "
             "(is > 10)) or "
             "((is equal to 3) or "
             "((is equal to 5) or "
             "(is equal to 7)))",
             Describe(m));
 }

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

Definition at line 2343 of file gmock-matchers_test.cc.

References testing::AnyOf(), DescribeNegation(), testing::Eq(), EXPECT_EQ, testing::Ge(), testing::Gt(), testing::Le(), testing::Lt(), and m.

                                      {
   Matcher<int> m;
   m = AnyOf(Le(1), Ge(3));
   EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
             DescribeNegation(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2));
   EXPECT_EQ("(isn't < 0) and "
             "((isn't equal to 1) and (isn't equal to 2))",
             DescribeNegation(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
   EXPECT_EQ("((isn't < 0) and "
             "(isn't equal to 1)) and "
             "((isn't equal to 2) and "
             "(isn't equal to 3))",
             DescribeNegation(m));
 
   m = AnyOf(Le(0), Gt(10), 3, 5, 7);
   EXPECT_EQ("((isn't <= 0) and "
             "(isn't > 10)) and "
             "((isn't equal to 3) and "
             "((isn't equal to 5) and "
             "(isn't equal to 7)))",
             DescribeNegation(m));
 }

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

Definition at line 2371 of file gmock-matchers_test.cc.

References testing::AnyOf(), testing::Gt(), testing::Lt(), and m.

                                                             {
   // greater_than_5 and less_than_10 are monomorphic matchers.
   Matcher<int> greater_than_5 = Gt(5);
   Matcher<int> less_than_10 = Lt(10);
 
   Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
   Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
   Matcher<int&> m3 = AnyOf(greater_than_5, m2);
 
   // Tests that EitherOf works when composing itself.
   Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
   Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
 }

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

Definition at line 2385 of file gmock-matchers_test.cc.

References testing::AnyOf(), EXPECT_EQ, Explain(), GreaterThan(), testing::Gt(), testing::Lt(), and m.

                                 {
   Matcher<int> m;
 
   // Failed match.  Both matchers need to explain.  The second
   // matcher doesn't give an explanation, so only the first matcher's
   // explanation is printed.
   m = AnyOf(GreaterThan(10), Lt(0));
   EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
 
   // Failed match.  Both matchers need to explain.
   m = AnyOf(GreaterThan(10), GreaterThan(20));
   EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
             Explain(m, 5));
 
   // Failed match.  All matchers need to explain.  The second
   // matcher doesn't given an explanation.
   m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
   EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
             Explain(m, 5));
 
   // Failed match.  All matchers need to explain.
   m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
   EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
             "and which is 25 less than 30",
             Explain(m, 5));
 
   // Successful match.  The first matcher, which succeeded, needs to
   // explain.
   m = AnyOf(GreaterThan(10), GreaterThan(20));
   EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
 
   // Successful match.  The second matcher, which succeeded, needs to
   // explain.  Since it doesn't given an explanation, nothing is
   // printed.
   m = AnyOf(GreaterThan(10), Lt(30));
   EXPECT_EQ("", Explain(m, 0));
 
   // Successful match.  The second matcher, which succeeded, needs to
   // explain.
   m = AnyOf(GreaterThan(30), GreaterThan(20));
   EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
 }

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

Definition at line 2462 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, IsPositive(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Truly().

                                                   {
   Matcher<double> m = Truly(IsPositive);
   EXPECT_TRUE(m.Matches(2.0));
   EXPECT_FALSE(m.Matches(-1.5));
 }

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

Definition at line 2469 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Truly().

                                       {
   Matcher<int> m = Truly(IsGreaterThan(5));
   EXPECT_TRUE(m.Matches(6));
   EXPECT_FALSE(m.Matches(4));
 }

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

Definition at line 2492 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, IsNotZero(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Truly().

                                                            {
   Matcher<int> m = Truly(IsNotZero);
   EXPECT_TRUE(m.Matches(1));
   EXPECT_FALSE(m.Matches(0));
 }

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

Definition at line 2499 of file gmock-matchers_test.cc.

References Describe(), EXPECT_EQ, IsPositive(), m, and testing::Truly().

                                  {
   Matcher<double> m = Truly(IsPositive);
   EXPECT_EQ("satisfies the given predicate",
             Describe(m));
 }

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

Definition at line 2507 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), ReferencesFooAndIsZero(), and testing::Truly().

                                         {
   Matcher<const int&> m = Truly(ReferencesFooAndIsZero);
   EXPECT_TRUE(m.Matches(foo));
   int n = 0;
   EXPECT_FALSE(m.Matches(n));
 }

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

Definition at line 2516 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), and testing::Matches().

                                                       {
   EXPECT_TRUE(Matches(Ge(0))(1));
   EXPECT_FALSE(Matches(Eq('a'))('b'));
 }

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

Definition at line 2523 of file gmock-matchers_test.cc.

References testing::AllOf(), testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, testing::Matches(), and testing::Ref().

                                          {
   int m = 0, n = 0;
   EXPECT_TRUE(Matches(AllOf(Ref(n), Eq(0)))(n));
   EXPECT_FALSE(Matches(Ref(m))(n));
 }

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

Definition at line 2531 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, and testing::Matches().

                                                 {
   Matcher<int> eq5 = Eq(5);
   EXPECT_TRUE(Matches(eq5)(5));
   EXPECT_FALSE(Matches(eq5)(2));
 }

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

Definition at line 2540 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Gt(), testing::StartsWith(), and testing::Value().

                                              {
   EXPECT_TRUE(Value("hi", StartsWith("h")));
   EXPECT_FALSE(Value(5, Gt(10)));
 }

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

Definition at line 2545 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, testing::Ref(), and testing::Value().

                                              {
   const Matcher<int> is_zero = Eq(0);
   EXPECT_TRUE(Value(0, is_zero));
   EXPECT_FALSE(Value('a', is_zero));
 
   int n = 0;
   const Matcher<const int&> ref_n = Ref(n);
   EXPECT_TRUE(Value(n, ref_n));
   EXPECT_FALSE(Value(1, ref_n));
 }

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

Definition at line 2556 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::ExplainMatchResult(), testing::Ge(), PolymorphicIsEven(), and testing::StringMatchResultListener::str().

                                                           {
   StringMatchResultListener listener1;
   EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
   EXPECT_EQ("% 2 == 0", listener1.str());
 
   StringMatchResultListener listener2;
   EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
   EXPECT_EQ("", listener2.str());
 }

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

Definition at line 2566 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, testing::ExplainMatchResult(), PolymorphicIsEven(), and testing::StringMatchResultListener::str().

                                                           {
   const Matcher<int> is_even = PolymorphicIsEven();
   StringMatchResultListener listener1;
   EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
   EXPECT_EQ("% 2 == 0", listener1.str());
 
   const Matcher<const double&> is_zero = Eq(0);
   StringMatchResultListener listener2;
   EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
   EXPECT_EQ("", listener2.str());
 }

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

Definition at line 2582 of file gmock-matchers_test.cc.

References testing::Eq(), and EXPECT_THAT.

                                                  {
   EXPECT_THAT(0, Really(Eq(0)));
 }

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

Definition at line 2586 of file gmock-matchers_test.cc.

References testing::AllArgs(), EXPECT_THAT, testing::Lt(), std::tr1::make_tuple(), and testing::Not().

                                  {
   EXPECT_THAT(make_tuple(1, 2L), AllArgs(Lt()));
   EXPECT_THAT(make_tuple(2L, 1), Not(AllArgs(Lt())));
 }

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

Definition at line 2591 of file gmock-matchers_test.cc.

References testing::AllArgs(), testing::Eq(), EXPECT_THAT, testing::Gt(), and testing::Not().

                                     {
   EXPECT_THAT(42, AllArgs(Gt(0)));
   EXPECT_THAT('a', Not(AllArgs(Eq('b'))));
 }

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

Definition at line 2606 of file gmock-matchers_test.cc.

References testing::_, testing::AllArgs(), EXPECT_CALL, EXPECT_EQ, testing::Gt(), testing::Lt(), ON_CALL, and testing::Return().

                                      {
   AllArgsHelper helper;
   ON_CALL(helper, Helper(_, _))
       .With(AllArgs(Lt()))
       .WillByDefault(Return(1));
   EXPECT_CALL(helper, Helper(_, _));
   EXPECT_CALL(helper, Helper(_, _))
       .With(AllArgs(Gt()))
       .WillOnce(Return(2));
 
   EXPECT_EQ(1, helper.Helper('\1', 2));
   EXPECT_EQ(2, helper.Helper('a', 1));
 }

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

Definition at line 2622 of file gmock-matchers_test.cc.

References testing::AllOf(), ASSERT_THAT, testing::EndsWith(), EXPECT_THAT, testing::Ge(), testing::Le(), and testing::StartsWith().

                                                         {
   ASSERT_THAT(5, Ge(2)) << "This should succeed.";
   ASSERT_THAT("Foo", EndsWith("oo"));
   EXPECT_THAT(2, AllOf(Le(7), Ge(0))) << "This should succeed too.";
   EXPECT_THAT("Hello", StartsWith("Hell"));
 }

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

Definition at line 2631 of file gmock-matchers_test.cc.

References testing::AllOf(), ASSERT_THAT, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, EXPECT_THAT, testing::Ge(), testing::Gt(), testing::Le(), and OfType().

                                                            {
   // 'n' must be static as it is used in an EXPECT_FATAL_FAILURE(),
   // which cannot reference auto variables.
   static unsigned short n;  // NOLINT
   n = 5;
 
   // VC++ prior to version 8.0 SP1 has a bug where it will not see any
   // functions declared in the namespace scope from within nested classes.
   // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
   // namespace-level functions invoked inside them need to be explicitly
   // resolved.
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)),
                        "Value of: n\n"
                        "Expected: is > 10\n"
                        "  Actual: 5" + OfType("unsigned short"));
   n = 0;
   EXPECT_NONFATAL_FAILURE(
       EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
       "Value of: n\n"
       "Expected: (is <= 7) and (is >= 5)\n"
       "  Actual: 0" + OfType("unsigned short"));
 }

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

Definition at line 2656 of file gmock-matchers_test.cc.

References testing::AllOf(), ASSERT_THAT, EXPECT_FATAL_FAILURE, EXPECT_THAT, testing::Le(), testing::Not(), OfType(), and testing::Ref().

                                                    {
   // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
   // reference auto variables.
   static int n;
   n = 0;
   EXPECT_THAT(n, AllOf(Le(7), Ref(n)));
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
                        "Value of: n\n"
                        "Expected: does not reference the variable @");
   // Tests the "Actual" part.
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
                        "Actual: 0" + OfType("int") + ", which is located @");
 }

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

Definition at line 2684 of file gmock-matchers_test.cc.

References ASSERT_THAT, testing::EndsWith(), EXPECT_NONFATAL_FAILURE, EXPECT_THAT, testing::Gt(), OfType(), and testing::StartsWith().

                                                        {
   Matcher<const char*> starts_with_he = StartsWith("he");
   ASSERT_THAT("hello", starts_with_he);
 
   Matcher<const string&> ends_with_ok = EndsWith("ok");
   ASSERT_THAT("book", ends_with_ok);
   const string bad = "bad";
   EXPECT_NONFATAL_FAILURE(EXPECT_THAT(bad, ends_with_ok),
                           "Value of: bad\n"
                           "Expected: ends with \"ok\"\n"
                           "  Actual: \"bad\"");
   Matcher<int> is_greater_than_5 = Gt(5);
   EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
                           "Value of: 5\n"
                           "Expected: is > 5\n"
                           "  Actual: 5" + OfType("int"));
 }

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

Definition at line 3142 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                               {
   const Matcher<int*> m = Pointee(Ge(0));
 
   int n = 1;
   EXPECT_TRUE(m.Matches(&n));
   n = -1;
   EXPECT_FALSE(m.Matches(&n));
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3152 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                      {
   const Matcher<const double*> m = Pointee(Ge(0));
 
   double x = 1;
   EXPECT_TRUE(m.Matches(&x));
   x = -1;
   EXPECT_FALSE(m.Matches(&x));
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3162 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                               {
   const Matcher<int* const &> m = Pointee(Ge(0));
 
   int n = 1;
   EXPECT_TRUE(m.Matches(&n));
   n = -1;
   EXPECT_FALSE(m.Matches(&n));
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3172 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Pointee(), and x.

                                                  {
   const Matcher<double* &> m = Pointee(Ge(0));
 
   double x = 1.0;
   double* p = &x;
   EXPECT_TRUE(m.Matches(p));
   x = -1;
   EXPECT_FALSE(m.Matches(p));
   p = NULL;
   EXPECT_FALSE(m.Matches(p));
 }

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

Definition at line 3304 of file gmock-matchers_test.cc.

References GCC61971::co, EXPECT_FALSE, EXPECT_TRUE, testing::Lt(), m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                                      {
   const Matcher< ConstPropagatingPtr<int> > m = Pointee(Lt(5));
   int three = 3;
   const ConstPropagatingPtr<int> co(&three);
   ConstPropagatingPtr<int> o(&three);
   EXPECT_TRUE(m.Matches(o));
   EXPECT_TRUE(m.Matches(co));
   *o = 6;
   EXPECT_FALSE(m.Matches(o));
   EXPECT_FALSE(m.Matches(ConstPropagatingPtr<int>()));
 }

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

Definition at line 3316 of file gmock-matchers_test.cc.

References testing::_, EXPECT_FALSE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                     {
   const Matcher<const char*> m = Pointee(_);
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3322 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::Pointee().

                                         {
   const Matcher<int*> m = Pointee(5);
 
   int n = 5;
   EXPECT_TRUE(m.Matches(&n));
   n = -1;
   EXPECT_FALSE(m.Matches(&n));
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3332 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Gt(), m, and testing::Pointee().

                                    {
   const Matcher<int*> m = Pointee(Gt(3));
   EXPECT_EQ("points to a value that is > 3", Describe(m));
   EXPECT_EQ("does not point to a value that is > 3",
             DescribeNegation(m));
 }

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

Definition at line 3339 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), GreaterThan(), m, OfType(), testing::Pointee(), and testing::StartsWith().

                                          {
   const Matcher<const string*> m = Pointee(StartsWith("Hi"));
 
   EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL)));
 
   const Matcher<long*> m2 = Pointee(GreaterThan(1));  // NOLINT
   long n = 3;  // NOLINT
   EXPECT_EQ("which points to 3" + OfType("long") + ", which is 2 more than 1",
             Explain(m2, &n));
 }

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

Definition at line 3350 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), m, OfType(), and testing::Pointee().

                                          {
   const Matcher<int*> m = Pointee(0);
   int n = 42;
   EXPECT_EQ("which points to 42" + OfType("int"), Explain(m, &n));
 }

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

Definition at line 3401 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                        {
   Matcher<AStruct> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3411 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), testing::Le(), m, and testing::internal::MatcherBase< T >::Matches().

                                     {
   AStruct a;
 
   Matcher<AStruct> m = Field(&AStruct::y, Ge(0.0));
   EXPECT_TRUE(m.Matches(a));
   m = Field(&AStruct::y, Le(0.0));
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3421 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), m, testing::internal::MatcherBase< T >::Matches(), testing::Not(), testing::Truly(), and ValueIsPositive().

                                          {
   AStruct a;
 
   Matcher<AStruct> m = Field(&AStruct::z, Truly(ValueIsPositive));
   EXPECT_TRUE(m.Matches(a));
   m = Field(&AStruct::z, Not(Truly(ValueIsPositive)));
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3431 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), m, testing::internal::MatcherBase< T >::Matches(), testing::gmock_matchers_test::AStruct::p, and testing::StartsWith().

                                       {
   // Matching against NULL.
   Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL));
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
   a.p = "hi";
   EXPECT_FALSE(m.Matches(a));
 
   // Matching a pointer that is not NULL.
   m = Field(&AStruct::p, StartsWith("hi"));
   a.p = "hill";
   EXPECT_TRUE(m.Matches(a));
   a.p = "hole";
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3448 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                        {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3459 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                            {
   // Note that the matcher expects DerivedStruct but we say AStruct
   // inside Field().
   Matcher<const DerivedStruct&> m = Field(&AStruct::x, Ge(0));
 
   DerivedStruct d;
   EXPECT_TRUE(m.Matches(d));
   d.x = -1;
   EXPECT_FALSE(m.Matches(d));
 }

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

Definition at line 3472 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                                {
   // The field is an int, but the inner matcher expects a signed char.
   Matcher<const AStruct&> m = Field(&AStruct::x,
                                     Matcher<signed char>(Ge(0)));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3484 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Field(), testing::Ge(), m, and x.

                                  {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
   EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
   EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
 }

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

Definition at line 3492 of file gmock-matchers_test.cc.

References a, EXPECT_EQ, Explain(), testing::Field(), testing::Ge(), GreaterThan(), m, OfType(), x, and testing::gmock_matchers_test::AStruct::x.

                                        {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   a.x = 1;
   EXPECT_EQ("whose given field is 1" + OfType("int"), Explain(m, a));
 
   m = Field(&AStruct::x, GreaterThan(0));
   EXPECT_EQ(
       "whose given field is 1" + OfType("int") + ", which is 1 more than 0",
       Explain(m, a));
 }

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

Definition at line 3506 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                                   {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(&a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3516 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                                      {
   Matcher<AStruct*> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(&a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3526 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                                            {
   Matcher<AStruct* const&> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   EXPECT_TRUE(m.Matches(&a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3536 of file gmock-matchers_test.cc.

References testing::_, EXPECT_FALSE, testing::Field(), m, testing::internal::MatcherBase< T >::Matches(), and x.

                                             {
   Matcher<const AStruct*> m = Field(&AStruct::x, _);
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3543 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Field(), testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), x, and testing::gmock_matchers_test::AStruct::x.

                                                      {
   // Note that the matcher expects DerivedStruct but we say AStruct
   // inside Field().
   Matcher<DerivedStruct*> m = Field(&AStruct::x, Ge(0));
 
   DerivedStruct d;
   EXPECT_TRUE(m.Matches(&d));
   d.x = -1;
   EXPECT_FALSE(m.Matches(&d));
 }

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

Definition at line 3555 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Field(), testing::Ge(), m, and x.

                                            {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
   EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
   EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
 }

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

Definition at line 3563 of file gmock-matchers_test.cc.

References a, EXPECT_EQ, Explain(), testing::Field(), testing::Ge(), GreaterThan(), m, OfType(), x, and testing::gmock_matchers_test::AStruct::x.

                                                  {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   a.x = 1;
   EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
   EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
             Explain(m, &a));
 
   m = Field(&AStruct::x, GreaterThan(0));
   EXPECT_EQ("which points to an object whose given field is 1" + OfType("int") +
             ", which is 1 more than 0", Explain(m, &a));
 }

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

Definition at line 3613 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                                  {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_TRUE(m.Matches(a));
 
   a.set_n(-1);
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3626 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), s, testing::gmock_matchers_test::AClass::set_s(), and testing::StartsWith().

                                                      {
   Matcher<const AClass&> m = Property(&AClass::s, StartsWith("hi"));
 
   AClass a;
   a.set_s("hill");
   EXPECT_TRUE(m.Matches(a));
 
   a.set_s("hole");
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3639 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::Not(), testing::Property(), testing::Ref(), and x.

                                                         {
   double x = 0.0;
   AClass a;
 
   Matcher<const AClass&> m = Property(&AClass::x, Ref(x));
   EXPECT_FALSE(m.Matches(a));
 
   m = Property(&AClass::x, Not(Ref(x)));
   EXPECT_TRUE(m.Matches(a));
 }

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

Definition at line 3652 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), s, testing::gmock_matchers_test::AClass::set_s(), and testing::StartsWith().

                                             {
   Matcher<AClass> m = Property(&AClass::s, StartsWith("hi"));
 
   AClass a;
   a.set_s("hill");
   EXPECT_TRUE(m.Matches(a));
 
   a.set_s("hole");
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3665 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                               {
   // The matcher expects a DerivedClass, but inside the Property() we
   // say AClass.
   Matcher<const DerivedClass&> m = Property(&AClass::n, Ge(0));
 
   DerivedClass d;
   d.set_n(1);
   EXPECT_TRUE(m.Matches(d));
 
   d.set_n(-1);
   EXPECT_FALSE(m.Matches(d));
 }

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

Definition at line 3680 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                                   {
   // n() returns an int but the inner matcher expects a signed char.
   Matcher<const AClass&> m = Property(&AClass::n,
                                       Matcher<signed char>(Ge(0)));
 
   AClass a;
   EXPECT_TRUE(m.Matches(a));
   a.set_n(-1);
   EXPECT_FALSE(m.Matches(a));
 }

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

Definition at line 3692 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Ge(), m, and testing::Property().

                                     {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
   EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
   EXPECT_EQ("is an object whose given property isn't >= 0",
             DescribeNegation(m));
 }

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

Definition at line 3701 of file gmock-matchers_test.cc.

References a, EXPECT_EQ, Explain(), testing::Ge(), GreaterThan(), m, OfType(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                           {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_EQ("whose given property is 1" + OfType("int"), Explain(m, a));
 
   m = Property(&AClass::n, GreaterThan(0));
   EXPECT_EQ(
       "whose given property is 1" + OfType("int") + ", which is 1 more than 0",
       Explain(m, a));
 }

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

Definition at line 3715 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                                      {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_TRUE(m.Matches(&a));
 
   a.set_n(-1);
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3727 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), s, testing::gmock_matchers_test::AClass::set_s(), and testing::StartsWith().

                                                         {
   Matcher<AClass*> m = Property(&AClass::s, StartsWith("hi"));
 
   AClass a;
   a.set_s("hill");
   EXPECT_TRUE(m.Matches(&a));
 
   a.set_s("hole");
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3740 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), s, testing::gmock_matchers_test::AClass::set_s(), and testing::StartsWith().

                                                               {
   Matcher<AClass* const&> m = Property(&AClass::s, StartsWith("hi"));
 
   AClass a;
   a.set_s("hill");
   EXPECT_TRUE(m.Matches(&a));
 
   a.set_s("hole");
   EXPECT_FALSE(m.Matches(&a));
 }

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

Definition at line 3752 of file gmock-matchers_test.cc.

References testing::_, EXPECT_FALSE, m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and x.

                                                                   {
   Matcher<const AClass*> m = Property(&AClass::x, _);
   EXPECT_FALSE(m.Matches(NULL));
 }

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

Definition at line 3759 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, testing::internal::MatcherBase< T >::Matches(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                                         {
   // The matcher expects a DerivedClass, but inside the Property() we
   // say AClass.
   Matcher<const DerivedClass*> m = Property(&AClass::n, Ge(0));
 
   DerivedClass d;
   d.set_n(1);
   EXPECT_TRUE(m.Matches(&d));
 
   d.set_n(-1);
   EXPECT_FALSE(m.Matches(&d));
 }

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

Definition at line 3773 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, testing::Ge(), m, and testing::Property().

                                               {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
   EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
   EXPECT_EQ("is an object whose given property isn't >= 0",
             DescribeNegation(m));
 }

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

Definition at line 3782 of file gmock-matchers_test.cc.

References a, EXPECT_EQ, Explain(), testing::Ge(), GreaterThan(), m, OfType(), testing::Property(), and testing::gmock_matchers_test::AClass::set_n().

                                                     {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
   EXPECT_EQ(
       "which points to an object whose given property is 1" + OfType("int"),
       Explain(m, &a));
 
   m = Property(&AClass::n, GreaterThan(0));
   EXPECT_EQ("which points to an object whose given property is 1" +
             OfType("int") + ", which is 1 more than 0",
             Explain(m, &a));
 }

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

Definition at line 3804 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, IntToStringFunction(), testing::internal::MatcherBase< T >::Matches(), and testing::ResultOf().

                                              {
   Matcher<int> matcher = ResultOf(&IntToStringFunction, Eq(string("foo")));
 
   EXPECT_TRUE(matcher.Matches(1));
   EXPECT_FALSE(matcher.Matches(2));
 }

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

Definition at line 3812 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, IntToStringFunction(), testing::ResultOf(), and testing::StrEq().

                                       {
   Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
 
   EXPECT_EQ("is mapped by the given callable to a value that "
             "is equal to \"foo\"", Describe(matcher));
   EXPECT_EQ("is mapped by the given callable to a value that "
             "isn't equal to \"foo\"", DescribeNegation(matcher));
 }

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

Definition at line 3824 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), testing::Ge(), GreaterThan(), IntFunction(), OfType(), and testing::ResultOf().

                                           {
   Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
   EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int"),
             Explain(matcher, 36));
 
   matcher = ResultOf(&IntFunction, GreaterThan(85));
   EXPECT_EQ("which is mapped by the given callable to 90" + OfType("int") +
             ", which is 5 more than 85", Explain(matcher, 36));
 }

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

Definition at line 3836 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, IntFunction(), testing::internal::MatcherBase< T >::Matches(), and testing::ResultOf().

                                                 {
   Matcher<int> matcher = ResultOf(&IntFunction, Eq(80));
 
   EXPECT_TRUE(matcher.Matches(42));
   EXPECT_FALSE(matcher.Matches(36));
 }

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

Definition at line 3851 of file gmock-matchers_test.cc.

References DoubleFunction(), EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), testing::Ref(), RefUncopyableFunction(), testing::ResultOf(), and x.

                                                        {
   double x = 3.14;
   double x2 = x;
   Matcher<double&> matcher = ResultOf(&DoubleFunction, Ref(x));
 
   EXPECT_TRUE(matcher.Matches(x));
   EXPECT_FALSE(matcher.Matches(x2));
 
   // Test that ResultOf works with uncopyable objects
   Uncopyable obj(0);
   Uncopyable obj2(0);
   Matcher<Uncopyable&> matcher2 =
       ResultOf(&RefUncopyableFunction, Ref(obj));
 
   EXPECT_TRUE(matcher2.Matches(obj));
   EXPECT_FALSE(matcher2.Matches(obj2));
 }

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

Definition at line 3873 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), testing::Ref(), testing::ResultOf(), s, and StringFunction().

                                                     {
   string s = "foo";
   string s2 = s;
   Matcher<const string&> matcher = ResultOf(&StringFunction, Ref(s));
 
   EXPECT_TRUE(matcher.Matches(s));
   EXPECT_FALSE(matcher.Matches(s2));
 }

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

Definition at line 3884 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), IntFunction(), testing::internal::MatcherBase< T >::Matches(), and testing::ResultOf().

                                                    {
   // IntFunction() returns int but the inner matcher expects a signed char.
   Matcher<int> matcher = ResultOf(IntFunction, Matcher<signed char>(Ge(85)));
 
   EXPECT_TRUE(matcher.Matches(36));
   EXPECT_FALSE(matcher.Matches(42));
 }

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

Definition at line 3894 of file gmock-matchers_test.cc.

References dummy(), testing::Eq(), EXPECT_DEATH_IF_SUPPORTED, and testing::ResultOf().

                                                     {
   EXPECT_DEATH_IF_SUPPORTED(
       ResultOf(static_cast<string(*)(int dummy)>(NULL), Eq(string("foo"))),
                "NULL function pointer is passed into ResultOf\\(\\)\\.");
 }

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

Definition at line 3902 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, IntToStringFunction(), testing::internal::MatcherBase< T >::Matches(), testing::ResultOf(), and testing::StrEq().

                                                {
   Matcher<int> matcher = ResultOf(IntToStringFunction, StrEq("foo"));
   EXPECT_TRUE(matcher.Matches(1));
   EXPECT_FALSE(matcher.Matches(2));
 }

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

Definition at line 3916 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), and testing::ResultOf().

                                      {
   Matcher<int> matcher = ResultOf(Functor(), Eq(string("foo")));
 
   EXPECT_TRUE(matcher.Matches(1));
   EXPECT_FALSE(matcher.Matches(2));
 }

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

Definition at line 3932 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), testing::internal::MatcherBase< T >::Matches(), and testing::ResultOf().

                                                 {
   Matcher<int> matcher_int = ResultOf(PolymorphicFunctor(), Ge(5));
 
   EXPECT_TRUE(matcher_int.Matches(10));
   EXPECT_FALSE(matcher_int.Matches(2));
 
   Matcher<const char*> matcher_string = ResultOf(PolymorphicFunctor(), Ge(5));
 
   EXPECT_TRUE(matcher_string.Matches("long string"));
   EXPECT_FALSE(matcher_string.Matches("shrt"));
 }

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

Definition at line 3951 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, testing::internal::MatcherBase< T >::Matches(), ReferencingFunction(), and testing::ResultOf().

                                                  {
   const int n = 1;
   const int n2 = 1;
   Matcher<const int&> matcher2 = ResultOf(ReferencingFunction, Eq(&n));
   EXPECT_TRUE(matcher2.Matches(n));
   EXPECT_FALSE(matcher2.Matches(n2));
 
   Matcher<const int&> matcher3 = ResultOf(ReferencingFunctor(), Eq(&n));
   EXPECT_TRUE(matcher3.Matches(n));
   EXPECT_FALSE(matcher3.Matches(n2));
 }

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

Definition at line 3996 of file gmock-matchers_test.cc.

References testing::AllOf(), DivisibleBy(), EXPECT_EQ, Explain(), and m.

                                                 {
   const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
   EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
 }

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

Definition at line 4003 of file gmock-matchers_test.cc.

References testing::AllOf(), DivisibleBy(), EXPECT_EQ, Explain(), and m.

                                                {
   const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
   EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
 }

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

Definition at line 4010 of file gmock-matchers_test.cc.

References testing::AllOf(), DivisibleBy(), EXPECT_EQ, Explain(), testing::Ge(), and m.

                                                {
   const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
   EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
 }

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

Definition at line 4017 of file gmock-matchers_test.cc.

References testing::AllOf(), DivisibleBy(), EXPECT_EQ, Explain(), and m.

                                               {
   const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
   EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
 }

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

Definition at line 4022 of file gmock-matchers_test.cc.

References testing::AllOf(), EXPECT_EQ, Explain(), testing::Ge(), testing::Le(), and m.

                                                 {
   const Matcher<int> m = AllOf(Ge(2), Le(3));
   EXPECT_EQ("", Explain(m, 2));
 }

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

Definition at line 4027 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), GreaterThan(), and m.

                                                    {
   const Matcher<int> m = GreaterThan(5);
   EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
 }

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

Definition at line 4055 of file gmock-matchers_test.cc.

References testing::ByRef(), testing::Eq(), EXPECT_FALSE, EXPECT_TRUE, m, and testing::internal::MatcherBase< T >::Matches().

                                                        {
   const NotCopyable const_value1(1);
   const Matcher<const NotCopyable&> m = Eq(ByRef(const_value1));
 
   const NotCopyable n1(1), n2(2);
   EXPECT_TRUE(m.Matches(n1));
   EXPECT_FALSE(m.Matches(n2));
 }

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

Definition at line 4064 of file gmock-matchers_test.cc.

References testing::ByRef(), EXPECT_FALSE, EXPECT_TRUE, testing::Ge(), m, and testing::internal::MatcherBase< T >::Matches().

                                                   {
   NotCopyable value2(2);
   const Matcher<NotCopyable&> m = Ge(ByRef(value2));
 
   NotCopyable n1(1), n2(2);
   EXPECT_FALSE(m.Matches(n1));
   EXPECT_TRUE(m.Matches(n2));
 }

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

Definition at line 4073 of file gmock-matchers_test.cc.

References EXPECT_THAT, and testing::Not().

                                      {
   vector<int> container;
   EXPECT_THAT(container, IsEmpty());
   container.push_back(0);
   EXPECT_THAT(container, Not(IsEmpty()));
   container.push_back(1);
   EXPECT_THAT(container, Not(IsEmpty()));
 }

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

Definition at line 4082 of file gmock-matchers_test.cc.

References EXPECT_THAT, and testing::Not().

                                    {
   string text;
   EXPECT_THAT(text, IsEmpty());
   text = "foo";
   EXPECT_THAT(text, Not(IsEmpty()));
   text = string("\0", 1);
   EXPECT_THAT(text, Not(IsEmpty()));
 }

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

Definition at line 4091 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, and m.

                                    {
   Matcher<vector<int> > m = IsEmpty();
   EXPECT_EQ("is empty", Describe(m));
   EXPECT_EQ("isn't empty", DescribeNegation(m));
 }

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

Definition at line 4097 of file gmock-matchers_test.cc.

References EXPECT_EQ, Explain(), and m.

                                   {
   Matcher<vector<int> > m = IsEmpty();
   vector<int> container;
   EXPECT_EQ("", Explain(m, container));
   container.push_back(0);
   EXPECT_EQ("whose size is 1", Explain(m, container));
 }

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

Definition at line 4105 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Not(), and testing::SizeIs().

                                    {
   vector<int> container;
   EXPECT_THAT(container, SizeIs(0));
   EXPECT_THAT(container, Not(SizeIs(1)));
   container.push_back(0);
   EXPECT_THAT(container, Not(SizeIs(0)));
   EXPECT_THAT(container, SizeIs(1));
   container.push_back(0);
   EXPECT_THAT(container, Not(SizeIs(0)));
   EXPECT_THAT(container, SizeIs(2));
 }

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

Definition at line 4117 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Not(), and testing::SizeIs().

                                {
   map<string, int> container;
   EXPECT_THAT(container, SizeIs(0));
   EXPECT_THAT(container, Not(SizeIs(1)));
   container.insert(make_pair("foo", 1));
   EXPECT_THAT(container, Not(SizeIs(0)));
   EXPECT_THAT(container, SizeIs(1));
   container.insert(make_pair("bar", 2));
   EXPECT_THAT(container, Not(SizeIs(0)));
   EXPECT_THAT(container, SizeIs(2));
 }

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

Definition at line 4129 of file gmock-matchers_test.cc.

References EXPECT_THAT, m, testing::Not(), and testing::SizeIs().

                                       {
   vector<int> container;
   Matcher<const vector<int>&> m = SizeIs(1);
   EXPECT_THAT(container, Not(m));
   container.push_back(0);
   EXPECT_THAT(container, m);
 }

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

Definition at line 4137 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, m, and testing::SizeIs().

                                   {
   Matcher<vector<int> > m = SizeIs(2);
   EXPECT_EQ("size is equal to 2", Describe(m));
   EXPECT_EQ("size isn't equal to 2", DescribeNegation(m));
 }

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

Definition at line 4143 of file gmock-matchers_test.cc.

References testing::AnyOf(), testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, Explain(), GreaterThan(), testing::Lt(), m, testing::internal::MatcherBase< T >::Matches(), testing::SizeIs(), testing::TYPED_TEST(), and testing::TYPED_TEST_CASE().

                                  {
   Matcher<vector<int> > m1 = SizeIs(2);
   Matcher<vector<int> > m2 = SizeIs(Lt(2u));
   Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
   Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
   vector<int> container;
   EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
   EXPECT_EQ("whose size 0 matches", Explain(m2, container));
   EXPECT_EQ("whose size 0 matches", Explain(m3, container));
   EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
             Explain(m4, container));
   container.push_back(0);
   container.push_back(0);
   EXPECT_EQ("whose size 2 matches", Explain(m1, container));
   EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
   EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
   EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
             Explain(m4, container));
 }

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

Definition at line 4239 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, Explain(), m, and testing::internal::MatcherBase< T >::Matches().

                                                   {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {2, 1, 5};
   vector<int> my_set(vals, vals + 6);
   vector<int> test_set(test_vals, test_vals + 3);
   const Matcher<vector<int> > m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
   EXPECT_EQ("which doesn't have these expected elements: 3, 8",
             Explain(m, test_set));
 }

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

Definition at line 4252 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, Explain(), m, and testing::internal::MatcherBase< T >::Matches().

                                                 {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
   list<size_t> my_set(vals, vals + 6);
   list<size_t> test_set(test_vals, test_vals + 7);
   const Matcher<const list<size_t>&> m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
   EXPECT_EQ("which has these unexpected elements: 92, 46",
             Explain(m, test_set));
 }

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

Definition at line 4264 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, Explain(), m, and testing::internal::MatcherBase< T >::Matches().

                                                           {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 92, 46};
   list<size_t> my_set(vals, vals + 6);
   list<size_t> test_set(test_vals, test_vals + 5);
   const Matcher<const list<size_t> > m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
   EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
             "and doesn't have these expected elements: 5, 8",
             Explain(m, test_set));
 }

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

Definition at line 4278 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, Explain(), m, and testing::internal::MatcherBase< T >::Matches().

                                                              {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 5, 8};
   vector<int> my_set(vals, vals + 6);
   vector<int> test_set(test_vals, test_vals + 5);
   const Matcher<vector<int> > m = ContainerEq(my_set);
   EXPECT_TRUE(m.Matches(my_set));
   EXPECT_FALSE(m.Matches(test_set));
   // There is nothing to report when both sets contain all the same values.
   EXPECT_EQ("", Explain(m, test_set));
 }

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

Definition at line 4292 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, Explain(), m, and testing::internal::MatcherBase< T >::Matches().

                                          {
   map<int, std::string> my_map;
   my_map[0] = "a";
   my_map[1] = "b";
 
   map<int, std::string> test_map;
   test_map[0] = "aa";
   test_map[1] = "b";
 
   const Matcher<const map<int, std::string>&> m = ContainerEq(my_map);
   EXPECT_TRUE(m.Matches(my_map));
   EXPECT_FALSE(m.Matches(test_map));
 
   EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
             "and doesn't have these expected elements: (0, \"a\")",
             Explain(m, test_map));
 }

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

Definition at line 4310 of file gmock-matchers_test.cc.

References b, testing::ContainerEq(), EXPECT_THAT, and testing::Not().

                                                 {
   int a1[] = {1, 2, 3};
   int a2[] = {1, 2, 3};
   int b[] = {1, 2, 4};
 
   EXPECT_THAT(a1, ContainerEq(a2));
   EXPECT_THAT(a1, Not(ContainerEq(b)));
 }

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

Definition at line 4319 of file gmock-matchers_test.cc.

References b, testing::ContainerEq(), testing::ElementsAre(), EXPECT_THAT, and testing::Not().

                                                               {
   const char a1[][3] = {"hi", "lo"};
   const char a2[][3] = {"hi", "lo"};
   const char b[][3] = {"lo", "hi"};
 
   // Tests using ContainerEq() in the first dimension.
   EXPECT_THAT(a1, ContainerEq(a2));
   EXPECT_THAT(a1, Not(ContainerEq(b)));
 
   // Tests using ContainerEq() in the second dimension.
   EXPECT_THAT(a1, ElementsAre(ContainerEq(a2[0]), ContainerEq(a2[1])));
   EXPECT_THAT(a1, ElementsAre(Not(ContainerEq(b[0])), ContainerEq(a2[1])));
 }

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

Definition at line 4333 of file gmock-matchers_test.cc.

References b, c, testing::ContainerEq(), EXPECT_THAT, std::tr1::make_tuple(), and testing::Not().

                                                        {
   const int a1[] = {1, 2, 3};
   const int a2[] = {1, 2, 3};
   const int b[] = {1, 2, 3, 4};
 
   const int* const p1 = a1;
   EXPECT_THAT(make_tuple(p1, 3), ContainerEq(a2));
   EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(b)));
 
   const int c[] = {1, 3, 2};
   EXPECT_THAT(make_tuple(p1, 3), Not(ContainerEq(c)));
 }

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

Definition at line 4346 of file gmock-matchers_test.cc.

References testing::ContainerEq(), EXPECT_THAT, m, and string.

                                                        {
   std::string a1[][3] = {
     {"hi", "hello", "ciao"},
     {"bye", "see you", "ciao"}
   };
 
   std::string a2[][3] = {
     {"hi", "hello", "ciao"},
     {"bye", "see you", "ciao"}
   };
 
   const Matcher<const std::string(&)[2][3]> m = ContainerEq(a2);
   EXPECT_THAT(a1, m);
 
   a2[0][0] = "ha";
   EXPECT_THAT(a1, m);
 }

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

Definition at line 4364 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSortedBy().

                                                {
   const vector<int> numbers;
   EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre()));
   EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1))));
 }

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

Definition at line 4370 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSortedBy().

                                                   {
   vector<unsigned> numbers;
   numbers.push_back(3);
   numbers.push_back(1);
   numbers.push_back(2);
   numbers.push_back(2);
   EXPECT_THAT(numbers, WhenSortedBy(greater<unsigned>(),
                                     ElementsAre(3, 2, 2, 1)));
   EXPECT_THAT(numbers, Not(WhenSortedBy(greater<unsigned>(),
                                         ElementsAre(1, 2, 2, 3))));
 }

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

Definition at line 4382 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSortedBy().

                                                    {
   list<string> words;
   words.push_back("say");
   words.push_back("hello");
   words.push_back("world");
   EXPECT_THAT(words, WhenSortedBy(less<string>(),
                                   ElementsAre("hello", "say", "world")));
   EXPECT_THAT(words, Not(WhenSortedBy(less<string>(),
                                       ElementsAre("say", "hello", "world"))));
 }

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

Definition at line 4393 of file gmock-matchers_test.cc.

References testing::ElementsAre(), testing::ElementsAreArray(), EXPECT_THAT, testing::Not(), and testing::WhenSortedBy().

                                             {
   const int numbers[] = {1, 3, 2, 4};
   const int sorted_numbers[] = {1, 2, 3, 4};
   EXPECT_THAT(numbers, WhenSortedBy(less<int>(), ElementsAre(1, 2, 3, 4)));
   EXPECT_THAT(numbers, WhenSortedBy(less<int>(),
                                     ElementsAreArray(sorted_numbers)));
   EXPECT_THAT(numbers, Not(WhenSortedBy(less<int>(), ElementsAre(1, 3, 2, 4))));
 }

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

Definition at line 4402 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), testing::ElementsAre(), EXPECT_EQ, m, and testing::WhenSortedBy().

                                         {
   const Matcher<vector<int> > m = WhenSortedBy(less<int>(), ElementsAre(1, 2));
   EXPECT_EQ("(when sorted) has 2 elements where\n"
             "element #0 is equal to 1,\n"
             "element #1 is equal to 2",
             Describe(m));
   EXPECT_EQ("(when sorted) doesn't have 2 elements, or\n"
             "element #0 isn't equal to 1, or\n"
             "element #1 isn't equal to 2",
             DescribeNegation(m));
 }

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

Definition at line 4414 of file gmock-matchers_test.cc.

References a, testing::ElementsAre(), EXPECT_EQ, Explain(), and testing::WhenSortedBy().

                                             {
   const int a[] = {2, 1};
   EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
             Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
   EXPECT_EQ("which is { 1, 2 } when sorted",
             Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
 }

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

Definition at line 4425 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSorted().

                                              {
   const vector<int> numbers;
   EXPECT_THAT(numbers, WhenSorted(ElementsAre()));
   EXPECT_THAT(numbers, Not(WhenSorted(ElementsAre(1))));
 }

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

Definition at line 4431 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSorted().

                                                 {
   list<string> words;
   words.push_back("3");
   words.push_back("1");
   words.push_back("2");
   words.push_back("2");
   EXPECT_THAT(words, WhenSorted(ElementsAre("1", "2", "2", "3")));
   EXPECT_THAT(words, Not(WhenSorted(ElementsAre("3", "1", "2", "2"))));
 }

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

Definition at line 4441 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), testing::Pair(), and testing::WhenSorted().

                                        {
     map<string, int> word_counts;
     word_counts["and"] = 1;
     word_counts["the"] = 1;
     word_counts["buffalo"] = 2;
     EXPECT_THAT(word_counts, WhenSorted(ElementsAre(
             Pair("and", 1), Pair("buffalo", 2), Pair("the", 1))));
     EXPECT_THAT(word_counts, Not(WhenSorted(ElementsAre(
             Pair("and", 1), Pair("the", 1), Pair("buffalo", 2)))));
 }

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

Definition at line 4452 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), testing::Pair(), and testing::WhenSorted().

                                             {
     multimap<int, int> ifib;
     ifib.insert(make_pair(8, 6));
     ifib.insert(make_pair(2, 3));
     ifib.insert(make_pair(1, 1));
     ifib.insert(make_pair(3, 4));
     ifib.insert(make_pair(1, 2));
     ifib.insert(make_pair(5, 5));
     EXPECT_THAT(ifib, WhenSorted(ElementsAre(Pair(1, 1),
                                              Pair(1, 2),
                                              Pair(2, 3),
                                              Pair(3, 4),
                                              Pair(5, 5),
                                              Pair(8, 6))));
     EXPECT_THAT(ifib, Not(WhenSorted(ElementsAre(Pair(8, 6),
                                                  Pair(2, 3),
                                                  Pair(1, 1),
                                                  Pair(3, 4),
                                                  Pair(1, 2),
                                                  Pair(5, 5)))));
 }

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

Definition at line 4474 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSorted().

                                                  {
     std::deque<int> d;
     d.push_back(2);
     d.push_back(1);
     EXPECT_THAT(d, WhenSorted(ElementsAre(1, 2)));
     EXPECT_THAT(d, Not(WhenSorted(ElementsAre(2, 1))));
 }

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

Definition at line 4482 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::Not(), and testing::WhenSorted().

                                                     {
     std::deque<int> d;
     d.push_back(2);
     d.push_back(1);
     Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2);
     EXPECT_THAT(d, WhenSorted(vector_match));
     Matcher<const std::vector<int>&> not_vector_match = ElementsAre(2, 1);
     EXPECT_THAT(d, Not(WhenSorted(not_vector_match)));
 }

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

Definition at line 4572 of file gmock-matchers_test.cc.

References a, testing::gmock_matchers_test::Streamlike< T >::begin(), testing::BeginEndDistanceIs(), testing::gmock_matchers_test::Streamlike< T >::end(), EXPECT_EQ, EXPECT_THAT, testing::Not(), s, SCOPED_TRACE, and testing::internal::TEST().

                                 {
   const int a[5] = {2, 1, 4, 5, 3};
   Streamlike<int> s(a, a + 5);
   Streamlike<int>::const_iterator it = s.begin();
   const int* ip = a;
   while (it != s.end()) {
     SCOPED_TRACE(ip - a);
     EXPECT_EQ(*ip++, *it++);
   }
 }

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

Definition at line 4597 of file gmock-matchers_test.cc.

References a, testing::BeginEndDistanceIs(), EXPECT_THAT, and s.

                                                   {
   const int a[5] = {1, 2, 3, 4, 5};
   Streamlike<int> s(a, a + 5);
   EXPECT_THAT(s, BeginEndDistanceIs(5));
 }

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

Definition at line 4603 of file gmock-matchers_test.cc.

References testing::BeginEndDistanceIs(), Describe(), DescribeNegation(), EXPECT_EQ, and m.

                                               {
   Matcher<vector<int> > m = BeginEndDistanceIs(2);
   EXPECT_EQ("distance between begin() and end() is equal to 2", Describe(m));
   EXPECT_EQ("distance between begin() and end() isn't equal to 2",
             DescribeNegation(m));
 }

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

Definition at line 4610 of file gmock-matchers_test.cc.

References testing::AnyOf(), testing::BeginEndDistanceIs(), EXPECT_EQ, Explain(), GreaterThan(), and testing::Lt().

                                              {
   Matcher<vector<int> > m1 = BeginEndDistanceIs(2);
   Matcher<vector<int> > m2 = BeginEndDistanceIs(Lt(2));
   Matcher<vector<int> > m3 = BeginEndDistanceIs(AnyOf(0, 3));
   Matcher<vector<int> > m4 = BeginEndDistanceIs(GreaterThan(1));
   vector<int> container;
   EXPECT_EQ("whose distance between begin() and end() 0 doesn't match",
             Explain(m1, container));
   EXPECT_EQ("whose distance between begin() and end() 0 matches",
             Explain(m2, container));
   EXPECT_EQ("whose distance between begin() and end() 0 matches",
             Explain(m3, container));
   EXPECT_EQ(
       "whose distance between begin() and end() 0 doesn't match, which is 1 "
       "less than 1",
       Explain(m4, container));
   container.push_back(0);
   container.push_back(0);
   EXPECT_EQ("whose distance between begin() and end() 2 matches",
             Explain(m1, container));
   EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
             Explain(m2, container));
   EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
             Explain(m3, container));
   EXPECT_EQ(
       "whose distance between begin() and end() 2 matches, which is 1 more "
       "than 1",
       Explain(m4, container));
 }

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

Definition at line 4640 of file gmock-matchers_test.cc.

References a, testing::ElementsAre(), EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), s, and testing::WhenSorted().

                                          {
   // Streamlike 'container' provides only minimal iterator support.
   // Its iterators are tagged with input_iterator_tag.
   const int a[5] = {2, 1, 4, 5, 3};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   EXPECT_THAT(s, WhenSorted(ElementsAre(1, 2, 3, 4, 5)));
   EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
 }

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

Definition at line 4649 of file gmock-matchers_test.cc.

References a, testing::ElementsAre(), EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), s, and testing::WhenSorted().

                                                                 {
   const int a[] = {2, 1, 4, 5, 3};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   Matcher<const std::vector<int>&> vector_match = ElementsAre(1, 2, 3, 4, 5);
   EXPECT_THAT(s, WhenSorted(vector_match));
   EXPECT_THAT(s, Not(WhenSorted(ElementsAre(2, 1, 4, 5, 3))));
 }

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

Definition at line 4660 of file gmock-matchers_test.cc.

References a, testing::ElementsAre(), EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), and s.

                                                {
   const int a[5] = {1, 2, 3, 4, 5};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   EXPECT_THAT(s, ElementsAre(1, 2, 3, 4, 5));
   EXPECT_THAT(s, Not(ElementsAre(2, 1, 4, 5, 3)));
 }

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

Definition at line 4667 of file gmock-matchers_test.cc.

References a, testing::ElementsAreArray(), EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), and s.

                                                     {
   const int a[5] = {1, 2, 3, 4, 5};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
 
   vector<int> expected;
   expected.push_back(1);
   expected.push_back(2);
   expected.push_back(3);
   expected.push_back(4);
   expected.push_back(5);
   EXPECT_THAT(s, ElementsAreArray(expected));
 
   expected[3] = 0;
   EXPECT_THAT(s, Not(ElementsAreArray(expected)));
 }

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

Definition at line 4683 of file gmock-matchers_test.cc.

References testing::ElementsAre(), EXPECT_THAT, testing::gmock_matchers_test::Uncopyable::set_value(), testing::Truly(), and ValueIsPositive().

                                            {
   Uncopyable objs[2];
   objs[0].set_value(-3);
   objs[1].set_value(1);
   EXPECT_THAT(objs, ElementsAre(UncopyableIs(-3), Truly(ValueIsPositive)));
 }

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

Definition at line 4690 of file gmock-matchers_test.cc.

References testing::ElementsAreArray(), EXPECT_THAT, and testing::Not().

                                          {
   const int actual[] = {3, 1, 2};
 
   ::std::list<int> expected;
   expected.push_back(3);
   expected.push_back(1);
   expected.push_back(2);
   EXPECT_THAT(actual, ElementsAreArray(expected));
 
   expected.push_back(4);
   EXPECT_THAT(actual, Not(ElementsAreArray(expected)));
 }

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

Definition at line 4705 of file gmock-matchers_test.cc.

References a, EXPECT_TRUE, testing::ExplainMatchResult(), GTEST_ARRAY_SIZE_, s, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAreArray().

                                                           {
   const int a[] = {0, 1, 2, 3, 4};
   std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   do {
     StringMatchResultListener listener;
     EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(a),
                                    s, &listener)) << listener.str();
   } while (std::next_permutation(s.begin(), s.end()));
 }

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

Definition at line 4715 of file gmock-matchers_test.cc.

References a, b, EXPECT_TRUE, testing::ExplainMatchResult(), GTEST_ARRAY_SIZE_, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAreArray().

                                                 {
   const bool a[] = {0, 1, 0, 1, 1};
   const bool b[] = {1, 0, 1, 1, 0};
   std::vector<bool> expected(a, a + GTEST_ARRAY_SIZE_(a));
   std::vector<bool> actual(b, b + GTEST_ARRAY_SIZE_(b));
   StringMatchResultListener listener;
   EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(expected),
                                  actual, &listener)) << listener.str();
 }

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

Definition at line 4725 of file gmock-matchers_test.cc.

References a, EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), s, and testing::UnorderedElementsAreArray().

                                                         {
   // Streamlike 'container' provides only minimal iterator support.
   // Its iterators are tagged with input_iterator_tag, and it has no
   // size() or empty() methods.
   const int a[5] = {2, 1, 4, 5, 3};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
 
   ::std::vector<int> expected;
   expected.push_back(1);
   expected.push_back(2);
   expected.push_back(3);
   expected.push_back(4);
   expected.push_back(5);
   EXPECT_THAT(s, UnorderedElementsAreArray(expected));
 
   expected.push_back(6);
   EXPECT_THAT(s, Not(UnorderedElementsAreArray(expected)));
 }

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

Definition at line 4744 of file gmock-matchers_test.cc.

References a, testing::Eq(), EXPECT_THAT, testing::Ge(), testing::Le(), testing::Ne(), testing::Not(), testing::internal::TEST(), and testing::UnorderedElementsAreArray().

                                                        {
   const int actual[] = {3, 1, 2};
 
   ::std::list<int> expected;
   expected.push_back(1);
   expected.push_back(2);
   expected.push_back(3);
   EXPECT_THAT(actual, UnorderedElementsAreArray(expected));
 
   expected.push_back(4);
   EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
 }

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

Definition at line 5218 of file gmock-matchers_test.cc.

References EXPECT_TRUE, and testing::internal::IsReadableTypeName().

                                                        {
   EXPECT_TRUE(IsReadableTypeName("int"));
   EXPECT_TRUE(IsReadableTypeName("const unsigned char*"));
   EXPECT_TRUE(IsReadableTypeName("MyMap<int, void*>"));
   EXPECT_TRUE(IsReadableTypeName("void (*)(int, bool)"));
 }

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

Definition at line 5225 of file gmock-matchers_test.cc.

References EXPECT_TRUE, and testing::internal::IsReadableTypeName().

                                                                             {
   EXPECT_TRUE(IsReadableTypeName("my_long_namespace::MyClassName"));
   EXPECT_TRUE(IsReadableTypeName("int [5][6][7][8][9][10][11]"));
   EXPECT_TRUE(IsReadableTypeName("my_namespace::MyOuterClass::MyInnerClass"));
 }

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

Definition at line 5231 of file gmock-matchers_test.cc.

References EXPECT_FALSE, and testing::internal::IsReadableTypeName().

                                                                {
   EXPECT_FALSE(
       IsReadableTypeName("basic_string<char, std::char_traits<char> >"));
   EXPECT_FALSE(IsReadableTypeName("std::vector<int, std::alloc_traits<int> >"));
 }

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

Definition at line 5237 of file gmock-matchers_test.cc.

References EXPECT_FALSE, and testing::internal::IsReadableTypeName().

                                                                    {
   EXPECT_FALSE(IsReadableTypeName("void (&)(int, bool, char, float)"));
 }

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

Definition at line 5243 of file gmock-matchers_test.cc.

References EXPECT_EQ, and testing::internal::JoinAsTuple().

                                        {
   EXPECT_EQ("", JoinAsTuple(Strings()));
 }

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

Definition at line 5247 of file gmock-matchers_test.cc.

References EXPECT_EQ, and testing::internal::JoinAsTuple().

                                      {
   const char* fields[] = {"1"};
   EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1)));
 }

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

Definition at line 5252 of file gmock-matchers_test.cc.

References EXPECT_EQ, and testing::internal::JoinAsTuple().

                                      {
   const char* fields[] = {"1", "a"};
   EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2)));
 }

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

Definition at line 5257 of file gmock-matchers_test.cc.

References EXPECT_EQ, and testing::internal::JoinAsTuple().

                                      {
   const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
   EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)",
             JoinAsTuple(Strings(fields, fields + 10)));
 }

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

Definition at line 5265 of file gmock-matchers_test.cc.

References EXPECT_EQ, testing::internal::FormatMatcherDescription(), and params.

                                                              {
   EXPECT_EQ("is even",
             FormatMatcherDescription(false, "IsEven", Strings()));
   EXPECT_EQ("not (is even)",
             FormatMatcherDescription(true, "IsEven", Strings()));
 
   const char* params[] = {"5"};
   EXPECT_EQ("equals 5",
             FormatMatcherDescription(false, "Equals",
                                      Strings(params, params + 1)));
 
   const char* params2[] = {"5", "8"};
   EXPECT_EQ("is in range (5, 8)",
             FormatMatcherDescription(false, "IsInRange",
                                      Strings(params2, params2 + 2)));
 }

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

Definition at line 5283 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::DivisibleByImpl::divider(), EXPECT_EQ, m, testing::PolymorphicMatcher< Impl >::mutable_impl(), and testing::gmock_matchers_test::DivisibleByImpl::set_divider().

                                                    {
   PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
   DivisibleByImpl& impl = m.mutable_impl();
   EXPECT_EQ(42, impl.divider());
 
   impl.set_divider(0);
   EXPECT_EQ(0, m.mutable_impl().divider());
 }

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

Definition at line 5293 of file gmock-matchers_test.cc.

References testing::gmock_matchers_test::DivisibleByImpl::divider(), EXPECT_EQ, testing::PolymorphicMatcher< Impl >::impl(), and m.

                                             {
   const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
   const DivisibleByImpl& impl = m.impl();
   EXPECT_EQ(42, impl.divider());
 }

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

Definition at line 5299 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_EQ, testing::internal::ExplainMatchFailureTupleTo(), GreaterThan(), and std::tr1::make_tuple().

                                              {
   stringstream ss1;
   ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
                              make_tuple('a', 10), &ss1);
   EXPECT_EQ("", ss1.str());  // Successful match.
 
   stringstream ss2;
   ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
                              make_tuple(2, 'b'), &ss2);
   EXPECT_EQ("  Expected arg #0: is > 5\n"
             "           Actual: 2, which is 3 less than 5\n"
             "  Expected arg #1: is equal to 'a' (97, 0x61)\n"
             "           Actual: 'b' (98, 0x62)\n",
             ss2.str());  // Failed match where both arguments need explanation.
 
   stringstream ss3;
   ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
                              make_tuple(2, 'a'), &ss3);
   EXPECT_EQ("  Expected arg #0: is > 5\n"
             "           Actual: 2, which is 3 less than 5\n",
             ss3.str());  // Failed match where only one argument needs
                          // explanation.
 }

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

Definition at line 5325 of file gmock-matchers_test.cc.

References a, b, testing::Each(), EXPECT_EQ, Explain(), GreaterThan(), and m.

                                              {
   set<int> a;  // empty
 
   Matcher<set<int> > m = Each(2);
   EXPECT_EQ("", Explain(m, a));
 
   Matcher<const int(&)[1]> n = Each(1);  // NOLINT
 
   const int b[1] = {1};
   EXPECT_EQ("", Explain(n, b));
 
   n = Each(3);
   EXPECT_EQ("whose element #0 doesn't match", Explain(n, b));
 
   a.insert(1);
   a.insert(2);
   a.insert(3);
   m = Each(GreaterThan(0));
   EXPECT_EQ("", Explain(m, a));
 
   m = Each(GreaterThan(10));
   EXPECT_EQ("whose element #0 doesn't match, which is 9 less than 10",
             Explain(m, a));
 }

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

Definition at line 5350 of file gmock-matchers_test.cc.

References Describe(), testing::Each(), EXPECT_EQ, m, and testing::Not().

                                          {
   Matcher<vector<int> > m = Each(1);
   EXPECT_EQ("only contains elements that is equal to 1", Describe(m));
 
   Matcher<vector<int> > m2 = Not(m);
   EXPECT_EQ("contains some element that isn't equal to 1", Describe(m2));
 }

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

Definition at line 5358 of file gmock-matchers_test.cc.

References testing::Each(), EXPECT_THAT, testing::Lt(), and testing::Not().

                                                   {
   vector<int> some_vector;
   EXPECT_THAT(some_vector, Each(1));
   some_vector.push_back(3);
   EXPECT_THAT(some_vector, Not(Each(1)));
   EXPECT_THAT(some_vector, Each(3));
   some_vector.push_back(1);
   some_vector.push_back(2);
   EXPECT_THAT(some_vector, Not(Each(3)));
   EXPECT_THAT(some_vector, Each(Lt(3.5)));
 
   vector<string> another_vector;
   another_vector.push_back("fee");
   EXPECT_THAT(another_vector, Each(string("fee")));
   another_vector.push_back("fie");
   another_vector.push_back("foe");
   another_vector.push_back("fum");
   EXPECT_THAT(another_vector, Not(Each(string("fee"))));
 }

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

Definition at line 5378 of file gmock-matchers_test.cc.

References testing::_, bar, testing::Each(), EXPECT_THAT, testing::Gt(), testing::Not(), and testing::Pair().

                                                {
   map<const char*, int> my_map;
   const char* bar = "a string";
   my_map[bar] = 2;
   EXPECT_THAT(my_map, Each(make_pair(bar, 2)));
 
   map<string, int> another_map;
   EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
   another_map["fee"] = 1;
   EXPECT_THAT(another_map, Each(make_pair(string("fee"), 1)));
   another_map["fie"] = 2;
   another_map["foe"] = 3;
   another_map["fum"] = 4;
   EXPECT_THAT(another_map, Not(Each(make_pair(string("fee"), 1))));
   EXPECT_THAT(another_map, Not(Each(make_pair(string("fum"), 1))));
   EXPECT_THAT(another_map, Each(Pair(_, Gt(0))));
 }

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

Definition at line 5396 of file gmock-matchers_test.cc.

References a, testing::Each(), EXPECT_THAT, testing::Gt(), and testing::Not().

                                {
   const int a[] = {1, 2, 3};
   EXPECT_THAT(a, Each(Gt(0)));
   EXPECT_THAT(a, Not(Each(Gt(1))));
 }

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

Definition at line 5402 of file gmock-matchers_test.cc.

References a, testing::Each(), EXPECT_THAT, testing::Gt(), std::tr1::make_tuple(), and testing::Not().

                                            {
   const int a[] = {1, 2};
   const int* const pointer = a;
   EXPECT_THAT(make_tuple(pointer, 2), Each(Gt(0)));
   EXPECT_THAT(make_tuple(pointer, 2), Not(Each(Gt(1))));
 }

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

Definition at line 5437 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, IsHalfOf(), m, testing::Pointwise(), and folly::detail::rhs.

                                    {
   vector<int> rhs;
   rhs.push_back(1);
   rhs.push_back(2);
   rhs.push_back(3);
   const Matcher<const vector<int>&> m = Pointwise(IsHalfOf(), rhs);
   EXPECT_EQ("contains 3 values, where each value and its corresponding value "
             "in { 1, 2, 3 } are a pair where the first is half of the second",
             Describe(m));
   EXPECT_EQ("doesn't contain exactly 3 values, or contains a value x at some "
             "index i where x and the i-th value of { 1, 2, 3 } are a pair "
             "where the first isn't half of the second",
             DescribeNegation(m));
 }

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

Definition at line 5452 of file gmock-matchers_test.cc.

References EXPECT_THAT, IsHalfOf(), m, testing::Pointwise(), and folly::detail::rhs.

                                     {
   list<signed char> rhs;
   rhs.push_back(2);
   rhs.push_back(4);
 
   int lhs[] = {1, 2};
   const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
   EXPECT_THAT(lhs, m);
 
   // Changing rhs now shouldn't affect m, which made a copy of rhs.
   rhs.push_back(6);
   EXPECT_THAT(lhs, m);
 }

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

Definition at line 5466 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Gt(), testing::Lt(), testing::Not(), testing::Pointwise(), and folly::detail::rhs.

                                             {
   const int lhs[] = {1, 2, 3};
   vector<int> rhs;
   rhs.push_back(2);
   rhs.push_back(4);
   rhs.push_back(6);
   EXPECT_THAT(lhs, Pointwise(Lt(), rhs));
   EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
 }

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

Definition at line 5476 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Gt(), testing::Lt(), testing::Not(), testing::Pointwise(), folly::detail::rhs, and testing::internal::TEST().

                                             {
   const int rhs[] = {1, 2, 3};
   vector<int> lhs;
   lhs.push_back(2);
   lhs.push_back(4);
   lhs.push_back(6);
   EXPECT_THAT(lhs, Pointwise(Gt(), rhs));
   EXPECT_THAT(lhs, Not(Pointwise(Lt(), rhs)));
 }

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

Definition at line 5496 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), testing::Gt(), testing::Not(), testing::Pointwise(), and folly::detail::rhs.

                                       {
   const double lhs[2] = {1, 2};
   const int rhs[1] = {0};
   EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs)));
   EXPECT_EQ("which contains 2 values",
             Explain(Pointwise(Gt(), rhs), lhs));
 
   const int rhs2[3] = {0, 1, 2};
   EXPECT_THAT(lhs, Not(Pointwise(Gt(), rhs2)));
 }

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

Definition at line 5507 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), IsHalfOf(), testing::Not(), testing::Pointwise(), and folly::detail::rhs.

                                          {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 6, 4};
   EXPECT_THAT(lhs, Not(Pointwise(IsHalfOf(), rhs)));
   EXPECT_EQ("where the value pair (2, 6) at index #1 don't match, "
             "where the second/2 is 3",
             Explain(Pointwise(IsHalfOf(), rhs), lhs));
 }

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

Definition at line 5516 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), IsHalfOf(), testing::Pointwise(), and folly::detail::rhs.

                                            {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 4, 6};
   EXPECT_THAT(lhs, Pointwise(IsHalfOf(), rhs));
   EXPECT_EQ("", Explain(Pointwise(IsHalfOf(), rhs), lhs));
 }

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

Definition at line 5523 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), IsHalfOf(), testing::Pointwise(), and folly::detail::rhs.

                                                    {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 4, 6};
   const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
   EXPECT_THAT(lhs, Pointwise(m1, rhs));
   EXPECT_EQ("", Explain(Pointwise(m1, rhs), lhs));
 
   // This type works as a tuple<const double&, const int&> can be
   // implicitly cast to tuple<double, int>.
   const Matcher<tuple<double, int> > m2 = IsHalfOf();
   EXPECT_THAT(lhs, Pointwise(m2, rhs));
   EXPECT_EQ("", Explain(Pointwise(m2, rhs), lhs));
 }

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

Definition at line 5537 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, IsHalfOf(), m, folly::detail::rhs, and testing::UnorderedPointwise().

                                             {
   vector<int> rhs;
   rhs.push_back(1);
   rhs.push_back(2);
   rhs.push_back(3);
   const Matcher<const vector<int>&> m = UnorderedPointwise(IsHalfOf(), rhs);
   EXPECT_EQ(
       "has 3 elements and there exists some permutation of elements such "
       "that:\n"
       " - element #0 and 1 are a pair where the first is half of the second, "
       "and\n"
       " - element #1 and 2 are a pair where the first is half of the second, "
       "and\n"
       " - element #2 and 3 are a pair where the first is half of the second",
       Describe(m));
   EXPECT_EQ(
       "doesn't have 3 elements, or there exists no permutation of elements "
       "such that:\n"
       " - element #0 and 1 are a pair where the first is half of the second, "
       "and\n"
       " - element #1 and 2 are a pair where the first is half of the second, "
       "and\n"
       " - element #2 and 3 are a pair where the first is half of the second",
       DescribeNegation(m));
 }

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

Definition at line 5563 of file gmock-matchers_test.cc.

References EXPECT_THAT, IsHalfOf(), m, folly::detail::rhs, and testing::UnorderedPointwise().

                                              {
   list<signed char> rhs;
   rhs.push_back(2);
   rhs.push_back(4);
 
   int lhs[] = {2, 1};
   const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
   EXPECT_THAT(lhs, m);
 
   // Changing rhs now shouldn't affect m, which made a copy of rhs.
   rhs.push_back(6);
   EXPECT_THAT(lhs, m);
 }

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

Definition at line 5577 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Gt(), testing::Lt(), testing::Not(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                      {
   const int lhs[] = {1, 2, 3};
   vector<int> rhs;
   rhs.push_back(4);
   rhs.push_back(6);
   rhs.push_back(2);
   EXPECT_THAT(lhs, UnorderedPointwise(Lt(), rhs));
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
 }

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

Definition at line 5587 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::Gt(), testing::Lt(), testing::Not(), folly::detail::rhs, testing::internal::TEST(), and testing::UnorderedPointwise().

                                                      {
   const int rhs[] = {1, 2, 3};
   vector<int> lhs;
   lhs.push_back(4);
   lhs.push_back(2);
   lhs.push_back(6);
   EXPECT_THAT(lhs, UnorderedPointwise(Gt(), rhs));
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
 }

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

Definition at line 5607 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), testing::Gt(), testing::Not(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                {
   const double lhs[2] = {1, 2};
   const int rhs[1] = {0};
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
   EXPECT_EQ("which has 2 elements",
             Explain(UnorderedPointwise(Gt(), rhs), lhs));
 
   const int rhs2[3] = {0, 1, 2};
   EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs2)));
 }

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

Definition at line 5618 of file gmock-matchers_test.cc.

References EXPECT_EQ, EXPECT_THAT, Explain(), IsHalfOf(), testing::Not(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                   {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 6, 6};
   EXPECT_THAT(lhs, Not(UnorderedPointwise(IsHalfOf(), rhs)));
   EXPECT_EQ("where the following elements don't match any matchers:\n"
             "element #1: 2",
             Explain(UnorderedPointwise(IsHalfOf(), rhs), lhs));
 }

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

Definition at line 5627 of file gmock-matchers_test.cc.

References EXPECT_THAT, IsHalfOf(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                                {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {2, 4, 6};
   EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
 }

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

Definition at line 5633 of file gmock-matchers_test.cc.

References EXPECT_THAT, IsHalfOf(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                                     {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {6, 4, 2};
   EXPECT_THAT(lhs, UnorderedPointwise(IsHalfOf(), rhs));
 }

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

Definition at line 5639 of file gmock-matchers_test.cc.

References EXPECT_THAT, IsHalfOf(), folly::detail::rhs, and testing::UnorderedPointwise().

                                                             {
   const double lhs[3] = {1, 2, 3};
   const int rhs[3] = {4, 6, 2};
   const Matcher<tuple<const double&, const int&> > m1 = IsHalfOf();
   EXPECT_THAT(lhs, UnorderedPointwise(m1, rhs));
 
   // This type works as a tuple<const double&, const int&> can be
   // implicitly cast to tuple<double, int>.
   const Matcher<tuple<double, int> > m2 = IsHalfOf();
   EXPECT_THAT(lhs, UnorderedPointwise(m2, rhs));
 }

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

Definition at line 2902 of file gmock-matchers_test.cc.

References testing::FloatEq().

                                                      {
   TestMatches(&FloatEq);
 }

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

Definition at line 2906 of file gmock-matchers_test.cc.

References testing::NanSensitiveFloatEq().

                                                                  {
   TestMatches(&NanSensitiveFloatEq);
 }

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

Definition at line 2910 of file gmock-matchers_test.cc.

References EXPECT_FALSE, testing::FloatEq(), m, and testing::internal::MatcherBase< T >::Matches().

                                          {
   // FloatEq never matches NaN.
   Matcher<float> m = FloatEq(nan1_);
   EXPECT_FALSE(m.Matches(nan1_));
   EXPECT_FALSE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 2918 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::NanSensitiveFloatEq().

                                                   {
   // NanSensitiveFloatEq will match NaN.
   Matcher<float> m = NanSensitiveFloatEq(nan1_);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 2926 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, f, and testing::FloatEq().

                                           {
   Matcher<float> m1 = FloatEq(2.0f);
   EXPECT_EQ("is approximately 2", Describe(m1));
   EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<float> m2 = FloatEq(0.5f);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
   EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<float> m3 = FloatEq(nan1_);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }

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

Definition at line 2940 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, f, and testing::NanSensitiveFloatEq().

                                                       {
   Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
   EXPECT_EQ("is approximately 2", Describe(m1));
   EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
   EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
   EXPECT_EQ("is NaN", Describe(m3));
   EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }

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

Definition at line 2958 of file gmock-matchers_test.cc.

References testing::FloatNear().

                                         {
   TestNearMatches(&FloatNear);
 }

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

Definition at line 2962 of file gmock-matchers_test.cc.

References testing::NanSensitiveFloatNear().

                                                                        {
   TestNearMatches(&NanSensitiveFloatNear);
 }

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

Definition at line 2966 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, f, and testing::FloatNear().

                                                 {
   Matcher<float> m1 = FloatNear(2.0f, 0.5f);
   EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
   EXPECT_EQ(
       "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
 
   Matcher<float> m2 = FloatNear(0.5f, 0.5f);
   EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
   EXPECT_EQ(
       "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
 
   Matcher<float> m3 = FloatNear(nan1_, 0.0);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }

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

Definition at line 2982 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, f, and testing::NanSensitiveFloatNear().

                                                             {
   Matcher<float> m1 = NanSensitiveFloatNear(2.0f, 0.5f);
   EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
   EXPECT_EQ(
       "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
 
   Matcher<float> m2 = NanSensitiveFloatNear(0.5f, 0.5f);
   EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
   EXPECT_EQ(
       "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
 
   Matcher<float> m3 = NanSensitiveFloatNear(nan1_, 0.1f);
   EXPECT_EQ("is NaN", Describe(m3));
   EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }

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

Definition at line 2998 of file gmock-matchers_test.cc.

References EXPECT_FALSE, f, testing::FloatNear(), m, and testing::internal::MatcherBase< T >::Matches().

                                                {
   // FloatNear never matches NaN.
   Matcher<float> m = FloatNear(ParentType::nan1_, 0.1f);
   EXPECT_FALSE(m.Matches(nan1_));
   EXPECT_FALSE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 3006 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, f, m, testing::internal::MatcherBase< T >::Matches(), and testing::NanSensitiveFloatNear().

                                                         {
   // NanSensitiveFloatNear will match NaN.
   Matcher<float> m = NanSensitiveFloatNear(nan1_, 0.1f);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 3017 of file gmock-matchers_test.cc.

References testing::DoubleEq().

                                                         {
   TestMatches(&DoubleEq);
 }

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

Definition at line 3021 of file gmock-matchers_test.cc.

References testing::NanSensitiveDoubleEq().

                                                                     {
   TestMatches(&NanSensitiveDoubleEq);
 }

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

Definition at line 3025 of file gmock-matchers_test.cc.

References testing::DoubleEq(), EXPECT_FALSE, m, and testing::internal::MatcherBase< T >::Matches().

                                            {
   // DoubleEq never matches NaN.
   Matcher<double> m = DoubleEq(nan1_);
   EXPECT_FALSE(m.Matches(nan1_));
   EXPECT_FALSE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 3033 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::NanSensitiveDoubleEq().

                                                     {
   // NanSensitiveDoubleEq will match NaN.
   Matcher<double> m = NanSensitiveDoubleEq(nan1_);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 3041 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), testing::DoubleEq(), and EXPECT_EQ.

                                             {
   Matcher<double> m1 = DoubleEq(2.0);
   EXPECT_EQ("is approximately 2", Describe(m1));
   EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<double> m2 = DoubleEq(0.5);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
   EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<double> m3 = DoubleEq(nan1_);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }

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

Definition at line 3055 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, and testing::NanSensitiveDoubleEq().

                                                         {
   Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
   EXPECT_EQ("is approximately 2", Describe(m1));
   EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
   EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
   EXPECT_EQ("is NaN", Describe(m3));
   EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }

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

Definition at line 3073 of file gmock-matchers_test.cc.

References testing::DoubleNear().

                                           {
   TestNearMatches(&DoubleNear);
 }

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

Definition at line 3077 of file gmock-matchers_test.cc.

References testing::NanSensitiveDoubleNear().

                                                                           {
   TestNearMatches(&NanSensitiveDoubleNear);
 }

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

Definition at line 3081 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), testing::DoubleNear(), and EXPECT_EQ.

                                                   {
   Matcher<double> m1 = DoubleNear(2.0, 0.5);
   EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
   EXPECT_EQ(
       "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
 
   Matcher<double> m2 = DoubleNear(0.5, 0.5);
   EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
   EXPECT_EQ(
       "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
 
   Matcher<double> m3 = DoubleNear(nan1_, 0.0);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }

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

Definition at line 3097 of file gmock-matchers_test.cc.

References testing::DoubleNear(), EXPECT_EQ, EXPECT_TRUE, and Explain().

                                                      {
   EXPECT_EQ("", Explain(DoubleNear(2.0, 0.1), 2.05));
   EXPECT_EQ("which is 0.2 from 2", Explain(DoubleNear(2.0, 0.1), 2.2));
   EXPECT_EQ("which is -0.3 from 2", Explain(DoubleNear(2.0, 0.1), 1.7));
 
   const string explanation = Explain(DoubleNear(2.1, 1e-10), 2.1 + 1.2e-10);
   // Different C++ implementations may print floating-point numbers
   // slightly differently.
   EXPECT_TRUE(explanation == "which is 1.2e-10 from 2.1" ||  // GCC
               explanation == "which is 1.2e-010 from 2.1")   // MSVC
       << " where explanation is \"" << explanation << "\".";
 }

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

Definition at line 3110 of file gmock-matchers_test.cc.

References Describe(), DescribeNegation(), EXPECT_EQ, and testing::NanSensitiveDoubleNear().

                                                               {
   Matcher<double> m1 = NanSensitiveDoubleNear(2.0, 0.5);
   EXPECT_EQ("is approximately 2 (absolute error <= 0.5)", Describe(m1));
   EXPECT_EQ(
       "isn't approximately 2 (absolute error > 0.5)", DescribeNegation(m1));
 
   Matcher<double> m2 = NanSensitiveDoubleNear(0.5, 0.5);
   EXPECT_EQ("is approximately 0.5 (absolute error <= 0.5)", Describe(m2));
   EXPECT_EQ(
       "isn't approximately 0.5 (absolute error > 0.5)", DescribeNegation(m2));
 
   Matcher<double> m3 = NanSensitiveDoubleNear(nan1_, 0.1);
   EXPECT_EQ("is NaN", Describe(m3));
   EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }

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

Definition at line 3126 of file gmock-matchers_test.cc.

References testing::DoubleNear(), EXPECT_FALSE, m, and testing::internal::MatcherBase< T >::Matches().

                                                  {
   // DoubleNear never matches NaN.
   Matcher<double> m = DoubleNear(ParentType::nan1_, 0.1);
   EXPECT_FALSE(m.Matches(nan1_));
   EXPECT_FALSE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 3134 of file gmock-matchers_test.cc.

References EXPECT_FALSE, EXPECT_TRUE, m, testing::internal::MatcherBase< T >::Matches(), and testing::NanSensitiveDoubleNear().

                                                           {
   // NanSensitiveDoubleNear will match NaN.
   Matcher<double> m = NanSensitiveDoubleNear(nan1_, 0.1);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }

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

Definition at line 4798 of file gmock-matchers_test.cc.

References EXPECT_THAT, testing::gmock_matchers_test::Uncopyable::set_value(), testing::Truly(), testing::UnorderedElementsAre(), and ValueIsPositive().

                                                       {
   Uncopyable objs[2];
   objs[0].set_value(-3);
   objs[1].set_value(1);
   EXPECT_THAT(objs,
               UnorderedElementsAre(Truly(ValueIsPositive), UncopyableIs(-3)));
 }

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

Definition at line 4806 of file gmock-matchers_test.cc.

References a, EXPECT_TRUE, testing::ExplainMatchResult(), GTEST_ARRAY_SIZE_, s, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAre().

                                                        {
   const int a[] = {1, 2, 3};
   std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   do {
     StringMatchResultListener listener;
     EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
                                    s, &listener)) << listener.str();
   } while (std::next_permutation(s.begin(), s.end()));
 }

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

Definition at line 4816 of file gmock-matchers_test.cc.

References a, EXPECT_FALSE, testing::ExplainMatchResult(), GTEST_ARRAY_SIZE_, s, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAreArray().

                                                                      {
   const int a[] = {1, 2, 3};
   std::vector<int> s(a, a + GTEST_ARRAY_SIZE_(a));
   std::vector<Matcher<int> > mv;
   mv.push_back(1);
   mv.push_back(2);
   mv.push_back(2);
   // The element with value '3' matches nothing: fail fast.
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAreArray(mv),
                                   s, &listener)) << listener.str();
 }

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

Definition at line 4829 of file gmock-matchers_test.cc.

References a, EXPECT_THAT, GTEST_ARRAY_SIZE_, testing::Not(), s, and testing::UnorderedElementsAre().

                                                      {
   // Streamlike 'container' provides only minimal iterator support.
   // Its iterators are tagged with input_iterator_tag, and it has no
   // size() or empty() methods.
   const int a[5] = {2, 1, 4, 5, 3};
   Streamlike<int> s(a, a + GTEST_ARRAY_SIZE_(a));
 
   EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
   EXPECT_THAT(s, Not(UnorderedElementsAre(2, 2, 3, 4, 5)));
 }

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

Definition at line 4846 of file gmock-matchers_test.cc.

References testing::_, testing::Eq(), EXPECT_TRUE, testing::ExplainMatchResult(), i, s, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAreArray().

                                               {
   std::vector<int> s;
   std::vector<Matcher<int> > mv;
   for (int i = 0; i < 100; ++i) {
     s.push_back(i);
     mv.push_back(_);
   }
   mv[50] = Eq(0);
   StringMatchResultListener listener;
   EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
                                  s, &listener)) << listener.str();
 }

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

Definition at line 4862 of file gmock-matchers_test.cc.

References testing::_, EXPECT_TRUE, testing::ExplainMatchResult(), i, s, testing::StringMatchResultListener::str(), and testing::UnorderedElementsAreArray().

                                                         {
   std::vector<int> s;
   std::vector<Matcher<int> > mv;
   for (int i = 0; i < 100; ++i) {
     s.push_back(i);
     if (i & 1) {
       mv.push_back(_);
     } else {
       mv.push_back(i);
     }
   }
   StringMatchResultListener listener;
   EXPECT_TRUE(ExplainMatchResult(UnorderedElementsAreArray(mv),
                                  s, &listener)) << listener.str();
 }

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

Definition at line 4878 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                         {
   std::vector<int> v;
   v.push_back(4);
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
                                   v, &listener)) << listener.str();
   EXPECT_THAT(listener.str(), Eq("which has 1 element"));
 }

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

Definition at line 4887 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                             {
   std::vector<int> v;
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3),
                                   v, &listener)) << listener.str();
   EXPECT_THAT(listener.str(), Eq(""));
 }

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

Definition at line 4895 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                                {
   std::vector<int> v;
   v.push_back(1);
   v.push_back(1);
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
                                   v, &listener)) << listener.str();
   EXPECT_THAT(
       listener.str(),
       Eq("where the following matchers don't match any elements:\n"
          "matcher #1: is equal to 2"));
 }

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

Definition at line 4908 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                                {
   std::vector<int> v;
   v.push_back(1);
   v.push_back(2);
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 1),
                                   v, &listener)) << listener.str();
   EXPECT_THAT(
       listener.str(),
       Eq("where the following elements don't match any matchers:\n"
          "element #1: 2"));
 }

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

Definition at line 4921 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                                         {
   std::vector<int> v;
   v.push_back(2);
   v.push_back(3);
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2),
                                   v, &listener)) << listener.str();
   EXPECT_THAT(
       listener.str(),
       Eq("where"
          " the following matchers don't match any elements:\n"
          "matcher #0: is equal to 1\n"
          "and"
          " where"
          " the following elements don't match any matchers:\n"
          "element #1: 3"));
 }

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

Definition at line 4946 of file gmock-matchers_test.cc.

References testing::AnyOf(), EMString(), EXPECT_FALSE, EXPECT_THAT, testing::ExplainMatchResult(), prefix(), testing::StringMatchResultListener::str(), testing::UnorderedElementsAre(), and v.

                                                                 {
   // A situation where all elements and matchers have a match
   // associated with them, but the max matching is not perfect.
   std::vector<string> v;
   v.push_back("a");
   v.push_back("b");
   v.push_back("c");
   StringMatchResultListener listener;
   EXPECT_FALSE(ExplainMatchResult(
       UnorderedElementsAre("a", "a", AnyOf("b", "c")), v, &listener))
       << listener.str();
 
   string prefix =
       "where no permutation of the elements can satisfy all matchers, "
       "and the closest match is 2 of 3 matchers with the "
       "pairings:\n";
 
   // We have to be a bit loose here, because there are 4 valid max matches.
   EXPECT_THAT(
       listener.str(),
       AnyOf(prefix + "{\n  " + EMString(0, 0) +
                      ",\n  " + EMString(1, 2) + "\n}",
             prefix + "{\n  " + EMString(0, 1) +
                      ",\n  " + EMString(1, 2) + "\n}",
             prefix + "{\n  " + EMString(0, 0) +
                      ",\n  " + EMString(2, 2) + "\n}",
             prefix + "{\n  " + EMString(0, 1) +
                      ",\n  " + EMString(2, 2) + "\n}"));
 }

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

Definition at line 4976 of file gmock-matchers_test.cc.

References testing::Eq(), EXPECT_THAT, and testing::UnorderedElementsAre().

                                            {
   EXPECT_THAT(Describe<IntVec>(UnorderedElementsAre()),
               Eq("is empty"));
   EXPECT_THAT(
       Describe<IntVec>(UnorderedElementsAre(345)),
       Eq("has 1 element and that element is equal to 345"));
   EXPECT_THAT(
       Describe<IntVec>(UnorderedElementsAre(111, 222, 333)),
       Eq("has 3 elements and there exists some permutation "
          "of elements such that:\n"
          " - element #0 is equal to 111, and\n"
          " - element #1 is equal to 222, and\n"
          " - element #2 is equal to 333"));
 }

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

Definition at line 4991 of file gmock-matchers_test.cc.

References best_so_far_, testing::Eq(), EXPECT_THAT, g(), graph_, kUnused, lhs_used_, matches_, rhs_used_, and testing::UnorderedElementsAre().

                                                    {
   EXPECT_THAT(DescribeNegation<IntVec>(UnorderedElementsAre()),
               Eq("isn't empty"));
   EXPECT_THAT(
       DescribeNegation<IntVec>(UnorderedElementsAre(345)),
       Eq("doesn't have 1 element, or has 1 element that isn't equal to 345"));
   EXPECT_THAT(
       DescribeNegation<IntVec>(UnorderedElementsAre(123, 234, 345)),
       Eq("doesn't have 3 elements, or there exists no permutation "
          "of elements such that:\n"
          " - element #0 is equal to 123, and\n"
          " - element #1 is equal to 234, and\n"
          " - element #2 is equal to 345"));
 }

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

Definition at line 5135 of file gmock-matchers_test.cc.

References testing::AnyOf(), testing::internal::MatchMatrix::DebugString(), testing::ElementsAre(), EXPECT_THAT, FindBacktrackingMaxBPM(), g(), GTEST_ARRAY_SIZE_, i, testing::Pair(), and testing::internal::MatchMatrix::SetEdge().

                                                    {
   //   .......
   // 0:-----\ :
   // 1:---\ | :
   // 2:---\ | :
   // 3:-\ | | :
   //  :.......:
   //    0 1 2
   MatchMatrix g(4, 3);
   static const int kEdges[][2] = {{0, 2}, {1, 1}, {2, 1}, {3, 0}};
   for (size_t i = 0; i < GTEST_ARRAY_SIZE_(kEdges); ++i) {
     g.SetEdge(kEdges[i][0], kEdges[i][1], true);
   }
   EXPECT_THAT(FindBacktrackingMaxBPM(g),
               ElementsAre(Pair(3, 0),
                           Pair(AnyOf(1, 2), 1),
                           Pair(0, 2))) << g.DebugString();
 }

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

Definition at line 5102 of file gmock-matchers_test.cc.

References testing::internal::MatchMatrix::DebugString(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, FindBacktrackingMaxBPM(), testing::internal::FindMaxBipartiteMatching(), testing::internal::MatchMatrix::HasEdge(), i, testing::INSTANTIATE_TEST_CASE_P(), testing::internal::MatchMatrix::LhsSize(), testing::internal::MatchMatrix::NextGraph(), testing::PrintToString(), testing::internal::MatchMatrix::RhsSize(), SCOPED_TRACE, and folly::size().

                                   {
   int nodes = GetParam();
   MatchMatrix graph(nodes, nodes);
   do {
     ElementMatcherPairs matches =
         internal::FindMaxBipartiteMatching(graph);
     EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(), matches.size())
         << "graph: " << graph.DebugString();
     // Check that all elements of matches are in the graph.
     // Check that elements of first and second are unique.
     std::vector<bool> seen_element(graph.LhsSize());
     std::vector<bool> seen_matcher(graph.RhsSize());
     SCOPED_TRACE(PrintToString(matches));
     for (size_t i = 0; i < matches.size(); ++i) {
       size_t ilhs = matches[i].first;
       size_t irhs = matches[i].second;
       EXPECT_TRUE(graph.HasEdge(ilhs, irhs));
       EXPECT_FALSE(seen_element[ilhs]);
       EXPECT_FALSE(seen_matcher[irhs]);
       seen_element[ilhs] = true;
       seen_matcher[irhs] = true;
     }
   } while (graph.NextGraph());
 }

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

Definition at line 5155 of file gmock-matchers_test.cc.

References testing::internal::MatchMatrix::DebugString(), EXPECT_EQ, FindBacktrackingMaxBPM(), testing::internal::FindMaxBipartiteMatching(), testing::INSTANTIATE_TEST_CASE_P(), testing::internal::MatchMatrix::NextGraph(), testing::PrintToString(), and folly::size().

                                            {
   size_t nlhs = GetParam().first;
   size_t nrhs = GetParam().second;
   MatchMatrix graph(nlhs, nrhs);
   do {
     EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
               internal::FindMaxBipartiteMatching(graph).size())
         << "graph: " << graph.DebugString()
         << "\nbacktracking: "
         << PrintToString(FindBacktrackingMaxBPM(graph))
         << "\nmax flow: "
         << PrintToString(internal::FindMaxBipartiteMatching(graph));
   } while (graph.NextGraph());
 }

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

Definition at line 5186 of file gmock-matchers_test.cc.

References testing::internal::MatchMatrix::DebugString(), EXPECT_EQ, FindBacktrackingMaxBPM(), testing::internal::FindMaxBipartiteMatching(), GTEST_FLAG, GTEST_FLAG_PREFIX_, testing::INSTANTIATE_TEST_CASE_P(), testing::internal::MatchMatrix::Randomize(), seed, folly::size(), and folly::detail::distributed_mutex::time().

                                         {
   int nodes = GetParam().first;
   int iters = GetParam().second;
   MatchMatrix graph(nodes, nodes);
 
   testing::internal::Int32 seed = GTEST_FLAG(random_seed);
   if (seed == 0) {
     seed = static_cast<testing::internal::Int32>(time(NULL));
   }
 
   for (; iters > 0; --iters, ++seed) {
     srand(static_cast<int>(seed));
     graph.Randomize();
     EXPECT_EQ(FindBacktrackingMaxBPM(graph).size(),
               internal::FindMaxBipartiteMatching(graph).size())
         << " graph: " << graph.DebugString()
         << "\nTo reproduce the failure, rerun the test with the flag"
            " --" << GTEST_FLAG_PREFIX_ << "random_seed=" << seed;
   }
 }