#include <math.h>
#include <algorithm>
#include <iterator>
#include <limits>
#include <ostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h"
#include "gmock/internal/custom/gmock-matchers.h"

Include dependency graph for gmock-matchers.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	testing::MatchResultListener

class	testing::MatcherDescriberInterface

class	testing::MatcherInterface< T >

class	testing::StringMatchResultListener

struct	testing::internal::AnyEq

struct	testing::internal::AnyNe

struct	testing::internal::AnyLt

struct	testing::internal::AnyGt

struct	testing::internal::AnyLe

struct	testing::internal::AnyGe

class	testing::internal::DummyMatchResultListener

class	testing::internal::StreamMatchResultListener

class	testing::internal::MatcherBase< T >

class	testing::Matcher< T >

class	testing::Matcher< const internal::string &>

class	testing::Matcher< internal::string >

class	testing::PolymorphicMatcher< Impl >

class	testing::internal::MatcherCastImpl< T, M >

class	testing::internal::MatcherCastImpl< T, Matcher< U > >

class	testing::internal::MatcherCastImpl< T, Matcher< T > >

class	testing::SafeMatcherCastImpl< T >

class	testing::internal::TuplePrefix< N >

class	testing::internal::TuplePrefix< 0 >

class	testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >

class	testing::internal::AnyMatcherImpl< T >

class	testing::internal::AnythingMatcher

class	testing::internal::ComparisonBase< D, Rhs, Op >

class	testing::internal::EqMatcher< Rhs >

class	testing::internal::NeMatcher< Rhs >

class	testing::internal::LtMatcher< Rhs >

class	testing::internal::GtMatcher< Rhs >

class	testing::internal::LeMatcher< Rhs >

class	testing::internal::GeMatcher< Rhs >

class	testing::internal::IsNullMatcher

class	testing::internal::NotNullMatcher

class	testing::internal::RefMatcher< T >

class	testing::internal::RefMatcher< T & >

class	testing::internal::StrEqualityMatcher< StringType >

class	testing::internal::HasSubstrMatcher< StringType >

class	testing::internal::StartsWithMatcher< StringType >

class	testing::internal::EndsWithMatcher< StringType >

class	testing::internal::MatchesRegexMatcher

class	testing::internal::PairMatchBase< D, Op >

class	testing::internal::Eq2Matcher

class	testing::internal::Ne2Matcher

class	testing::internal::Lt2Matcher

class	testing::internal::Gt2Matcher

class	testing::internal::Le2Matcher

class	testing::internal::Ge2Matcher

class	testing::internal::NotMatcherImpl< T >

class	testing::internal::NotMatcher< InnerMatcher >

class	testing::internal::BothOfMatcherImpl< T >

class	testing::internal::BothOfMatcher< Matcher1, Matcher2 >

class	testing::internal::EitherOfMatcherImpl< T >

class	testing::internal::EitherOfMatcher< Matcher1, Matcher2 >

class	testing::internal::TrulyMatcher< Predicate >

class	testing::internal::MatcherAsPredicate< M >

class	testing::internal::PredicateFormatterFromMatcher< M >

class	testing::internal::FloatingEqMatcher< FloatType >

class	testing::internal::FloatingEqMatcher< FloatType >::Impl< T >

class	testing::internal::PointeeMatcher< InnerMatcher >

class	testing::internal::WhenDynamicCastToMatcherBase< To >

class	testing::internal::WhenDynamicCastToMatcher< To >

class	testing::internal::WhenDynamicCastToMatcher< To & >

class	testing::internal::FieldMatcher< Class, FieldType >

class	testing::internal::PropertyMatcher< Class, PropertyType >

struct	testing::internal::CallableTraits< Functor >

struct	testing::internal::CallableTraits< ResType(*)(ArgType)>

class	testing::internal::ResultOfMatcher< Callable >

class	testing::internal::SizeIsMatcher< SizeMatcher >

class	testing::internal::SizeIsMatcher< SizeMatcher >::Impl< Container >

class	testing::internal::BeginEndDistanceIsMatcher< DistanceMatcher >

class	testing::internal::BeginEndDistanceIsMatcher< DistanceMatcher >::Impl< Container >

class	testing::internal::ContainerEqMatcher< Container >

struct	testing::internal::LessComparator

class	testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >

class	testing::internal::WhenSortedByMatcher< Comparator, ContainerMatcher >::Impl< LhsContainer >

class	testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >

class	testing::internal::PointwiseMatcher< TupleMatcher, RhsContainer >::Impl< LhsContainer >

class	testing::internal::QuantifierMatcherImpl< Container >

class	testing::internal::ContainsMatcherImpl< Container >

