Lines Matching defs:match
43 // which must return a bool to indicate if the match succeeds. Inside
48 // to generate the failure message when the match fails. Since a
85 // polymorphic. For example, IsEven() can be used to match any type
200 // the match has failed or succeeded. For example, when expecting a
303 // A match result listener that stores the explanation in a string.
581 // the match result to the listener. Returns the match result.
595 const bool match = matcher.MatchAndExplain(value, &inner_listener);
605 return match;
674 // all matchers in matcher_tuple match the corresponding fields in
789 // 'variable'. This matcher is polymorphic as it can match any
794 // from mistakenly using Ref(x) to match a non-reference function
834 // in order to match the interface MatcherInterface<Super&>.
1153 *os << "does not match after Base64Unescape ";
1166 // used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
1254 // match matcher m.
1261 // to match any type m can match.
1301 // If either matcher1_ or matcher2_ doesn't match x, we only need
1323 // Otherwise we need to explain why *both* of them match.
1348 // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
1349 // all of the provided matchers (Matcher1, Matcher2, ...) can match.
1590 // The expected path here is that the matcher should match (i.e. that most
1689 // We perform an equality check so that inf will match inf, regardless
1692 // which should only match if max_abs_error_ is also infinity.
1920 // m. The pointer can be either raw or smart, and will match `m` against the
2327 << (result ? " matches" : " doesn't match");
2383 << (result ? " matches" : " doesn't match");
2514 // so that we can match associative containers.
2551 const bool match =
2554 return match;
2666 *listener << ") at index #" << i << " don't match";
2707 // * All elements in the container match, if all_elements_should_match.
2720 << (matches ? " matches" : " doesn't match");
2754 *listener << ") match";
2759 *listener << " and whose match quantity of " << match_elements.size()
2769 *listener << " whose match quantity of " << match_elements.size()
2770 << " does not match";
2844 *os << "quantity of elements that match ";
2851 *os << "quantity of elements that match ";
2946 // inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an
2964 const bool match = inner_matcher_.MatchAndExplain(
2970 return match;
3093 *listener << "whose first field does not match";
3100 *listener << "whose second field does not match";
3113 *listener << "whose both fields match";
3154 "Number of arguments doesn't match the number of fields.");
3325 *listener << "whose field #" << failed_pos << " does not match";
3330 *listener << "whose all elements match";
3435 bool match; // Does the current element match the current matcher?
3438 match = matchers_[exam_pos].MatchAndExplain(*it, &s);
3441 match = matchers_[exam_pos].Matches(*it);
3444 if (!match) {
3460 // The element count doesn't match. If the container is empty,
3471 // The element count matches, but the exam_pos-th element doesn't match.
3473 *listener << "whose element #" << exam_pos << " doesn't match";
3914 const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
3916 << (match ? " matches" : " doesn't match");
3918 return match;
3958 const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
3960 << (match ? " matches" : " doesn't match");
3962 return match;
4019 const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
4021 << (match ? " matches" : " doesn't match");
4023 return match;
4077 const bool match =
4080 return match;
4657 // match.
4840 // in order to have a match. Examples:
4844 // - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
4898 // only if there is a subset of matchers {m1, ..., mk} which would match the
4900 // must be <= n in order to have a match. Examples:
4906 // match Gt(0). The reason is that different matchers must be used for
4980 // inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an
4990 // to match a std::map<int, string> that contains exactly one element whose key
5061 // Matches the value against the given matcher and explains the match