Lines Matching defs:it
61 // The two-level delegation design makes it possible to allow a user
63 // is impossible if we pass matchers by pointers. It also eases
96 // intends to hear it.
122 // It's the responsibility of the caller (Google Mock) to guarantee
124 // implementation when it doesn't care about the performance, as it
141 // MatcherInterface, but it is highly advised so that your matcher
188 // from it. We put functionalities common to all Matcher<T>
233 // memory. It has been observed that linked_ptr performs better in
255 // cannot use it until a valid value has been assigned to it.
304 // The PolymorphicMatcher class template makes it easy to implement a
364 // than the Matcher<T> constructor as it doesn't require you to
376 // easier to use than the PolymorphicMatcher<Impl> constructor as it
406 // its conversion operator to create Matcher<T>. Or it can be a value
410 // polymorphic matcher because it'll be ambiguous if T has an implicit
414 // It won't work to unconditionally implict_cast
415 // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
427 // matcher. It must be a value then. Use direct initialization to create
439 // Even if T has an implicit constructor from M, it won't be called because
494 // matcher m and returns a Matcher<T>. It compiles only when T can be
523 // argument from type T to U, and then pass it to the underlying Matcher<U>.
564 // If the explanation is not empty, prints it to the ostream.
576 // We consider a type name readable if it's short or doesn't contain
683 // value_tuple. It is a compiler error if matcher_tuple and
718 // This is mostly for completeness' safe, as it's not very useful
720 // such a possibility, and it doesn't hurt to be prepared.
727 // conversion operator to make it appearing as a Matcher<T> for any
826 // 'variable'. This matcher is polymorphic as it can match any
829 // The RefMatcher template class implements Ref(variable). It can
1205 // We do not nest it inside the NotMatcher class template, as that
1253 // T. We do not nest it inside the BothOfMatcher class template, as
1340 // T. We do not nest it inside the AnyOfMatcher class template, as
1486 // If we write Matcher<T>(matcher_).Matches(x) here, it won't
1488 // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
1490 // matcher_.Matches(x), it won't compile when matcher_ is
1519 // know which type to instantiate it to until we actually see the
1757 // Since *p has a field, it must be a class/struct/union type and
1821 // Since *p has a property method, it must be a class/struct/union
1911 // 'this' is a const pointer. It's the user's responsibility not to
1943 // We make a copy of rhs in case the elements in it are modified
1977 for (typename LhsStlContainer::const_iterator it =
1979 it != lhs_stl_container.end(); ++it) {
1980 if (internal::ArrayAwareFind(rhs_.begin(), rhs_.end(), *it) ==
1988 UniversalPrint(*it, os);
1994 for (typename StlContainer::const_iterator it = rhs_.begin();
1995 it != rhs_.end(); ++it) {
1997 lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
2006 UniversalPrint(*it, os);
2111 // it are modified after this matcher is created.
2232 for (typename StlContainer::const_iterator it = stl_container.begin();
2233 it != stl_container.end(); ++it, ++i) {
2235 const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
2532 InputIter it = first;
2533 for (size_t i = 0; i != a_count; ++i, ++it) {
2534 matchers_.push_back(MatcherCast<const Element&>(*it));
2589 typename StlContainer::const_iterator it = stl_container.begin();
2592 for (size_t i = 0; i != count(); ++it, ++i) {
2594 if (matchers_[i].MatchAndExplain(*it, &s)) {
2690 // so it's OK to create global variables of this type.
2721 // it yet as those are used much less than Eq() in practice. A user
2820 // matchers of compatible types. For example, it allows
2838 // matchers of compatible types. For example, it allows
2850 // * It is required to keep no state affecting the results of
2851 // the calls on it and make no assumptions about how many calls
2852 // will be made. Any state it keeps must be protected from the
2854 // * If it is a function object, it has to define type result_type.
2864 // matchers of compatible types. For example, it allows