class	testing::internal::EachMatcherImpl< Container >

class	testing::internal::ContainsMatcher< M >

class	testing::internal::EachMatcher< M >

class	testing::internal::KeyMatcherImpl< PairType >

class	testing::internal::KeyMatcher< M >

class	testing::internal::PairMatcherImpl< PairType >

class	testing::internal::PairMatcher< FirstMatcher, SecondMatcher >

class	testing::internal::ElementsAreMatcherImpl< Container >

class	testing::internal::MatchMatrix

class	testing::internal::UnorderedElementsAreMatcherImplBase

class	testing::internal::UnorderedElementsAreMatcherImpl< Container >

struct	testing::internal::CastAndAppendTransform< Target >

class	testing::internal::UnorderedElementsAreMatcher< MatcherTuple >

class	testing::internal::ElementsAreMatcher< MatcherTuple >

class	testing::internal::UnorderedElementsAreArrayMatcher< T >

class	testing::internal::ElementsAreArrayMatcher< T >

class	testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >

Namespaces
	testing

	testing::internal

Macros
#define	ASSERT_THAT(value, matcher)

#define	EXPECT_THAT(value, matcher)

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

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

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

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

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

template<typename T , typename M >
Matcher< T >	testing::SafeMatcherCast (const M &polymorphic_matcher)

template<typename T >
Matcher< T >	testing::A ()

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

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

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

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

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

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

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

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

template<typename StringType >
bool	testing::internal::CaseInsensitiveStringEquals (const StringType &s1, const StringType &s2)

template<typename M >
PredicateFormatterFromMatcher< M >	testing::internal::MakePredicateFormatterFromMatcher (M matcher)

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

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

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

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

template<typename Iter >
internal::ElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type >	testing::ElementsAreArray (Iter first, Iter last)

template<typename T >
internal::ElementsAreArrayMatcher< T >	testing::ElementsAreArray (const T *pointer, size_t count)

template<typename T , size_t N>
internal::ElementsAreArrayMatcher< T >	testing::ElementsAreArray (const T(&array)[N])

template<typename Container >
internal::ElementsAreArrayMatcher< typename Container::value_type >	testing::ElementsAreArray (const Container &container)

template<typename Iter >
internal::UnorderedElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type >	testing::UnorderedElementsAreArray (Iter first, Iter last)

template<typename T >
internal::UnorderedElementsAreArrayMatcher< T >	testing::UnorderedElementsAreArray (const T *pointer, size_t count)

template<typename T , size_t N>
internal::UnorderedElementsAreArrayMatcher< T >	testing::UnorderedElementsAreArray (const T(&array)[N])

template<typename Container >
internal::UnorderedElementsAreArrayMatcher< typename Container::value_type >	testing::UnorderedElementsAreArray (const Container &container)

template<typename T >
Matcher< T >	testing::An ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename InnerMatcher >
internal::PointeeMatcher< InnerMatcher >	testing::Pointee (const InnerMatcher &inner_matcher)

template<typename To >
PolymorphicMatcher< internal::WhenDynamicCastToMatcher< To > >	testing::WhenDynamicCastTo (const Matcher< To > &inner_matcher)

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

template<typename Class , typename PropertyType , typename PropertyMatcher >
PolymorphicMatcher< internal::PropertyMatcher< Class, PropertyType > >	testing::Property (PropertyType(Class::*property)() const, const PropertyMatcher &matcher)

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

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

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

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

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

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

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

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

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

PolymorphicMatcher< internal::MatchesRegexMatcher >	testing::MatchesRegex (const internal::string &regex)

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

PolymorphicMatcher< internal::MatchesRegexMatcher >	testing::ContainsRegex (const internal::string &regex)

internal::Eq2Matcher	testing::Eq ()

internal::Ge2Matcher	testing::Ge ()

internal::Gt2Matcher	testing::Gt ()

internal::Le2Matcher	testing::Le ()

internal::Lt2Matcher	testing::Lt ()

internal::Ne2Matcher	testing::Ne ()

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

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

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

template<typename DistanceMatcher >
internal::BeginEndDistanceIsMatcher< DistanceMatcher >	testing::BeginEndDistanceIs (const DistanceMatcher &distance_matcher)

template<typename Container >
PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> >	testing::ContainerEq (const Container &rhs)

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

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

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

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

template<typename M >
internal::ContainsMatcher< M >	testing::Contains (M matcher)

template<typename M >
internal::EachMatcher< M >	testing::Each (M matcher)

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

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

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

template<typename T , typename M >
bool	testing::Value (const T &value, M matcher)

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

template<typename InnerMatcher >
InnerMatcher	testing::AllArgs (const InnerMatcher &matcher)