gmock-matchers.h File Reference

#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"

Go to the source code of this file.

Classes
class	testing::MatchResultListener
class	testing::MatcherDescriberInterface
class	testing::MatcherInterface< T >
class	testing::StringMatchResultListener
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::IsNullMatcher
class	testing::internal::NotNullMatcher
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::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::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::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 >

Namespaces
namespace	testing
namespace	testing::internal

Macros
#define	GMOCK_IMPLEMENT_COMPARISON_MATCHER_(name, op, relation, negated_relation)
#define	GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(name, op, relation)
#define	ASSERT_THAT(value, matcher)
#define	EXPECT_THAT(value, matcher)

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 (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)
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Eq,==, "is equal to", "isn't equal to")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Ge, >=, "is >=", "isn't >=")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Gt, >, "is >", "isn't >")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Le,<=, "is <=", "isn't <=")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Lt,<, "is <", "isn't <")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON_MATCHER_ (Ne, !=, "isn't equal to", "is equal to")
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)
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Eq,==, "an equal pair")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Ge, >=, "a pair where the first >= the second")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Gt, >, "a pair where the first > the second")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Le,<=, "a pair where the first <= the second")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Lt,<, "a pair where the first < the second")
	testing::internal::GMOCK_IMPLEMENT_COMPARISON2_MATCHER_ (Ne, !=, "an unequal pair")
template<typename M>
PredicateFormatterFromMatcher< M >	testing::internal::MakePredicateFormatterFromMatcher (const M &matcher)
GTEST_API_ ElementMatcherPairs	testing::internal::FindMaxBipartiteMatching (const MatchMatrix &g)
GTEST_API_ bool	testing::internal::FindPairing (const MatchMatrix &matrix, MatchResultListener *listener)
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 T, typename A>
internal::ElementsAreArrayMatcher< T >	testing::ElementsAreArray (const ::std::vector< T, A > &vec)
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 T, typename A>
internal::UnorderedElementsAreArrayMatcher< T >	testing::UnorderedElementsAreArray (const ::std::vector< T, A > &vec)
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 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 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 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)

Macro Definition Documentation

ASSERT_THAT

#define ASSERT_THAT	(		value,
			matcher )

Value:

ASSERT_PRED_FORMAT1(\
::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)

EXPECT_THAT

#define EXPECT_THAT	(		value,
			matcher )

Value:

EXPECT_PRED_FORMAT1(\
::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)

GMOCK_IMPLEMENT_COMPARISON2_MATCHER_

#define GMOCK_IMPLEMENT_COMPARISON2_MATCHER_	(		name,
			op,
			relation )

Value:

class name##2Matcher { \
 public: \
  template <typename T1, typename T2> \
  operator Matcher< ::std::tr1::tuple<T1, T2> >() const { \
    return MakeMatcher(new Impl< ::std::tr1::tuple<T1, T2> >); \
  } \
  template <typename T1, typename T2> \
  operator Matcher<const ::std::tr1::tuple<T1, T2>&>() const { \
    return MakeMatcher(new Impl<const ::std::tr1::tuple<T1, T2>&>); \
  } \
 private: \
  template <typename Tuple> \
  class Impl : public MatcherInterface<Tuple> { \
   public: \
    virtual bool MatchAndExplain( \
        Tuple args, \
        MatchResultListener* /* listener */) const { \
      return ::std::tr1::get<0>(args) op ::std::tr1::get<1>(args); \
    } \
    virtual void DescribeTo(::std::ostream* os) const { \
      *os << "are " relation;                                 \
    } \
    virtual void DescribeNegationTo(::std::ostream* os) const { \
      *os << "aren't " relation; \
    } \
  }; \
}

GMOCK_IMPLEMENT_COMPARISON_MATCHER_

#define GMOCK_IMPLEMENT_COMPARISON_MATCHER_	(		name,
			op,
			relation,
			negated_relation )