Lines Matching full:matchers
372 // ArgumentMatcherTuple: the tuple type consisting of Matchers for all
4626 // ON_CALL(mock_object, Method(argument-matchers))
4635 // EXPECT_CALL(mock_object, Method(argument-matchers))
4636 // .With(multi-argument-matchers)
4693 // This file implements some commonly used argument matchers. More
4694 // matchers can be defined by the user implementing the
4725 // is impossible if we pass matchers by pointers. It also eases
5255 // This overload handles polymorphic matchers and values only since
5256 // monomorphic matchers are handled by the next one.
5262 // This overload handles monomorphic matchers.
5329 // Value cannot be passed by const reference, because some matchers take a
5370 // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
5371 // describes failures in matching the first N fields of matchers
5375 static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
5382 TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
5387 get<N - 1>(matchers);
5395 get<N - 1>(matchers).DescribeTo(os);
5420 static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
5426 // matchers in matcher_tuple match the corresponding fields in
5443 // Describes failures in matching matchers against values. If there
5446 void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
5451 matchers, values, os);
5683 // Polymorphic helper functions for narrow and wide string matchers.
5716 // String matchers.
5718 // Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
5917 // Implements polymorphic matchers MatchesRegex(regex) and
6132 // MatcherList provides mechanisms for storing a variable number of matchers in
6138 // * Tail denotes the types of the remaining matchers of the list.
6152 // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
6153 // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
6157 static Matcher<T> CreateMatcher(const ListType& matchers) {
6159 SafeMatcherCast<T>(matchers.first),
6161 matchers.second)));
6177 static Matcher<T> CreateMatcher(const ListType& matchers) {
6179 SafeMatcherCast<T>(matchers.first),
6180 SafeMatcherCast<T>(matchers.second)));
6186 // CombiningMatcher<T> is used to recursively combine the provided matchers
6191 VariadicMatcher(const Args&... matchers) // NOLINT
6192 : matchers_(MatcherListType::BuildList(matchers...)) {}
6196 // all of the provided matchers (Matcher1, Matcher2, ...) can match.
6217 // matches a value that matches all of the matchers m_1, ..., and m_n.
6311 // matches a value that matches at least one of the matchers m_1, ...,
7414 // type with its two matchers. See Pair() function below.
7532 // element matchers.
7590 // Go through the elements and matchers in pairs, until we reach
7591 // the end of either the elements or the matchers, or until we find a
7668 // Connectivity matrix of (elements X matchers), in element-major order.
7730 // element matchers are alive).
7772 // element matchers.
7877 MatcherVec matchers;
7878 matchers.reserve(::std::tr1::tuple_size<MatcherTuple>::value);
7880 ::std::back_inserter(matchers));
7882 matchers.begin(), matchers.end()));
7902 MatcherVec matchers;
7903 matchers.reserve(::std::tr1::tuple_size<MatcherTuple>::value);
7905 ::std::back_inserter(matchers));
7907 matchers.begin(), matchers.end()));
7979 // can be either a sequence of values or a sequence of matchers.
8095 // We could define similar monomorphic matchers for other comparison
8228 // matchers of compatible types. For example, it allows
8246 // matchers of compatible types. For example, it allows
8272 // matchers of compatible types. For example, it allows
8277 // String matchers.
8352 // Wide string matchers.
8608 // gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
8610 inline internal::AllOfMatcher<Args...> AllOf(const Args&... matchers) {
8611 return internal::AllOfMatcher<Args...>(matchers...);
8615 inline internal::AnyOfMatcher<Args...> AnyOf(const Args&... matchers) {
8616 return internal::AnyOfMatcher<Args...>(matchers...);
8631 // These macros allow using matchers to check values in Google Test
8857 const ArgumentMatcherTuple& matchers)
8859 matchers_(matchers),
8892 // Returns true iff the given arguments match the matchers.
8908 // ON_CALL(mock_object, Method(matchers))
8916 // matchers => matchers_
9610 // Returns the matchers for the arguments as specified inside the
9612 const ArgumentMatcherTuple& matchers() const {
9844 void SetMatchers(const ArgumentMatcherTuple& matchers) {
9845 matchers_ = matchers;
9850 // The argument matchers specified in the spec.
11700 // pump.py gmock-generated-matchers.h.pump
11734 // This file implements some commonly used variadic matchers.
12706 // sub-matchers. AllOf is called fully qualified to prevent ADL from firing.
12789 // sub-matchers. AnyOf is called fully qualified to prevent ADL from firing.
12875 // define custom matchers easily.
12933 // Parameterizing Matchers
12964 // support multi-parameter matchers.
12966 // Describing Parameterized Matchers
13029 // can be useful when composing matchers.
13057 // Overloading Matchers
13060 // You can overload matchers with different numbers of parameters:
13074 // overloading matchers based on parameter types (as opposed to just
14153 // This file implements some matchers that depend on gmock-generated-matchers.h.
14156 // gmock-more-matchers-test.cc.
