Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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"
#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::PolymorphicMatcher< Impl >::MonomorphicImpl< T >
 
class  testing::internal::MatcherCastImpl< T, M >
 
class  testing::internal::MatcherCastImpl< T, Matcher< U > >
 
class  testing::internal::MatcherCastImpl< T, Matcher< U > >::Impl
 
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 >
 
struct  testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >::IterateOverTuple< Tup, kRemainingSize >
 
struct  testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >::IterateOverTuple< Tup, 0 >
 
class  testing::internal::AnyMatcherImpl< T >
 
class  testing::internal::AnythingMatcher
 
class  testing::internal::ComparisonBase< D, Rhs, Op >
 
class  testing::internal::ComparisonBase< D, Rhs, Op >::Impl< Lhs >
 
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  RefMatcher< T >
 
class  testing::internal::RefMatcher< T & >
 
class  testing::internal::RefMatcher< T & >::Impl< Super >
 
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::PairMatchBase< D, Op >::Impl< Tuple >
 
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::PointeeMatcher< InnerMatcher >::Impl< Pointer >
 
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::ResultOfMatcher< Callable >::Impl< T >
 
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 >
 
class  testing::internal::BoundSecondMatcher< Tuple2Matcher, Second >::Impl< T >
 

Namespaces

namespace  testing
 
namespace  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< Ttesting::MakeMatcher (const MatcherInterface< T > *impl)
 
template<class Impl >
PolymorphicMatcher< Impl > testing::MakePolymorphicMatcher (const Impl &impl)
 
template<typename T , typename M >
Matcher< Ttesting::MatcherCast (const M &matcher)
 
template<typename T , typename M >
Matcher< Ttesting::SafeMatcherCast (const M &polymorphic_matcher)
 
template<typename T >
Matcher< Ttesting::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< Ttesting::An ()
 
template<typename T >
internal::EqMatcher< Ttesting::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)
 

Variables

const internal::AnythingMatcher testing::_ = {}
 

Macro Definition Documentation

#define ASSERT_THAT (   value,
  matcher 
)
Value:

Definition at line 4388 of file gmock-matchers.h.

View newest version in sPHENIX GitHub at line 4388 of file gmock-matchers.h

Referenced by testing::gmock_matchers_test::TEST().

#define EXPECT_THAT (   value,
  matcher 
)
Value:

Definition at line 4390 of file gmock-matchers.h.

View newest version in sPHENIX GitHub at line 4390 of file gmock-matchers.h

Referenced by testing::gmock_matchers_test::TEST(), and testing::gmock_matchers_test::TEST_F().