38 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 39 #define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 53 #include "gtest/gtest.h" 55 #if GTEST_HAS_STD_INITIALIZER_LIST_ 56 # include <initializer_list> 98 ::std::ostream*
stream() {
return stream_; }
107 ::std::ostream*
const stream_;
126 virtual void DescribeTo(::std::ostream* os)
const = 0;
142 template <
typename T>
195 ::std::stringstream ss_;
203 template <
typename A,
typename B>
207 template <
typename A,
typename B>
211 template <
typename A,
typename B>
215 template <
typename A,
typename B>
219 template <
typename A,
typename B>
223 template <
typename A,
typename B>
251 template <
typename T>
257 return impl_->MatchAndExplain(x, listener);
267 void DescribeTo(::std::ostream* os)
const { impl_->DescribeTo(os); }
271 impl_->DescribeNegationTo(os);
318 template <
typename T>
372 #if GTEST_HAS_STRING_PIECE_ 378 :
public internal::MatcherBase<const StringPiece&> {
382 explicit Matcher(
const MatcherInterface<const StringPiece&>* impl)
383 :
internal::MatcherBase<const StringPiece&>(impl) {}
390 Matcher(
const char* s);
393 Matcher(StringPiece s);
398 :
public internal::MatcherBase<StringPiece> {
402 explicit Matcher(
const MatcherInterface<StringPiece>* impl)
403 :
internal::MatcherBase<StringPiece>(impl) {}
410 Matcher(
const char* s);
413 Matcher(StringPiece s);
415 #endif // GTEST_HAS_STRING_PIECE_ 429 template <
class Impl>
440 const Impl&
impl()
const {
return impl_; }
442 template <
typename T>
444 return Matcher<T>(
new MonomorphicImpl<T>(impl_));
448 template <
typename T>
451 explicit MonomorphicImpl(
const Impl&
impl) : impl_(
impl) {}
453 virtual void DescribeTo(::std::ostream* os)
const {
454 impl_.DescribeTo(os);
457 virtual void DescribeNegationTo(::std::ostream* os)
const {
458 impl_.DescribeNegationTo(os);
461 virtual bool MatchAndExplain(
T x, MatchResultListener* listener)
const {
462 return impl_.MatchAndExplain(x, listener);
483 template <
typename T>
495 template <
class Impl>
514 template <
typename T,
typename M>
532 polymorphic_matcher_or_value,
545 static Matcher<T> CastImpl(
const M& polymorphic_matcher_or_value,
546 BooleanConstant<true>) {
555 return polymorphic_matcher_or_value;
562 template <
typename T,
typename U>
572 explicit Impl(
const Matcher<U>& source_matcher)
573 : source_matcher_(source_matcher) {}
577 return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
580 virtual void DescribeTo(::std::ostream* os)
const {
581 source_matcher_.DescribeTo(os);
584 virtual void DescribeNegationTo(::std::ostream* os)
const {
585 source_matcher_.DescribeNegationTo(os);
589 const Matcher<U> source_matcher_;
597 template <
typename T>
609 template <
typename T,
typename M>
621 template <
typename T>
626 template <
typename M>
640 template <
typename U>
644 T_must_be_implicitly_convertible_to_U);
649 cannot_convert_non_referentce_arg_to_reference);
657 kTIsOther || kUIsOther ||
659 conversion_of_arithmetic_types_must_be_lossless);
660 return MatcherCast<T>(matcher);
664 template <
typename T,
typename M>
670 template <
typename T>
679 ::std::ostream* os) {
680 if (explanation !=
"" && os != NULL) {
681 *os <<
", " << explanation;
691 return (type_name.length() <= 20 ||
692 type_name.find_first_of(
"<(") == string::npos);
700 template <
typename Value,
typename T>
714 const string& type_name = GetTypeName<Value>();
716 *listener->
stream() <<
" (of type " << type_name <<
")";
731 template <
typename MatcherTuple,
typename ValueTuple>
733 const ValueTuple& value_tuple) {
735 &&
get<N - 1>(matcher_tuple).
Matches(get<N - 1>(value_tuple));
742 template <
typename MatcherTuple,
typename ValueTuple>
744 const ValueTuple& values,
745 ::std::ostream* os) {
751 typename tuple_element<N - 1,
MatcherTuple>::type matcher =
752 get<N - 1>(matchers);
753 typedef typename tuple_element<N - 1, ValueTuple>::type
Value;
756 if (!matcher.MatchAndExplain(
value, &listener)) {
759 *os <<
" Expected arg #" << N - 1 <<
": ";
760 get<N - 1>(matchers).DescribeTo(os);
761 *os <<
"\n Actual: ";
778 template <
typename MatcherTuple,
typename ValueTuple>
780 const ValueTuple& ) {
784 template <
typename MatcherTuple,
typename ValueTuple>
795 template <
typename MatcherTuple,
typename ValueTuple>
797 const ValueTuple& value_tuple) {
802 matcher_and_value_have_different_numbers_of_fields);
804 Matches(matcher_tuple, value_tuple);
809 template <
typename MatcherTuple,
typename ValueTuple>
811 const ValueTuple& values,
812 ::std::ostream* os) {
814 matchers, values, os);
821 template <
typename Tuple,
typename Func,
typename OutIter>
824 typedef ::testing::tuple_size<Tuple> TupleSize;
829 static OutIter
Run(Func f,
const Tuple& t, OutIter out) {
830 return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
834 template <
typename Tup,
size_t kRemainingSize>
835 struct IterateOverTuple {
836 OutIter operator() (Func f,
const Tup& t, OutIter out)
const {
837 *out++ = f(::testing::get<TupleSize::value - kRemainingSize>(t));
838 return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
841 template <
typename Tup>
842 struct IterateOverTuple<Tup, 0> {
843 OutIter operator() (Func ,
const Tup& , OutIter out)
const {
852 template <
typename Tuple,
typename Func,
typename OutIter>
858 template <
typename T>
863 virtual void DescribeTo(::std::ostream* os)
const { *os <<
"is anything"; }
868 *os <<
"never matches";
878 template <
typename T>
892 template <
typename D,
typename Rhs,
typename Op>
896 template <
typename Lhs>
902 template <
typename Lhs>
905 explicit Impl(
const Rhs& rhs) : rhs_(rhs) {}
906 virtual bool MatchAndExplain(
908 return Op()(lhs, rhs_);
910 virtual void DescribeTo(::std::ostream* os)
const {
911 *os << D::Desc() <<
" ";
914 virtual void DescribeNegationTo(::std::ostream* os)
const {
915 *os << D::NegatedDesc() <<
" ";
926 template <
typename Rhs>
931 static const char*
Desc() {
return "is equal to"; }
934 template <
typename Rhs>
939 static const char*
Desc() {
return "isn't equal to"; }
942 template <
typename Rhs>
947 static const char*
Desc() {
return "is <"; }
950 template <
typename Rhs>
955 static const char*
Desc() {
return "is >"; }
958 template <
typename Rhs>
963 static const char*
Desc() {
return "is <="; }
966 template <
typename Rhs>
971 static const char*
Desc() {
return "is >="; }
979 template <
typename Po
inter>
984 #else // GTEST_LANG_CXX11 986 #endif // GTEST_LANG_CXX11 989 void DescribeTo(::std::ostream* os)
const { *os <<
"is NULL"; }
999 template <
typename Po
inter>
1002 #if GTEST_LANG_CXX11 1003 return p !=
nullptr;
1004 #else // GTEST_LANG_CXX11 1006 #endif // GTEST_LANG_CXX11 1009 void DescribeTo(::std::ostream* os)
const { *os <<
"isn't NULL"; }
1028 template <
typename T>
1031 template <
typename T>
1044 template <
typename Super>
1055 template <
typename Super>
1058 explicit Impl(Super& x) : object_(x) {}
1062 virtual bool MatchAndExplain(
1064 *listener <<
"which is located @" <<
static_cast<const void*
>(&x);
1065 return &x == &object_;
1068 virtual void DescribeTo(::std::ostream* os)
const {
1069 *os <<
"references the variable ";
1073 virtual void DescribeNegationTo(::std::ostream* os)
const {
1074 *os <<
"does not reference the variable ";
1079 const Super& object_;
1095 const wchar_t* rhs) {
1101 template <
typename StringType>
1103 const StringType& s2) {
1110 const typename StringType::value_type nul = 0;
1111 const size_t i1 = s1.find(nul), i2 = s2.find(nul);
1114 if (i1 == StringType::npos || i2 == StringType::npos) {
1125 template <
typename StringType>
1129 bool case_sensitive)
1130 : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
1137 template <
typename CharType>
1149 template <
typename MatcheeStringType>
1152 const StringType& s2(s);
1153 const bool eq = case_sensitive_ ? s2 == string_ :
1155 return expect_eq_ == eq;
1159 DescribeToHelper(expect_eq_, os);
1163 DescribeToHelper(!expect_eq_, os);
1167 void DescribeToHelper(
bool expect_eq, ::std::ostream* os)
const {
1168 *os << (expect_eq ?
"is " :
"isn't ");
1170 if (!case_sensitive_) {
1171 *os <<
"(ignoring case) ";
1176 const StringType string_;
1177 const bool expect_eq_;
1178 const bool case_sensitive_;
1186 template <
typename StringType>
1190 : substring_(substring) {}
1197 template <
typename CharType>
1206 template <
typename MatcheeStringType>
1209 const StringType& s2(s);
1210 return s2.find(substring_) != StringType::npos;
1215 *os <<
"has substring ";
1220 *os <<
"has no substring ";
1225 const StringType substring_;
1233 template <
typename StringType>
1244 template <
typename CharType>
1253 template <
typename MatcheeStringType>
1256 const StringType& s2(s);
1257 return s2.length() >= prefix_.length() &&
1258 s2.substr(0, prefix_.length()) == prefix_;
1262 *os <<
"starts with ";
1267 *os <<
"doesn't start with ";
1272 const StringType prefix_;
1280 template <
typename StringType>
1290 template <
typename CharType>
1299 template <
typename MatcheeStringType>
1302 const StringType& s2(s);
1303 return s2.length() >= suffix_.length() &&
1304 s2.substr(s2.length() - suffix_.length()) == suffix_;
1308 *os <<
"ends with ";
1313 *os <<
"doesn't end with ";
1318 const StringType suffix_;
1329 : regex_(regex), full_match_(full_match) {}
1336 template <
typename CharType>
1345 template <
class MatcheeStringType>
1354 *os << (full_match_ ?
"matches" :
"contains")
1355 <<
" regular expression ";
1360 *os <<
"doesn't " << (full_match_ ?
"match" :
"contain")
1361 <<
" regular expression ";
1367 const bool full_match_;
1380 template <
typename D,
typename Op>
1383 template <
typename T1,
typename T2>
1385 return MakeMatcher(
new Impl< ::testing::tuple<T1, T2> >);
1387 template <
typename T1,
typename T2>
1389 return MakeMatcher(
new Impl<const ::testing::tuple<T1, T2>&>);
1393 static ::std::ostream& GetDesc(::std::ostream& os) {
1394 return os << D::Desc();
1397 template <
typename Tuple>
1400 virtual bool MatchAndExplain(
1403 return Op()(::testing::get<0>(args), ::testing::get<1>(args));
1405 virtual void DescribeTo(::std::ostream* os)
const {
1406 *os <<
"are " << GetDesc;
1408 virtual void DescribeNegationTo(::std::ostream* os)
const {
1409 *os <<
"aren't " << GetDesc;
1416 static const char*
Desc() {
return "an equal pair"; }
1420 static const char*
Desc() {
return "an unequal pair"; }
1424 static const char*
Desc() {
return "a pair where the first < the second"; }
1428 static const char*
Desc() {
return "a pair where the first > the second"; }
1432 static const char*
Desc() {
return "a pair where the first <= the second"; }
1436 static const char*
Desc() {
return "a pair where the first >= the second"; }
1443 template <
typename T>
1447 : matcher_(matcher) {}
1450 return !matcher_.MatchAndExplain(x, listener);
1454 matcher_.DescribeNegationTo(os);
1458 matcher_.DescribeTo(os);
1469 template <
typename InnerMatcher>
1476 template <
typename T>
1482 InnerMatcher matcher_;
1491 template <
typename T>
1495 : matcher1_(matcher1), matcher2_(matcher2) {}
1499 matcher1_.DescribeTo(os);
1501 matcher2_.DescribeTo(os);
1507 matcher1_.DescribeNegationTo(os);
1509 matcher2_.DescribeNegationTo(os);
1517 if (!matcher1_.MatchAndExplain(x, &listener1)) {
1518 *listener << listener1.
str();
1523 if (!matcher2_.MatchAndExplain(x, &listener2)) {
1524 *listener << listener2.
str();
1537 *listener <<
", and " << s2;
1550 #if GTEST_LANG_CXX11 1558 template <
int kSize,
typename Head,
typename... Tail>
1559 struct MatcherList {
1560 typedef MatcherList<kSize - 1, Tail...> MatcherListTail;
1561 typedef ::std::pair<Head, typename MatcherListTail::ListType> ListType;
1567 static ListType BuildList(
const Head& matcher,
const Tail&... tail) {
1568 return ListType(matcher, MatcherListTail::BuildList(tail...));
1575 template <
typename T,
template <
typename >
class CombiningMatcher>
1576 static Matcher<
T> CreateMatcher(const ListType& matchers) {
1577 return Matcher<T>(
new CombiningMatcher<T>(
1578 SafeMatcherCast<T>(matchers.first),
1579 MatcherListTail::template CreateMatcher<T, CombiningMatcher>(
1586 template <
typename Matcher1,
typename Matcher2>
1587 struct MatcherList<2, Matcher1, Matcher2> {
1588 typedef ::std::pair<Matcher1, Matcher2> ListType;
1590 static ListType BuildList(
const Matcher1& matcher1,
1591 const Matcher2& matcher2) {
1592 return ::std::pair<Matcher1, Matcher2>(matcher1, matcher2);
1595 template <
typename T,
template <
typename >
class CombiningMatcher>
1596 static Matcher<
T> CreateMatcher(const ListType& matchers) {
1597 return Matcher<T>(
new CombiningMatcher<T>(
1598 SafeMatcherCast<T>(matchers.first),
1599 SafeMatcherCast<T>(matchers.second)));
1607 template <
template <
typename T>
class CombiningMatcher,
typename...
Args>
1608 class VariadicMatcher {
1610 VariadicMatcher(
const Args&... matchers)
1611 : matchers_(MatcherListType::BuildList(matchers...)) {}
1616 template <
typename T>
1617 operator Matcher<T>()
const {
1618 return MatcherListType::template CreateMatcher<T, CombiningMatcher>(
1623 typedef MatcherList<
sizeof...(Args),
Args...> MatcherListType;
1625 const typename MatcherListType::ListType matchers_;
1630 template <
typename...
Args>
1631 using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl,
Args...>;
1633 #endif // GTEST_LANG_CXX11 1637 template <
typename Matcher1,
typename Matcher2>
1641 : matcher1_(matcher1), matcher2_(matcher2) {}
1646 template <
typename T>
1649 SafeMatcherCast<T>(matcher2_)));
1663 template <
typename T>
1667 : matcher1_(matcher1), matcher2_(matcher2) {}
1671 matcher1_.DescribeTo(os);
1673 matcher2_.DescribeTo(os);
1679 matcher1_.DescribeNegationTo(os);
1681 matcher2_.DescribeNegationTo(os);
1689 if (matcher1_.MatchAndExplain(x, &listener1)) {
1690 *listener << listener1.
str();
1695 if (matcher2_.MatchAndExplain(x, &listener2)) {
1696 *listener << listener2.
str();
1709 *listener <<
", and " << s2;
1722 #if GTEST_LANG_CXX11 1724 template <
typename...
Args>
1725 using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl,
Args...>;
1727 #endif // GTEST_LANG_CXX11 1732 template <
typename Matcher1,
typename Matcher2>
1736 : matcher1_(matcher1), matcher2_(matcher2) {}
1741 template <
typename T>
1744 SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
1756 template <
typename Predicate>
1765 template <
typename T>
1780 *os <<
"satisfies the given predicate";
1784 *os <<
"doesn't satisfy the given predicate";
1788 Predicate predicate_;
1795 template <
typename M>
1806 template <
typename T>
1822 return MatcherCast<const T&>(matcher_).
Matches(x);
1833 template <
typename M>
1841 template <
typename T>
1859 ::std::stringstream ss;
1860 ss <<
"Value of: " << value_text <<
"\n" 1863 ss <<
"\n Actual: " << listener.str();
1877 template <
typename M>
1878 inline PredicateFormatterFromMatcher<M>
1887 template <
typename FloatType>
1897 expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
1904 FloatType max_abs_error)
1905 : expected_(expected),
1906 nan_eq_nan_(nan_eq_nan),
1907 max_abs_error_(max_abs_error) {
1909 <<
", where max_abs_error is" << max_abs_error;
1913 template <
typename T>
1916 Impl(FloatType expected,
bool nan_eq_nan, FloatType max_abs_error)
1917 : expected_(expected),
1918 nan_eq_nan_(nan_eq_nan),
1919 max_abs_error_(max_abs_error) {}
1926 if (actual.is_nan() || expected.
is_nan()) {
1927 if (actual.is_nan() && expected.
is_nan()) {
1933 if (HasMaxAbsError()) {
1938 if (
value == expected_) {
1942 const FloatType diff =
value - expected_;
1943 if (fabs(diff) <= max_abs_error_) {
1948 *listener <<
"which is " << diff <<
" from " << expected_;
1952 return actual.AlmostEquals(expected);
1960 const ::std::streamsize old_precision = os->precision(
1961 ::std::numeric_limits<FloatType>::digits10 + 2);
1966 *os <<
"never matches";
1969 *os <<
"is approximately " << expected_;
1970 if (HasMaxAbsError()) {
1971 *os <<
" (absolute error <= " << max_abs_error_ <<
")";
1974 os->precision(old_precision);
1979 const ::std::streamsize old_precision = os->precision(
1980 ::std::numeric_limits<FloatType>::digits10 + 2);
1985 *os <<
"is anything";
1988 *os <<
"isn't approximately " << expected_;
1989 if (HasMaxAbsError()) {
1990 *os <<
" (absolute error > " << max_abs_error_ <<
")";
1994 os->precision(old_precision);
1998 bool HasMaxAbsError()
const {
1999 return max_abs_error_ >= 0;
2002 const FloatType expected_;
2003 const bool nan_eq_nan_;
2005 const FloatType max_abs_error_;
2007 GTEST_DISALLOW_ASSIGN_(
Impl);
2032 const FloatType expected_;
2033 const bool nan_eq_nan_;
2035 const FloatType max_abs_error_;
2042 template <
typename InnerMatcher>
2055 template <
typename Po
inter>
2062 template <
typename Po
inter>
2068 explicit Impl(
const InnerMatcher& matcher)
2071 virtual void DescribeTo(::std::ostream* os)
const {
2072 *os <<
"points to a value that ";
2073 matcher_.DescribeTo(os);
2076 virtual void DescribeNegationTo(::std::ostream* os)
const {
2077 *os <<
"does not point to a value that ";
2078 matcher_.DescribeTo(os);
2082 MatchResultListener* listener)
const {
2086 *listener <<
"which points to ";
2091 const Matcher<const Pointee&> matcher_;
2096 const InnerMatcher matcher_;
2107 template <
typename To>
2114 GetCastTypeDescription(os);
2119 GetCastTypeDescription(os);
2128 return GetTypeName<To>();
2129 #else // GTEST_HAS_RTTI 2130 return "the target type";
2131 #endif // GTEST_HAS_RTTI 2135 static void GetCastTypeDescription(::std::ostream* os) {
2136 *os <<
"when dynamic_cast to " <<
GetToName() <<
", ";
2144 template <
typename To>
2150 template <
typename From>
2153 To to =
dynamic_cast<To
>(from);
2160 template <
typename To>
2166 template <
typename From>
2169 To* to =
dynamic_cast<To*
>(&from);
2171 *listener <<
"which cannot be dynamic_cast to " << this->GetToName();
2180 template <
typename Class,
typename FieldType>
2185 : field_(field), matcher_(matcher) {}
2188 *os <<
"is an object whose given field ";
2193 *os <<
"is an object whose given field ";
2197 template <
typename T>
2199 return MatchAndExplainImpl(
2200 typename ::testing::internal::
2209 bool MatchAndExplainImpl(
false_type ,
const Class& obj,
2211 *listener <<
"whose given field is ";
2215 bool MatchAndExplainImpl(
true_type ,
const Class* p,
2220 *listener <<
"which points to an object ";
2224 return MatchAndExplainImpl(
false_type(), *p, listener);
2227 const FieldType Class::*field_;
2228 const Matcher<const FieldType&> matcher_;
2235 template <
typename Class,
typename PropertyType>
2246 : property_(property), matcher_(matcher) {}
2249 *os <<
"is an object whose given property ";
2254 *os <<
"is an object whose given property ";
2258 template <
typename T>
2260 return MatchAndExplainImpl(
2261 typename ::testing::internal::
2270 bool MatchAndExplainImpl(
false_type ,
const Class& obj,
2272 *listener <<
"whose given property is ";
2275 #if defined(_PREFAST_ ) && _MSC_VER == 1800 2281 RefToConstProperty result = (obj.*property_)();
2286 bool MatchAndExplainImpl(
true_type ,
const Class* p,
2291 *listener <<
"which points to an object ";
2295 return MatchAndExplainImpl(
false_type(), *p, listener);
2298 PropertyType (Class::*property_)()
const;
2299 const Matcher<RefToConstProperty> matcher_;
2308 template <
typename Functor>
2314 template <
typename T>
2319 template <
typename ArgType,
typename ResType>
2322 typedef ResType(*StorageType)(ArgType);
2326 <<
"NULL function pointer is passed into ResultOf().";
2328 template <
typename T>
2329 static ResType
Invoke(ResType(*f)(ArgType),
T arg) {
2336 template <
typename Callable>
2342 : callable_(callable), matcher_(matcher) {
2346 template <
typename T>
2348 return Matcher<T>(
new Impl<T>(callable_, matcher_));
2354 template <
typename T>
2358 : callable_(callable), matcher_(matcher) {}
2360 virtual void DescribeTo(::std::ostream* os)
const {
2361 *os <<
"is mapped by the given callable to a value that ";
2362 matcher_.DescribeTo(os);
2365 virtual void DescribeNegationTo(::std::ostream* os)
const {
2366 *os <<
"is mapped by the given callable to a value that ";
2367 matcher_.DescribeNegationTo(os);
2370 virtual bool MatchAndExplain(
T obj, MatchResultListener* listener)
const {
2371 *listener <<
"which is mapped by the given callable to ";
2375 CallableTraits<Callable>::template Invoke<T>(callable_, obj);
2385 mutable CallableStorageType callable_;
2386 const Matcher<ResultType> matcher_;
2391 const CallableStorageType callable_;
2392 const Matcher<ResultType> matcher_;
2398 template <
typename SizeMatcher>
2402 : size_matcher_(size_matcher) {
2405 template <
typename Container>
2410 template <
typename Container>
2415 typedef typename ContainerView::type::size_type
SizeType;
2416 explicit Impl(
const SizeMatcher& size_matcher)
2432 const bool result = size_matcher_.
MatchAndExplain(size, &size_listener);
2434 <<
"whose size " << size << (result ?
" matches" :
" doesn't match");
2441 GTEST_DISALLOW_ASSIGN_(
Impl);
2445 const SizeMatcher size_matcher_;
2451 template <
typename DistanceMatcher>
2455 : distance_matcher_(distance_matcher) {}
2457 template <
typename Container>
2462 template <
typename Container>
2467 typedef typename std::iterator_traits<
2468 typename ContainerView::type::const_iterator>::difference_type
2470 explicit Impl(
const DistanceMatcher& distance_matcher)
2474 *os <<
"distance between begin() and end() ";
2478 *os <<
"distance between begin() and end() ";
2484 #if GTEST_HAS_STD_BEGIN_AND_END_ 2487 DistanceType distance = std::distance(begin(container), end(container));
2489 DistanceType distance = std::distance(container.begin(), container.end());
2494 *listener <<
"whose distance between begin() and end() " << distance
2495 << (result ?
" matches" :
" doesn't match");
2502 GTEST_DISALLOW_ASSIGN_(
Impl);
2506 const DistanceMatcher distance_matcher_;
2520 template <
typename Container>
2530 : expected_(
View::Copy(expected)) {
2542 *os <<
"does not equal ";
2546 template <
typename LhsContainer>
2553 typedef typename LhsView::type LhsStlContainer;
2555 if (lhs_stl_container == expected_)
2558 ::std::ostream*
const os = listener->
stream();
2561 bool printed_header =
false;
2562 for (
typename LhsStlContainer::const_iterator it =
2563 lhs_stl_container.begin();
2564 it != lhs_stl_container.end(); ++it) {
2567 if (printed_header) {
2570 *os <<
"which has these unexpected elements: ";
2571 printed_header =
true;
2578 bool printed_header2 =
false;
2579 for (
typename StlContainer::const_iterator it = expected_.begin();
2580 it != expected_.end(); ++it) {
2582 lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
2583 lhs_stl_container.end()) {
2584 if (printed_header2) {
2587 *os << (printed_header ?
",\nand" :
"which")
2588 <<
" doesn't have these expected elements: ";
2589 printed_header2 =
true;
2607 template <
typename T,
typename U>
2608 bool operator()(
const T& lhs,
const U& rhs)
const {
return lhs < rhs; }
2612 template <
typename Comparator,
typename ContainerMatcher>
2616 const ContainerMatcher& matcher)
2617 : comparator_(comparator), matcher_(matcher) {}
2619 template <
typename LhsContainer>
2624 template <
typename LhsContainer>
2636 Impl(
const Comparator& comparator,
const ContainerMatcher& matcher)
2637 : comparator_(comparator), matcher_(matcher) {}
2640 *os <<
"(when sorted) ";
2645 *os <<
"(when sorted) ";
2652 ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
2653 lhs_stl_container.end());
2655 sorted_container.begin(), sorted_container.end(), comparator_);
2660 return matcher_.
Matches(sorted_container);
2663 *listener <<
"which is ";
2665 *listener <<
" when sorted";
2675 const Comparator comparator_;
2678 GTEST_DISALLOW_COPY_AND_ASSIGN_(
Impl);
2682 const Comparator comparator_;
2683 const ContainerMatcher matcher_;
2692 template <
typename TupleMatcher,
typename RhsContainer>
2702 : tuple_matcher_(tuple_matcher), rhs_(
RhsView::Copy(rhs)) {
2709 template <
typename LhsContainer>
2714 template <
typename LhsContainer>
2734 *os <<
"contains " << rhs_.size()
2735 <<
" values, where each value and its corresponding value in ";
2741 *os <<
"doesn't contain exactly " << rhs_.size()
2742 <<
" values, or contains a value x at some index i" 2743 <<
" where x and the i-th value of ";
2752 const size_t actual_size = lhs_stl_container.size();
2753 if (actual_size != rhs_.size()) {
2754 *listener <<
"which contains " << actual_size <<
" values";
2758 typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
2759 typename RhsStlContainer::const_iterator right = rhs_.begin();
2760 for (
size_t i = 0; i != actual_size; ++i, ++left, ++right) {
2766 value_pair, &inner_listener)) {
2767 *listener <<
"where the value pair (";
2771 *listener <<
") at index #" << i <<
" don't match";
2776 if (!mono_tuple_matcher_.
Matches(value_pair))
2788 GTEST_DISALLOW_ASSIGN_(
Impl);
2792 const TupleMatcher tuple_matcher_;
2799 template <
typename Container>
2806 typedef typename StlContainer::value_type
Element;
2808 template <
typename InnerMatcher>
2817 Container container,
2821 for (
typename StlContainer::const_iterator it = stl_container.begin();
2822 it != stl_container.end(); ++it, ++i) {
2826 if (matches != all_elements_should_match) {
2827 *listener <<
"whose element #" << i
2828 << (matches ?
" matches" :
" doesn't match");
2830 return !all_elements_should_match;
2833 return all_elements_should_match;
2844 template <
typename Container>
2847 template <
typename InnerMatcher>
2853 *os <<
"contains at least one element that ";
2858 *os <<
"doesn't contain any element that ";
2873 template <
typename Container>
2876 template <
typename InnerMatcher>
2882 *os <<
"only contains elements that ";
2887 *os <<
"contains some element that ";
2901 template <
typename M>
2906 template <
typename Container>
2912 const M inner_matcher_;
2918 template <
typename M>
2923 template <
typename Container>
2929 const M inner_matcher_;
2938 template <
typename PairType>
2944 template <
typename InnerMatcher>
2957 if (explanation !=
"") {
2958 *listener <<
"whose first field is a value " << explanation;
2965 *os <<
"has a key that ";
2971 *os <<
"doesn't have a key that ";
2982 template <
typename M>
2987 template <
typename PairType>
2993 const M matcher_for_key_;
3000 template <
typename PairType>
3007 template <
typename FirstMatcher,
typename SecondMatcher>
3017 *os <<
"has a first field that ";
3019 *os <<
", and has a second field that ";
3025 *os <<
"has a first field that ";
3027 *os <<
", or has a second field that ";
3038 return first_matcher_.
Matches(a_pair.first) &&
3039 second_matcher_.
Matches(a_pair.second);
3043 &first_inner_listener)) {
3044 *listener <<
"whose first field does not match";
3050 &second_inner_listener)) {
3051 *listener <<
"whose second field does not match";
3055 ExplainSuccess(first_inner_listener.
str(), second_inner_listener.
str(),
3064 *listener <<
"whose both fields match";
3065 if (first_explanation !=
"") {
3066 *listener <<
", where the first field is a value " << first_explanation;
3068 if (second_explanation !=
"") {
3070 if (first_explanation !=
"") {
3071 *listener <<
"and ";
3073 *listener <<
"where ";
3075 *listener <<
"the second field is a value " << second_explanation;
3079 const Matcher<const FirstType&> first_matcher_;
3080 const Matcher<const SecondType&> second_matcher_;
3086 template <
typename FirstMatcher,
typename SecondMatcher>
3090 : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
3092 template <
typename PairType>
3096 first_matcher_, second_matcher_));
3100 const FirstMatcher first_matcher_;
3101 const SecondMatcher second_matcher_;
3107 template <
typename Container>
3114 typedef typename StlContainer::value_type
Element;
3118 template <
typename InputIter>
3120 while (first != last) {
3121 matchers_.push_back(MatcherCast<const Element&>(*first++));
3129 }
else if (count() == 1) {
3130 *os <<
"has 1 element that ";
3131 matchers_[0].DescribeTo(os);
3133 *os <<
"has " << Elements(count()) <<
" where\n";
3134 for (
size_t i = 0; i != count(); ++i) {
3135 *os <<
"element #" << i <<
" ";
3136 matchers_[i].DescribeTo(os);
3137 if (i + 1 < count()) {
3147 *os <<
"isn't empty";
3151 *os <<
"doesn't have " << Elements(count()) <<
", or\n";
3152 for (
size_t i = 0; i != count(); ++i) {
3153 *os <<
"element #" << i <<
" ";
3154 matchers_[i].DescribeNegationTo(os);
3155 if (i + 1 < count()) {
3166 const bool listener_interested = listener->
IsInterested();
3169 ::std::vector<internal::string> explanations(count());
3171 typename StlContainer::const_iterator it = stl_container.begin();
3172 size_t exam_pos = 0;
3173 bool mismatch_found =
false;
3178 for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
3180 if (listener_interested) {
3182 match = matchers_[exam_pos].MatchAndExplain(*it, &s);
3183 explanations[exam_pos] = s.
str();
3185 match = matchers_[exam_pos].Matches(*it);
3189 mismatch_found =
true;
3198 size_t actual_count = exam_pos;
3199 for (; it != stl_container.end(); ++it) {
3203 if (actual_count != count()) {
3208 if (listener_interested && (actual_count != 0)) {
3209 *listener <<
"which has " << Elements(actual_count);
3214 if (mismatch_found) {
3216 if (listener_interested) {
3217 *listener <<
"whose element #" << exam_pos <<
" doesn't match";
3225 if (listener_interested) {
3226 bool reason_printed =
false;
3227 for (
size_t i = 0; i != count(); ++i) {
3230 if (reason_printed) {
3231 *listener <<
",\nand ";
3233 *listener <<
"whose element #" << i <<
" matches, " << s;
3234 reason_printed =
true;
3242 static Message Elements(
size_t count) {
3243 return Message() << count << (count == 1 ?
" element" :
" elements");
3246 size_t count()
const {
return matchers_.size(); }
3248 ::std::vector<Matcher<const Element&> > matchers_;
3260 : num_elements_(num_elements),
3261 num_matchers_(num_matchers),
3262 matched_(num_elements_* num_matchers_, 0) {
3268 return matched_[SpaceIndex(ilhs, irhs)] == 1;
3271 matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
3281 string DebugString()
const;
3284 size_t SpaceIndex(
size_t ilhs,
size_t irhs)
const {
3285 return ilhs * num_matchers_ + irhs;
3288 size_t num_elements_;
3289 size_t num_matchers_;
3294 ::std::vector<char> matched_;
3319 void DescribeToImpl(::std::ostream* os)
const;
3322 void DescribeNegationToImpl(::std::ostream* os)
const;
3324 bool VerifyAllElementsAndMatchersAreMatched(
3325 const ::std::vector<string>& element_printouts,
3330 return matcher_describers_;
3334 return Message() << n <<
" element" << (n == 1 ?
"" :
"s");
3338 MatcherDescriberVec matcher_describers_;
3344 template <
typename Container>
3354 typedef typename StlContainer::value_type
Element;
3358 template <
typename InputIter>
3360 for (; first != last; ++first) {
3361 matchers_.push_back(MatcherCast<const Element&>(*first));
3379 ::std::vector<string> element_printouts;
3380 MatchMatrix matrix = AnalyzeElements(stl_container.begin(),
3381 stl_container.end(),
3385 const size_t actual_count = matrix.
LhsSize();
3386 if (actual_count == 0 && matchers_.empty()) {
3389 if (actual_count != matchers_.size()) {
3395 *listener <<
"which has " <<
Elements(actual_count);
3401 matrix, listener) &&
3406 typedef ::std::vector<Matcher<const Element&> > MatcherVec;
3408 template <
typename ElementIter>
3409 MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
3410 ::std::vector<string>* element_printouts,
3412 element_printouts->clear();
3413 ::std::vector<char> did_match;
3414 size_t num_elements = 0;
3415 for (; elem_first != elem_last; ++num_elements, ++elem_first) {
3419 for (
size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
3420 did_match.push_back(
Matches(matchers_[irhs])(*elem_first));
3424 MatchMatrix matrix(num_elements, matchers_.size());
3425 ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
3426 for (
size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
3427 for (
size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
3428 matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
3434 MatcherVec matchers_;
3441 template <
typename Target>
3443 template <
typename Arg>
3445 return MatcherCast<Target>(
a);
3450 template <
typename MatcherTuple>
3454 : matchers_(args) {}
3456 template <
typename Container>
3460 typedef typename View::value_type Element;
3461 typedef ::std::vector<Matcher<const Element&> > MatcherVec;
3462 MatcherVec matchers;
3465 ::std::back_inserter(matchers));
3467 matchers.begin(), matchers.end()));
3476 template <
typename MatcherTuple>
3481 template <
typename Container>
3485 typedef typename View::value_type Element;
3486 typedef ::std::vector<Matcher<const Element&> > MatcherVec;
3487 MatcherVec matchers;
3490 ::std::back_inserter(matchers));
3492 matchers.begin(), matchers.end()));
3501 template <
typename T>
3506 template <
typename Iter>
3508 : matchers_(first, last) {}
3510 template <
typename Container>
3518 ::std::vector<T> matchers_;
3524 template <
typename T>
3527 template <
typename Iter>
3530 template <
typename Container>
3533 matchers_.begin(), matchers_.end()));
3537 const ::std::vector<T> matchers_;
3551 template <
typename Tuple2Matcher,
typename Second>
3555 : tuple2_matcher_(tm), second_value_(second) {}
3557 template <
typename T>
3559 return MakeMatcher(
new Impl<T>(tuple2_matcher_, second_value_));
3571 GTEST_LOG_(FATAL) <<
"BoundSecondMatcher should never be assigned.";
3575 template <
typename T>
3578 typedef ::testing::tuple<T, Second> ArgTuple;
3580 Impl(
const Tuple2Matcher& tm,
const Second& second)
3582 second_value_(second) {}
3584 virtual void DescribeTo(::std::ostream* os)
const {
3588 mono_tuple2_matcher_.DescribeTo(os);
3591 virtual bool MatchAndExplain(
T x, MatchResultListener* listener)
const {
3592 return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
3597 const Matcher<const ArgTuple&> mono_tuple2_matcher_;
3598 const Second second_value_;
3603 const Tuple2Matcher tuple2_matcher_;
3604 const Second second_value_;
3611 template <
typename Tuple2Matcher,
typename Second>
3613 const Tuple2Matcher& tm,
const Second& second) {
3623 const char* matcher_name,
3643 template <
typename Iter>
3644 inline internal::ElementsAreArrayMatcher<
3645 typename ::std::iterator_traits<Iter>::value_type>
3647 typedef typename ::std::iterator_traits<Iter>::value_type
T;
3651 template <
typename T>
3657 template <
typename T,
size_t N>
3659 const T (&array)[N]) {
3663 template <
typename Container>
3664 inline internal::ElementsAreArrayMatcher<typename Container::value_type>
3669 #if GTEST_HAS_STD_INITIALIZER_LIST_ 3670 template <
typename T>
3671 inline internal::ElementsAreArrayMatcher<T>
3685 template <
typename Iter>
3686 inline internal::UnorderedElementsAreArrayMatcher<
3687 typename ::std::iterator_traits<Iter>::value_type>
3689 typedef typename ::std::iterator_traits<Iter>::value_type
T;
3693 template <
typename T>
3694 inline internal::UnorderedElementsAreArrayMatcher<T>
3699 template <
typename T,
size_t N>
3700 inline internal::UnorderedElementsAreArrayMatcher<T>
3705 template <
typename Container>
3706 inline internal::UnorderedElementsAreArrayMatcher<
3707 typename Container::value_type>
3712 #if GTEST_HAS_STD_INITIALIZER_LIST_ 3713 template <
typename T>
3714 inline internal::UnorderedElementsAreArrayMatcher<T>
3731 template <
typename T>
3735 template <
typename T>
3741 template <
typename T>
3746 template <
typename T>
3761 template <
typename Lhs,
typename Rhs>
3765 template <
typename Rhs>
3771 template <
typename Rhs>
3777 template <
typename Rhs>
3783 template <
typename Rhs>
3789 template <
typename Rhs>
3808 template <
typename T>
3829 double rhs,
double max_abs_error) {
3837 double rhs,
double max_abs_error) {
3857 float rhs,
float max_abs_error) {
3865 float rhs,
float max_abs_error) {
3871 template <
typename InnerMatcher>
3873 const InnerMatcher& inner_matcher) {
3883 template <
typename To>
3884 inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
3894 template <
typename Class,
typename FieldType,
typename FieldMatcher>
3895 inline PolymorphicMatcher<
3897 FieldType Class::*field,
const FieldMatcher& matcher) {
3900 field, MatcherCast<const FieldType&>(matcher)));
3911 template <
typename Class,
typename PropertyType,
typename PropertyMatcher>
3912 inline PolymorphicMatcher<
3914 PropertyType (Class::*property)()
const,
const PropertyMatcher& matcher) {
3938 template <
typename Callable,
typename ResultOfMatcher>
3940 Callable callable,
const ResultOfMatcher& matcher) {
3943 MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
3954 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3961 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3968 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3975 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3978 str,
false,
false));
3983 inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
3990 inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
3997 inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
4025 #if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING 4029 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4036 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4043 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4050 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4053 str,
false,
false));
4058 inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
4065 inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
4072 inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
4078 #endif // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING 4106 template <
typename InnerMatcher>
4114 template <
typename Predicate>
4115 inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
4126 template <
typename SizeMatcher>
4127 inline internal::SizeIsMatcher<SizeMatcher>
4137 template <
typename DistanceMatcher>
4138 inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
4147 template <
typename Container>
4148 inline PolymorphicMatcher<internal::ContainerEqMatcher<
4160 template <
typename Comparator,
typename ContainerMatcher>
4161 inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
4163 const ContainerMatcher& container_matcher) {
4165 comparator, container_matcher);
4170 template <
typename ContainerMatcher>
4171 inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
4184 template <
typename TupleMatcher,
typename Container>
4185 inline internal::PointwiseMatcher<TupleMatcher,
4187 Pointwise(
const TupleMatcher& tuple_matcher,
const Container& rhs) {
4193 tuple_matcher, rhs);
4196 #if GTEST_HAS_STD_INITIALIZER_LIST_ 4199 template <
typename TupleMatcher,
typename T>
4200 inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> >
Pointwise(
4201 const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
4202 return Pointwise(tuple_matcher, std::vector<T>(rhs));
4205 #endif // GTEST_HAS_STD_INITIALIZER_LIST_ 4218 template <
typename Tuple2Matcher,
typename RhsContainer>
4219 inline internal::UnorderedElementsAreArrayMatcher<
4220 typename internal::BoundSecondMatcher<
4222 RhsContainer)>::type::value_type> >
4224 const RhsContainer& rhs_container) {
4233 typedef typename RhsView::type RhsStlContainer;
4234 typedef typename RhsStlContainer::value_type Second;
4235 const RhsStlContainer& rhs_stl_container =
4236 RhsView::ConstReference(rhs_container);
4239 ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
4240 for (
typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
4241 it != rhs_stl_container.end(); ++it) {
4250 #if GTEST_HAS_STD_INITIALIZER_LIST_ 4253 template <
typename Tuple2Matcher,
typename T>
4254 inline internal::UnorderedElementsAreArrayMatcher<
4255 typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
4257 std::initializer_list<T> rhs) {
4261 #endif // GTEST_HAS_STD_INITIALIZER_LIST_ 4281 template <
typename M>
4313 template <
typename M>
4321 template <
typename M>
4331 template <
typename FirstMatcher,
typename SecondMatcher>
4332 inline internal::PairMatcher<FirstMatcher, SecondMatcher>
4333 Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
4335 first_matcher, second_matcher);
4340 template <
typename M>
4346 template <
typename T,
typename M>
4353 template <
typename T,
typename M>
4356 return SafeMatcherCast<const T&>(matcher).MatchAndExplain(
value, listener);
4359 #if GTEST_LANG_CXX11 4362 template <
typename...
Args>
4363 inline internal::AllOfMatcher<
Args...>
AllOf(
const Args&... matchers) {
4364 return internal::AllOfMatcher<
Args...>(matchers...);
4367 template <
typename...
Args>
4368 inline internal::AnyOfMatcher<
Args...>
AnyOf(
const Args&... matchers) {
4369 return internal::AnyOfMatcher<
Args...>(matchers...);
4372 #endif // GTEST_LANG_CXX11 4381 template <
typename InnerMatcher>
4382 inline InnerMatcher
AllArgs(
const InnerMatcher& matcher) {
return matcher; }
4388 #define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\ 4389 ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) 4390 #define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\ 4391 ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) 4399 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
TrulyMatcher(Predicate pred)
WhenDynamicCastToMatcherBase(const Matcher< To > &matcher)
static Matcher< T > Cast(const Matcher< U > &source_matcher)
PolymorphicMatcher< internal::TrulyMatcher< Predicate > > Truly(Predicate pred)
bool MatchAndExplain(T x, MatchResultListener *listener) const
UnorderedElementsAreArrayMatcher(Iter first, Iter last)
virtual bool MatchAndExplain(PairType key_value, MatchResultListener *listener) const
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrCaseNe(const internal::string &str)
bool operator()(const T &lhs, const U &rhs) const
virtual void DescribeNegationTo(::std::ostream *os) const
#define GMOCK_KIND_OF_(type)
::std::ostream * stream()
virtual bool MatchAndExplain(T value, MatchResultListener *listener) const
WhenDynamicCastToMatcher(const Matcher< To &> &matcher)
static const char * Desc()
void DescribeNegationTo(::std::ostream *os) const
void DescribeTo(::std::ostream *os) const
void DescribeTo(::std::ostream *os) const
ContainerEqMatcher(const Container &expected)
PolymorphicMatcher< internal::EndsWithMatcher< internal::string > > EndsWith(const internal::string &suffix)
Matcher< T > SafeMatcherCast(const M &polymorphic_matcher)
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType
LhsView::type LhsStlContainer
static const char * NegatedDesc()
virtual void DescribeTo(::std::ostream *os) const
EitherOfMatcherImpl(const Matcher< T > &matcher1, const Matcher< T > &matcher2)
EndsWithMatcher(const StringType &suffix)
LhsView::type LhsStlContainer
void operator=(const BoundSecondMatcher &)
void DescribeTo(::std::ostream *os) const
void DescribeNegationTo(::std::ostream *os) const
static const char * NegatedDesc()
::std::pair< size_t, size_t > ElementMatcherPair
internal::GtMatcher< Rhs > Gt(Rhs x)
internal::ElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type > ElementsAreArray(Iter first, Iter last)
PredicateFormatterFromMatcher< M > MakePredicateFormatterFromMatcher(M matcher)
virtual bool MatchAndExplain(T x, MatchResultListener *listener) const
MatchResultListener & operator<<(const T &x)
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
static bool PartialMatch(const ::std::string &str, const RE &re)
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
bool MatchAndExplain(const LhsContainer &lhs, MatchResultListener *listener) const
virtual bool MatchAndExplain(T x, MatchResultListener *listener) const
static const char * NegatedDesc()
internal::StlContainerView< RhsContainer > RhsView
static const char * Desc()
::std::string PrintToString(const T &value)
virtual void DescribeNegationTo(::std::ostream *os) const
internal::FloatingEqMatcher< double > DoubleNear(double rhs, double max_abs_error)
StrEqualityMatcher(const StringType &str, bool expect_eq, bool case_sensitive)
internal::WhenSortedByMatcher< internal::LessComparator, ContainerMatcher > WhenSorted(const ContainerMatcher &container_matcher)
static ResType Invoke(ResType(*f)(ArgType), T arg)
static bool CaseInsensitiveCStringEquals(const char *lhs, const char *rhs)
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrNe(const internal::string &str)
static const char * Desc()
bool MatchAndExplain(const MatcheeStringType &s, MatchResultListener *) const
static const char * Desc()
virtual bool MatchAndExplain(LhsContainer lhs, MatchResultListener *listener) const
PolymorphicMatcher< internal::MatchesRegexMatcher > ContainsRegex(const internal::RE *regex)
#define GTEST_REMOVE_REFERENCE_(T)
internal::ResultOfMatcher< Callable > ResultOf(Callable callable, const ResultOfMatcher &matcher)
#define GTEST_CHECK_(condition)
bool MatchAndExplain(const MatcheeStringType &s, MatchResultListener *) const
static void CheckIsValid(ResType(*f)(ArgType))
GTEST_API_ bool FindPairing(const MatchMatrix &matrix, MatchResultListener *listener)
ResultOfMatcher(Callable callable, const Matcher< ResultType > &matcher)
BothOfMatcherImpl(const Matcher< T > &matcher1, const Matcher< T > &matcher2)
internal::GeMatcher< Rhs > Ge(Rhs x)
GTEST_API_ AssertionResult AssertionFailure()
MatchesRegexMatcher(const RE *regex, bool full_match)
Matcher(const MatcherInterface< internal::string > *impl)
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType
internal::AnyOfResult2< M1, M2 >::type AnyOf(M1 m1, M2 m2)
internal::UnorderedElementsAreArrayMatcher< typename internal::BoundSecondMatcher< Tuple2Matcher, typename internal::StlContainerView< GTEST_REMOVE_CONST_(RhsContainer)>::type::value_type > > UnorderedPointwise(const Tuple2Matcher &tuple2_matcher, const RhsContainer &rhs_container)
void DescribeNegationTo(::std::ostream *os) const
FloatingEqMatcher(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
virtual void DescribeTo(::std::ostream *os) const
virtual void DescribeNegationTo(::std::ostream *os) const
virtual bool MatchAndExplain(LhsContainer lhs, MatchResultListener *listener) const
WhenDynamicCastToMatcher(const Matcher< To > &matcher)
void DescribeTo(::std::ostream *os) const
virtual bool MatchAndExplain(T, MatchResultListener *) const
StlContainer::value_type Element
bool operator()(const A &a, const B &b) const
typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty
void DescribeTo(::std::ostream *os) const
StlContainer::value_type Element
static Matcher< T > Cast(const M &polymorphic_matcher_or_value)
internal::StlContainerView< RawContainer > View
InnerMatcher AllArgs(const InnerMatcher &matcher)
PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
internal::StlContainerView< Container > View
RemoveConstFromKey< typename LhsStlContainer::value_type >::type LhsValue
internal::FloatingEqMatcher< float > FloatEq(float rhs)
bool MatchPrintAndExplain(Value &value, const Matcher< T > &matcher, MatchResultListener *listener)
const Matcher< const Element & > inner_matcher_
virtual bool MatchAndExplain(PairType a_pair, MatchResultListener *listener) const
PolymorphicMatcher< internal::PropertyMatcher< Class, PropertyType > > Property(PropertyType(Class::*property)() const, const PropertyMatcher &matcher)
RhsView::type RhsStlContainer
bool TupleMatches(const MatcherTuple &matcher_tuple, const ValueTuple &value_tuple)
GTEST_API_ AssertionResult AssertionSuccess()
const Matcher< To > matcher_
internal::FloatingEqMatcher< float > NanSensitiveFloatNear(float rhs, float max_abs_error)
PolymorphicMatcher< internal::StartsWithMatcher< internal::string > > StartsWith(const internal::string &prefix)
virtual void DescribeTo(::std::ostream *os) const
internal::EqMatcher< T > Eq(T x)
UnorderedElementsAreArrayMatcher()
View::const_reference StlContainerReference
QuantifierMatcherImpl(InnerMatcher inner_matcher)
const MatcherDescriberInterface * GetDescriber() const
virtual void DescribeTo(::std::ostream *os) const
internal::BeginEndDistanceIsMatcher< DistanceMatcher > BeginEndDistanceIs(const DistanceMatcher &distance_matcher)
internal::FloatingEqMatcher< double > NanSensitiveDoubleNear(double rhs, double max_abs_error)
internal::FloatingEqMatcher< float > NanSensitiveFloatEq(float rhs)
void DescribeToImpl(::std::ostream *os) const
void DescribeTo(::std::ostream *os) const
::std::vector< const MatcherDescriberInterface * > MatcherDescriberVec
virtual void DescribeTo(::std::ostream *os) const
static const char * Desc()
LeMatcher(const Rhs &rhs)
bool MatchAndExplain(T &x, MatchResultListener *) const
ContainsMatcherImpl(InnerMatcher inner_matcher)
internal::SizeIsMatcher< SizeMatcher > SizeIs(const SizeMatcher &size_matcher)
PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
internal::ArgsMatcher< InnerMatcher > Args(const InnerMatcher &matcher)
#define GTEST_REFERENCE_TO_CONST_(T)
bool_constant< true > true_type
PolymorphicMatcher< internal::MatchesRegexMatcher > MatchesRegex(const internal::RE *regex)
StartsWithMatcher(const StringType &prefix)
bool operator()(const A &a, const B &b) const
PolymorphicMatcher< internal::NotNullMatcher > NotNull()
RawPairType::second_type SecondType
PolymorphicMatcher< internal::WhenDynamicCastToMatcher< To > > WhenDynamicCastTo(const Matcher< To > &inner_matcher)
void DescribeNegationTo(::std::ostream *os) const
void DescribeNegationTo(::std::ostream *os) const
static const char * NegatedDesc()
virtual void DescribeTo(::std::ostream *os) const
virtual bool MatchAndExplain(T x, MatchResultListener *listener) const
BoundSecondMatcher< Tuple2Matcher, Second > MatcherBindSecond(const Tuple2Matcher &tm, const Second &second)
static bool Matches(const MatcherTuple &, const ValueTuple &)
bool MatchAndExplain(const T &value, MatchResultListener *listener) const
WhenSortedByMatcher(const Comparator &comparator, const ContainerMatcher &matcher)
internal::StlContainerView< GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView
mdb_size_t count(MDB_cursor *cur)
virtual void DescribeTo(::std::ostream *os) const =0
StringMatchResultListener()
internal::PointwiseMatcher< TupleMatcher, GTEST_REMOVE_CONST_(Container)> Pointwise(const TupleMatcher &tuple_matcher, const Container &rhs)
static const char * NegatedDesc()
Matcher(const MatcherInterface< const internal::string &> *impl)
virtual void DescribeNegationTo(::std::ostream *os) const
void DescribeTo(::std::ostream *os) const
virtual void DescribeNegationTo(::std::ostream *os) const
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrCaseEq(const internal::string &str)
virtual void DescribeNegationTo(::std::ostream *os) const
static void Print(const T &value, ::std::ostream *os)
const type & const_reference
void SetEdge(size_t ilhs, size_t irhs, bool b)
virtual void DescribeNegationTo(::std::ostream *os) const
MatcherBase(const MatcherInterface< T > *impl)
CallableTraits< Callable >::ResultType ResultType
PointwiseMatcher(const TupleMatcher &tuple_matcher, const RhsContainer &rhs)
virtual void DescribeTo(::std::ostream *os) const
void DescribeTo(::std::ostream *os) const
bool VerifyAllElementsAndMatchersAreMatched(const ::std::vector< string > &element_printouts, const MatchMatrix &matrix, MatchResultListener *listener) const
PolymorphicMatcher< Impl > MakePolymorphicMatcher(const Impl &impl)
void DescribeTo(::std::ostream *os) const
static bool FullMatch(const ::std::string &str, const RE &re)
bool operator()(const A &a, const B &b) const
internal::string str() const
void DescribeNegationToImpl(::std::ostream *os) const
#define GTEST_DISALLOW_ASSIGN_(type)
ElementsAreArrayMatcher(Iter first, Iter last)
ContainerView::type::size_type SizeType
MatchMatrix(size_t num_elements, size_t num_matchers)
virtual void DescribeNegationTo(::std::ostream *os) const
virtual void DescribeTo(::std::ostream *os) const
LhsView::const_reference LhsStlContainerReference
bool Value(const T &value, M matcher)
bool MatchAndExplain(From from, MatchResultListener *listener) const
LhsView::const_reference LhsStlContainerReference
internal::MatcherAsPredicate< M > Matches(M matcher)
Impl(const TupleMatcher &tuple_matcher, const RhsStlContainer &rhs)
#define GTEST_LOG_(severity)
static const char * NegatedDesc()
bool CaseInsensitiveCStringEquals(const char *lhs, const char *rhs)
virtual void DescribeNegationTo(::std::ostream *os) const
HasSubstrMatcher(const StringType &substring)
Functor::result_type ResultType
virtual bool MatchAndExplain(T x, MatchResultListener *listener) const =0
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer
const Impl & impl() const
bool operator()(const A &a, const B &b) const
PolymorphicMatcher(const Impl &an_impl)
EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
LhsStlContainer::value_type LhsValue
bool MatchAndExplain(CharType *s, MatchResultListener *listener) const
void DescribeTo(::std::ostream *os) const
GTEST_API_ string FormatMatcherDescription(bool negation, const char *matcher_name, const Strings ¶m_values)
bool MatchAndExplainImpl(bool all_elements_should_match, Container container, MatchResultListener *listener) const
Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.
internal::LeMatcher< Rhs > Le(Rhs x)
PropertyMatcher(PropertyType(Class::*property)() const, const Matcher< RefToConstProperty > &matcher)
bool HasEdge(size_t ilhs, size_t irhs) const
static Message Elements(size_t n)
void DescribeNegationTo(::std::ostream *os) const
static Matcher< T > Cast(const M &polymorphic_matcher_or_value)
ElementsAreMatcher(const MatcherTuple &args)
internal::WhenSortedByMatcher< Comparator, ContainerMatcher > WhenSortedBy(const Comparator &comparator, const ContainerMatcher &container_matcher)
bool MatchAndExplain(const MatcheeStringType &s, MatchResultListener *) const
Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
virtual void DescribeTo(::std::ostream *os) const
#define GTEST_REMOVE_CONST_(T)
bool MatchAndExplain(CharType *s, MatchResultListener *listener) const
void DescribeNegationTo(::std::ostream *os) const
PolymorphicMatcher< internal::IsNullMatcher > IsNull()
View::const_reference StlContainerReference
GeMatcher(const Rhs &rhs)
bool MatchAndExplain(CharType *s, MatchResultListener *listener) const
StreamMatchResultListener(::std::ostream *os)
static const char * Desc()
UnorderedElementsAreMatcher(const MatcherTuple &args)
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
internal::PairMatcher< FirstMatcher, SecondMatcher > Pair(FirstMatcher first_matcher, SecondMatcher second_matcher)
::testing::tuple< const LhsValue &, const RhsValue & > InnerMatcherArg
MatchResultListener(::std::ostream *os)
static void ExplainMatchFailuresTo(const MatcherTuple &, const ValueTuple &, ::std::ostream *)
NotMatcher(InnerMatcher matcher)
Matcher(const MatcherInterface< T > *impl)
bool MatchAndExplain(From &from, MatchResultListener *listener) const
static Matcher< T > Cast(const Matcher< U > &matcher)
virtual ~MatchResultListener()=0
static const char * Desc()
PolymorphicMatcher< internal::ContainerEqMatcher< GTEST_REMOVE_CONST_(Container)> > ContainerEq(const Container &rhs)
internal::StlContainerView< GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView
bool ExplainMatchResult(M matcher, const T &value, MatchResultListener *listener)
static const char * Desc()
virtual void DescribeTo(::std::ostream *os) const
void DescribeNegationTo(::std::ostream *os) const
const T & move(const T &t)
View::const_reference StlContainerReference
::std::vector< ElementMatcherPair > ElementMatcherPairs
static const_reference ConstReference(const RawContainer &container)
virtual void DescribeTo(::std::ostream *os) const
MatcherDescriberVec & matcher_describers()
static const char * Desc()
internal::StlContainerView< GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView
UnorderedElementsAreMatcherImpl(InputIter first, InputIter last)
virtual ~MatcherDescriberInterface()
Matcher< T > MakeMatcher(const MatcherInterface< T > *impl)
GtMatcher(const Rhs &rhs)
void DescribeNegationTo(::std::ostream *os) const
virtual void DescribeNegationTo(::std::ostream *os) const
bool MatchAndExplain(CharType *s, MatchResultListener *listener) const
static void CheckIsValid(Functor)
bool MatchAndExplain(const MatcheeStringType &s, MatchResultListener *) const
static const char * Desc()
bool MatchAndExplain(const MatcheeStringType &s, MatchResultListener *) const
RawPairType::first_type FirstType
const GenericPointer< typename T::ValueType > T2 value
virtual void DescribeTo(::std::ostream *os) const
void ExplainMatchResultTo(T x, ::std::ostream *os) const
virtual void DescribeNegationTo(::std::ostream *os) const
static bool CaseInsensitiveWideCStringEquals(const wchar_t *lhs, const wchar_t *rhs)
internal::StlContainerView< GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView
void PrintIfNotEmpty(const internal::string &explanation, ::std::ostream *os)
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
LtMatcher(const Rhs &rhs)
GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix &g)
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer
bool IsReadableTypeName(const string &type_name)
static string GetToName()
#define GTEST_COMPILE_ASSERT_(expr, msg)
GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl)
OutIter TransformTupleValues(Func f, const Tuple &t, OutIter out)
RawPairType::first_type KeyType
static void ExplainMatchFailuresTo(const MatcherTuple &matchers, const ValueTuple &values, ::std::ostream *os)
Matcher< Lhs > TypedEq(const Rhs &rhs)
virtual void DescribeTo(::std::ostream *os) const
NotMatcherImpl(const Matcher< T > &matcher)
void DescribeNegationTo(::std::ostream *os) const
Matcher< T > MatcherCast(const M &matcher)
::std::vector< string > Strings
PolymorphicMatcher< internal::HasSubstrMatcher< internal::string > > HasSubstr(const internal::string &substring)
void DescribeTo(::std::ostream *os) const
ElementsAreMatcherImpl(InputIter first, InputIter last)
#define GTEST_REMOVE_REFERENCE_AND_CONST_(T)
internal::ContainsMatcher< M > Contains(M matcher)
internal::FloatingEqMatcher< float > FloatNear(float rhs, float max_abs_error)
bool_constant< false > false_type
void DescribeTo(::std::ostream *os) const
bool operator()(const A &a, const B &b) const
BeginEndDistanceIsMatcher(const DistanceMatcher &distance_matcher)
bool StaticAssertTypeEq()
bool CaseInsensitiveStringEquals(const StringType &s1, const StringType &s2)
EqMatcher(const Rhs &rhs)
const internal::AnythingMatcher _
StlContainer::value_type Element
bool MatchAndExplain(CharType *s, MatchResultListener *listener) const
PolymorphicMatcher< internal::StrEqualityMatcher< internal::string > > StrEq(const internal::string &str)
std::iterator_traits< typename ContainerView::type::const_iterator >::difference_type DistanceType
virtual void DescribeNegationTo(::std::ostream *os) const
NeMatcher(const Rhs &rhs)
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
virtual void DescribeTo(::std::ostream *os) const
SizeIsMatcher(const SizeMatcher &size_matcher)
internal::StlContainerView< RawContainer > View
static bool Matches(const MatcherTuple &matcher_tuple, const ValueTuple &value_tuple)
bool MatchAndExplain(const Pointer &p, MatchResultListener *) const
DummyMatchResultListener()
internal::FloatingEqMatcher< double > DoubleEq(double rhs)
Impl(const SizeMatcher &size_matcher)
virtual void DescribeNegationTo(::std::ostream *os) const
RhsStlContainer::value_type RhsValue
Iter ArrayAwareFind(Iter begin, Iter end, const Element &elem)
EachMatcherImpl(InnerMatcher inner_matcher)
const GenericPointer< typename T::ValueType > & pointer
static Matcher< T > Cast(const Matcher< T > &matcher)
internal::PointeeMatcher< InnerMatcher > Pointee(const InnerMatcher &inner_matcher)
bool IsInterested() const
virtual bool MatchAndExplain(Container container, MatchResultListener *listener) const
PolymorphicMatcher< internal::FieldMatcher< Class, FieldType > > Field(FieldType Class::*field, const FieldMatcher &matcher)
bool MatchAndExplain(const T &value, MatchResultListener *listener) const
bool MatchAndExplain(const Pointer &p, MatchResultListener *) const
void ExplainMatchFailureTupleTo(const MatcherTuple &matchers, const ValueTuple &values, ::std::ostream *os)
internal::KeyMatcher< M > Key(M inner_matcher)
internal::UnorderedElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type > UnorderedElementsAreArray(Iter first, Iter last)
const Pointer::element_type * GetRawPointer(const Pointer &p)
internal::NotMatcher< InnerMatcher > Not(InnerMatcher m)
ComparisonBase(const Rhs &rhs)
internal::LtMatcher< Rhs > Lt(Rhs x)
internal::FloatingEqMatcher< double > NanSensitiveDoubleEq(double rhs)
FloatingEqMatcher(FloatType expected, bool nan_eq_nan)
void DescribeNegationTo(::std::ostream *os) const
PointeeMatcher(const InnerMatcher &matcher)
void DescribeNegationTo(::std::ostream *os) const
StlContainerView< RawContainer > View
Impl(const Comparator &comparator, const ContainerMatcher &matcher)
bool operator()(const A &a, const B &b) const
bool operator()(const T &x) const
void DescribeNegationTo(::std::ostream *os) const
virtual void DescribeNegationTo(::std::ostream *os) const
KeyMatcherImpl(InnerMatcher inner_matcher)
View::const_reference StlContainerReference
virtual void DescribeNegationTo(::std::ostream *os) const
BoundSecondMatcher(const Tuple2Matcher &tm, const Second &second)
void DescribeTo(::std::ostream *os) const
void UniversalPrint(const T &value, ::std::ostream *os)
virtual void DescribeTo(::std::ostream *os) const
StlContainer::const_iterator StlContainerConstIterator
internal::RefMatcher< T & > Ref(T &x)
MatcherAsPredicate(M matcher)
static ResultType Invoke(Functor f, T arg)
static const char * Desc()
Impl(const DistanceMatcher &distance_matcher)
internal::EachMatcher< M > Each(M matcher)
static const char * Desc()
virtual void DescribeNegationTo(::std::ostream *os) const
internal::NeMatcher< Rhs > Ne(Rhs x)
FieldMatcher(FieldType Class::*field, const Matcher< const FieldType &> &matcher)
BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
internal::AllOfResult2< M1, M2 >::type AllOf(M1 m1, M2 m2)