include/gmock/gmock-matchers.h

74 // used by a matcher to explain why a value matches or doesn't match.
78 // to indicate whether the listener is interested in why the match
101   // the match result.  A matcher's MatchAndExplain() method can use
145   // Returns true iff the matcher matches x; also explains the match
153   // the match result *if and only if* they can provide additional
155   // print-out of x and the matcher's description.  Whether the match
158   // when the match succeeds (e.g. when the matcher is used inside
162   // what the actual element count is, regardless of the match result,
165   // size is when the match fails, as it's redundant to say that the
183 // A match result listener that stores the explanation in a string.
227 // A match result listener that ignores the explanation.
236 // A match result listener that forwards the explanation to a given
254   // Returns true iff the matcher matches x; also explains the match
274   // Explains why x matches, or doesn't match, the matcher.
418 // polymorphic matcher (i.e. a matcher that can match values of more
696 // the match result to the listener. Returns the match result.
710   const bool match = matcher.MatchAndExplain(value, &inner_listener);
720   return match;
791 // matchers in matcher_tuple match the corresponding fields in
887 // used to match an int, a short, a double, etc).  Therefore we use
1016 // 'variable'.  This matcher is polymorphic as it can match any
1021 // from mistakenly using Ref(x) to match a non-reference function
1061     // in order to match the interface MatcherInterface<Super&>.
1360     *os << "doesn't " << (full_match_ ? "match" : "contain")
1377 // used to match a tuple<int, short>, a tuple<const long&, double>,
1468 // match matcher m.
1475   // to match any type m can match.
1514     // If either matcher1_ or matcher2_ doesn't match x, we only need
1528     // Otherwise we need to explain why *both* of them match.
1614   // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
1615   // all of the provided matchers (Matcher1, Matcher2, ...) can match.
1644   // BothOfMatcher<Matcher1, Matcher2> object to match any type that
1645   // both Matcher1 and Matcher2 can match.
1739   // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
1740   // both Matcher1 and Matcher2 can match.
1934         // We perform an equality check so that inf will match inf, regardless
1937         // which should only match if max_abs_error_ is also infinity.
2208   // true_type iff the Field() matcher is used to match a pointer.
2269   // true_type iff the Property() matcher is used to match a pointer.
2434           << "whose size " << size << (result ? " matches" : " doesn't match");
2495                 << (result ? " matches" : " doesn't match");
2632     // so that we can match associative containers.
2668       const bool match = matcher_.MatchAndExplain(sorted_container,
2671       return match;
2771             *listener << ") at index #" << i << " don't match";
2814   // * All elements in the container match, if all_elements_should_match.
2828                   << (matches ? " matches" : " doesn't match");
2936 // inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
2954     const bool match = inner_matcher_.MatchAndExplain(key_value.first,
2960     return match;
3044       *listener << "whose first field does not match";
3051       *listener << "whose second field does not match";
3064     *listener << "whose both fields match";
3179       bool match;  // Does the current element match the current matcher?
3182         match = matchers_[exam_pos].MatchAndExplain(*it, &s);
3185         match = matchers_[exam_pos].Matches(*it);
3188       if (!match) {
3204       // The element count doesn't match.  If the container is empty,
3215       // The element count matches, but the exam_pos-th element doesn't match.
3217         *listener << "whose element #" << exam_pos << " doesn't match";
3390       // The element count doesn't match.  If the container is empty,
4105 // match.
4319 // inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
4329 // to match a std::map<int, string> that contains exactly one element whose key
4351 // Matches the value against the given matcher and explains the match