1 // Copyright 2007, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 // Author: wan@google.com (Zhanyong Wan)
32 // Google Mock - a framework for writing C++ mock classes.
34 // This file implements some commonly used argument matchers. More
35 // matchers can be defined by the user implementing the
36 // MatcherInterface<T> interface if necessary.
38 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
39 #define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
45 #include <ostream> // NOLINT
51 #include "gmock/internal/gmock-internal-utils.h"
52 #include "gmock/internal/gmock-port.h"
53 #include "gtest/gtest.h"
55 #if GTEST_HAS_STD_INITIALIZER_LIST_
56 # include <initializer_list> // NOLINT -- must be after gtest.h
61 // To implement a matcher Foo for type T, define:
62 // 1. a class FooMatcherImpl that implements the
63 // MatcherInterface<T> interface, and
64 // 2. a factory function that creates a Matcher<T> object from a
67 // The two-level delegation design makes it possible to allow a user
68 // to write "v" instead of "Eq(v)" where a Matcher is expected, which
69 // is impossible if we pass matchers by pointers. It also eases
70 // ownership management as Matcher objects can now be copied like
73 // MatchResultListener is an abstract class. Its << operator can be
74 // used by a matcher to explain why a value matches or doesn't match.
76 // TODO(wan@google.com): add method
77 // bool InterestedInWhy(bool result) const;
78 // to indicate whether the listener is interested in why the match
79 // result is 'result'.
80 class MatchResultListener {
82 // Creates a listener object with the given underlying ostream. The
83 // listener does not own the ostream, and does not dereference it
84 // in the constructor or destructor.
85 explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
86 virtual ~MatchResultListener() = 0; // Makes this class abstract.
88 // Streams x to the underlying ostream; does nothing if the ostream
91 MatchResultListener& operator<<(const T& x) {
97 // Returns the underlying ostream.
98 ::std::ostream* stream() { return stream_; }
100 // Returns true iff the listener is interested in an explanation of
101 // the match result. A matcher's MatchAndExplain() method can use
102 // this information to avoid generating the explanation when no one
103 // intends to hear it.
104 bool IsInterested() const { return stream_ != NULL; }
107 ::std::ostream* const stream_;
109 GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
112 inline MatchResultListener::~MatchResultListener() {
115 // An instance of a subclass of this knows how to describe itself as a
117 class MatcherDescriberInterface {
119 virtual ~MatcherDescriberInterface() {}
121 // Describes this matcher to an ostream. The function should print
122 // a verb phrase that describes the property a value matching this
123 // matcher should have. The subject of the verb phrase is the value
124 // being matched. For example, the DescribeTo() method of the Gt(7)
125 // matcher prints "is greater than 7".
126 virtual void DescribeTo(::std::ostream* os) const = 0;
128 // Describes the negation of this matcher to an ostream. For
129 // example, if the description of this matcher is "is greater than
130 // 7", the negated description could be "is not greater than 7".
131 // You are not required to override this when implementing
132 // MatcherInterface, but it is highly advised so that your matcher
133 // can produce good error messages.
134 virtual void DescribeNegationTo(::std::ostream* os) const {
141 // The implementation of a matcher.
142 template <typename T>
143 class MatcherInterface : public MatcherDescriberInterface {
145 // Returns true iff the matcher matches x; also explains the match
146 // result to 'listener' if necessary (see the next paragraph), in
147 // the form of a non-restrictive relative clause ("which ...",
148 // "whose ...", etc) that describes x. For example, the
149 // MatchAndExplain() method of the Pointee(...) matcher should
150 // generate an explanation like "which points to ...".
152 // Implementations of MatchAndExplain() should add an explanation of
153 // the match result *if and only if* they can provide additional
154 // information that's not already present (or not obvious) in the
155 // print-out of x and the matcher's description. Whether the match
156 // succeeds is not a factor in deciding whether an explanation is
157 // needed, as sometimes the caller needs to print a failure message
158 // when the match succeeds (e.g. when the matcher is used inside
161 // For example, a "has at least 10 elements" matcher should explain
162 // what the actual element count is, regardless of the match result,
163 // as it is useful information to the reader; on the other hand, an
164 // "is empty" matcher probably only needs to explain what the actual
165 // size is when the match fails, as it's redundant to say that the
166 // size is 0 when the value is already known to be empty.
168 // You should override this method when defining a new matcher.
170 // It's the responsibility of the caller (Google Mock) to guarantee
171 // that 'listener' is not NULL. This helps to simplify a matcher's
172 // implementation when it doesn't care about the performance, as it
173 // can talk to 'listener' without checking its validity first.
174 // However, in order to implement dummy listeners efficiently,
175 // listener->stream() may be NULL.
176 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
178 // Inherits these methods from MatcherDescriberInterface:
179 // virtual void DescribeTo(::std::ostream* os) const = 0;
180 // virtual void DescribeNegationTo(::std::ostream* os) const;
183 // A match result listener that stores the explanation in a string.
184 class StringMatchResultListener : public MatchResultListener {
186 StringMatchResultListener() : MatchResultListener(&ss_) {}
188 // Returns the explanation accumulated so far.
189 internal::string str() const { return ss_.str(); }
191 // Clears the explanation accumulated so far.
192 void Clear() { ss_.str(""); }
195 ::std::stringstream ss_;
197 GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
203 template <typename A, typename B>
204 bool operator()(const A& a, const B& b) const { return a == b; }
207 template <typename A, typename B>
208 bool operator()(const A& a, const B& b) const { return a != b; }
211 template <typename A, typename B>
212 bool operator()(const A& a, const B& b) const { return a < b; }
215 template <typename A, typename B>
216 bool operator()(const A& a, const B& b) const { return a > b; }
219 template <typename A, typename B>
220 bool operator()(const A& a, const B& b) const { return a <= b; }
223 template <typename A, typename B>
224 bool operator()(const A& a, const B& b) const { return a >= b; }
227 // A match result listener that ignores the explanation.
228 class DummyMatchResultListener : public MatchResultListener {
230 DummyMatchResultListener() : MatchResultListener(NULL) {}
233 GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
236 // A match result listener that forwards the explanation to a given
237 // ostream. The difference between this and MatchResultListener is
238 // that the former is concrete.
239 class StreamMatchResultListener : public MatchResultListener {
241 explicit StreamMatchResultListener(::std::ostream* os)
242 : MatchResultListener(os) {}
245 GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
248 // An internal class for implementing Matcher<T>, which will derive
249 // from it. We put functionalities common to all Matcher<T>
250 // specializations here to avoid code duplication.
251 template <typename T>
254 // Returns true iff the matcher matches x; also explains the match
255 // result to 'listener'.
256 bool MatchAndExplain(T x, MatchResultListener* listener) const {
257 return impl_->MatchAndExplain(x, listener);
260 // Returns true iff this matcher matches x.
261 bool Matches(T x) const {
262 DummyMatchResultListener dummy;
263 return MatchAndExplain(x, &dummy);
266 // Describes this matcher to an ostream.
267 void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
269 // Describes the negation of this matcher to an ostream.
270 void DescribeNegationTo(::std::ostream* os) const {
271 impl_->DescribeNegationTo(os);
274 // Explains why x matches, or doesn't match, the matcher.
275 void ExplainMatchResultTo(T x, ::std::ostream* os) const {
276 StreamMatchResultListener listener(os);
277 MatchAndExplain(x, &listener);
280 // Returns the describer for this matcher object; retains ownership
281 // of the describer, which is only guaranteed to be alive when
282 // this matcher object is alive.
283 const MatcherDescriberInterface* GetDescriber() const {
290 // Constructs a matcher from its implementation.
291 explicit MatcherBase(const MatcherInterface<T>* impl)
294 virtual ~MatcherBase() {}
297 // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
298 // interfaces. The former dynamically allocates a chunk of memory
299 // to hold the reference count, while the latter tracks all
300 // references using a circular linked list without allocating
301 // memory. It has been observed that linked_ptr performs better in
302 // typical scenarios. However, shared_ptr can out-perform
303 // linked_ptr when there are many more uses of the copy constructor
304 // than the default constructor.
306 // If performance becomes a problem, we should see if using
308 ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
311 } // namespace internal
313 // A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
314 // object that can check whether a value of type T matches. The
315 // implementation of Matcher<T> is just a linked_ptr to const
316 // MatcherInterface<T>, so copying is fairly cheap. Don't inherit
318 template <typename T>
319 class Matcher : public internal::MatcherBase<T> {
321 // Constructs a null matcher. Needed for storing Matcher objects in STL
322 // containers. A default-constructed matcher is not yet initialized. You
323 // cannot use it until a valid value has been assigned to it.
324 explicit Matcher() {} // NOLINT
326 // Constructs a matcher from its implementation.
327 explicit Matcher(const MatcherInterface<T>* impl)
328 : internal::MatcherBase<T>(impl) {}
330 // Implicit constructor here allows people to write
331 // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
332 Matcher(T value); // NOLINT
335 // The following two specializations allow the user to write str
336 // instead of Eq(str) and "foo" instead of Eq("foo") when a string
337 // matcher is expected.
339 class GTEST_API_ Matcher<const internal::string&>
340 : public internal::MatcherBase<const internal::string&> {
344 explicit Matcher(const MatcherInterface<const internal::string&>* impl)
345 : internal::MatcherBase<const internal::string&>(impl) {}
347 // Allows the user to write str instead of Eq(str) sometimes, where
348 // str is a string object.
349 Matcher(const internal::string& s); // NOLINT
351 // Allows the user to write "foo" instead of Eq("foo") sometimes.
352 Matcher(const char* s); // NOLINT
356 class GTEST_API_ Matcher<internal::string>
357 : public internal::MatcherBase<internal::string> {
361 explicit Matcher(const MatcherInterface<internal::string>* impl)
362 : internal::MatcherBase<internal::string>(impl) {}
364 // Allows the user to write str instead of Eq(str) sometimes, where
365 // str is a string object.
366 Matcher(const internal::string& s); // NOLINT
368 // Allows the user to write "foo" instead of Eq("foo") sometimes.
369 Matcher(const char* s); // NOLINT
372 #if GTEST_HAS_STRING_PIECE_
373 // The following two specializations allow the user to write str
374 // instead of Eq(str) and "foo" instead of Eq("foo") when a StringPiece
375 // matcher is expected.
377 class GTEST_API_ Matcher<const StringPiece&>
378 : public internal::MatcherBase<const StringPiece&> {
382 explicit Matcher(const MatcherInterface<const StringPiece&>* impl)
383 : internal::MatcherBase<const StringPiece&>(impl) {}
385 // Allows the user to write str instead of Eq(str) sometimes, where
386 // str is a string object.
387 Matcher(const internal::string& s); // NOLINT
389 // Allows the user to write "foo" instead of Eq("foo") sometimes.
390 Matcher(const char* s); // NOLINT
392 // Allows the user to pass StringPieces directly.
393 Matcher(StringPiece s); // NOLINT
397 class GTEST_API_ Matcher<StringPiece>
398 : public internal::MatcherBase<StringPiece> {
402 explicit Matcher(const MatcherInterface<StringPiece>* impl)
403 : internal::MatcherBase<StringPiece>(impl) {}
405 // Allows the user to write str instead of Eq(str) sometimes, where
406 // str is a string object.
407 Matcher(const internal::string& s); // NOLINT
409 // Allows the user to write "foo" instead of Eq("foo") sometimes.
410 Matcher(const char* s); // NOLINT
412 // Allows the user to pass StringPieces directly.
413 Matcher(StringPiece s); // NOLINT
415 #endif // GTEST_HAS_STRING_PIECE_
417 // The PolymorphicMatcher class template makes it easy to implement a
418 // polymorphic matcher (i.e. a matcher that can match values of more
419 // than one type, e.g. Eq(n) and NotNull()).
421 // To define a polymorphic matcher, a user should provide an Impl
422 // class that has a DescribeTo() method and a DescribeNegationTo()
423 // method, and define a member function (or member function template)
425 // bool MatchAndExplain(const Value& value,
426 // MatchResultListener* listener) const;
428 // See the definition of NotNull() for a complete example.
429 template <class Impl>
430 class PolymorphicMatcher {
432 explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
434 // Returns a mutable reference to the underlying matcher
435 // implementation object.
436 Impl& mutable_impl() { return impl_; }
438 // Returns an immutable reference to the underlying matcher
439 // implementation object.
440 const Impl& impl() const { return impl_; }
442 template <typename T>
443 operator Matcher<T>() const {
444 return Matcher<T>(new MonomorphicImpl<T>(impl_));
448 template <typename T>
449 class MonomorphicImpl : public MatcherInterface<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);
468 GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
473 GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
476 // Creates a matcher from its implementation. This is easier to use
477 // than the Matcher<T> constructor as it doesn't require you to
478 // explicitly write the template argument, e.g.
482 // Matcher<const string&>(foo);
483 template <typename T>
484 inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
485 return Matcher<T>(impl);
488 // Creates a polymorphic matcher from its implementation. This is
489 // easier to use than the PolymorphicMatcher<Impl> constructor as it
490 // doesn't require you to explicitly write the template argument, e.g.
492 // MakePolymorphicMatcher(foo);
494 // PolymorphicMatcher<TypeOfFoo>(foo);
495 template <class Impl>
496 inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
497 return PolymorphicMatcher<Impl>(impl);
500 // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
501 // and MUST NOT BE USED IN USER CODE!!!
504 // The MatcherCastImpl class template is a helper for implementing
505 // MatcherCast(). We need this helper in order to partially
506 // specialize the implementation of MatcherCast() (C++ allows
507 // class/struct templates to be partially specialized, but not
508 // function templates.).
510 // This general version is used when MatcherCast()'s argument is a
511 // polymorphic matcher (i.e. something that can be converted to a
512 // Matcher but is not one yet; for example, Eq(value)) or a value (for
513 // example, "hello").
514 template <typename T, typename M>
515 class MatcherCastImpl {
517 static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
518 // M can be a polymorhic matcher, in which case we want to use
519 // its conversion operator to create Matcher<T>. Or it can be a value
520 // that should be passed to the Matcher<T>'s constructor.
522 // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
523 // polymorphic matcher because it'll be ambiguous if T has an implicit
524 // constructor from M (this usually happens when T has an implicit
525 // constructor from any type).
527 // It won't work to unconditionally implict_cast
528 // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
529 // a user-defined conversion from M to T if one exists (assuming M is
532 polymorphic_matcher_or_value,
534 internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
538 static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
539 // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
540 // matcher. It must be a value then. Use direct initialization to create
542 return Matcher<T>(ImplicitCast_<T>(value));
545 static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
546 BooleanConstant<true>) {
547 // M is implicitly convertible to Matcher<T>, which means that either
548 // M is a polymorhpic matcher or Matcher<T> has an implicit constructor
549 // from M. In both cases using the implicit conversion will produce a
552 // Even if T has an implicit constructor from M, it won't be called because
553 // creating Matcher<T> would require a chain of two user-defined conversions
554 // (first to create T from M and then to create Matcher<T> from T).
555 return polymorphic_matcher_or_value;
559 // This more specialized version is used when MatcherCast()'s argument
560 // is already a Matcher. This only compiles when type T can be
561 // statically converted to type U.
562 template <typename T, typename U>
563 class MatcherCastImpl<T, Matcher<U> > {
565 static Matcher<T> Cast(const Matcher<U>& source_matcher) {
566 return Matcher<T>(new Impl(source_matcher));
570 class Impl : public MatcherInterface<T> {
572 explicit Impl(const Matcher<U>& source_matcher)
573 : source_matcher_(source_matcher) {}
575 // We delegate the matching logic to the source matcher.
576 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
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_;
591 GTEST_DISALLOW_ASSIGN_(Impl);
595 // This even more specialized version is used for efficiently casting
596 // a matcher to its own type.
597 template <typename T>
598 class MatcherCastImpl<T, Matcher<T> > {
600 static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
603 } // namespace internal
605 // In order to be safe and clear, casting between different matcher
606 // types is done explicitly via MatcherCast<T>(m), which takes a
607 // matcher m and returns a Matcher<T>. It compiles only when T can be
608 // statically converted to the argument type of m.
609 template <typename T, typename M>
610 inline Matcher<T> MatcherCast(const M& matcher) {
611 return internal::MatcherCastImpl<T, M>::Cast(matcher);
614 // Implements SafeMatcherCast().
616 // We use an intermediate class to do the actual safe casting as Nokia's
617 // Symbian compiler cannot decide between
618 // template <T, M> ... (M) and
619 // template <T, U> ... (const Matcher<U>&)
620 // for function templates but can for member function templates.
621 template <typename T>
622 class SafeMatcherCastImpl {
624 // This overload handles polymorphic matchers and values only since
625 // monomorphic matchers are handled by the next one.
626 template <typename M>
627 static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
628 return internal::MatcherCastImpl<T, M>::Cast(polymorphic_matcher_or_value);
631 // This overload handles monomorphic matchers.
633 // In general, if type T can be implicitly converted to type U, we can
634 // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
635 // contravariant): just keep a copy of the original Matcher<U>, convert the
636 // argument from type T to U, and then pass it to the underlying Matcher<U>.
637 // The only exception is when U is a reference and T is not, as the
638 // underlying Matcher<U> may be interested in the argument's address, which
639 // is not preserved in the conversion from T to U.
640 template <typename U>
641 static inline Matcher<T> Cast(const Matcher<U>& matcher) {
642 // Enforce that T can be implicitly converted to U.
643 GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
644 T_must_be_implicitly_convertible_to_U);
645 // Enforce that we are not converting a non-reference type T to a reference
647 GTEST_COMPILE_ASSERT_(
648 internal::is_reference<T>::value || !internal::is_reference<U>::value,
649 cannot_convert_non_referentce_arg_to_reference);
650 // In case both T and U are arithmetic types, enforce that the
651 // conversion is not lossy.
652 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
653 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
654 const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
655 const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
656 GTEST_COMPILE_ASSERT_(
657 kTIsOther || kUIsOther ||
658 (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
659 conversion_of_arithmetic_types_must_be_lossless);
660 return MatcherCast<T>(matcher);
664 template <typename T, typename M>
665 inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
666 return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
669 // A<T>() returns a matcher that matches any value of type T.
670 template <typename T>
673 // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
674 // and MUST NOT BE USED IN USER CODE!!!
677 // If the explanation is not empty, prints it to the ostream.
678 inline void PrintIfNotEmpty(const internal::string& explanation,
679 ::std::ostream* os) {
680 if (explanation != "" && os != NULL) {
681 *os << ", " << explanation;
685 // Returns true if the given type name is easy to read by a human.
686 // This is used to decide whether printing the type of a value might
688 inline bool IsReadableTypeName(const string& type_name) {
689 // We consider a type name readable if it's short or doesn't contain
690 // a template or function type.
691 return (type_name.length() <= 20 ||
692 type_name.find_first_of("<(") == string::npos);
695 // Matches the value against the given matcher, prints the value and explains
696 // the match result to the listener. Returns the match result.
697 // 'listener' must not be NULL.
698 // Value cannot be passed by const reference, because some matchers take a
699 // non-const argument.
700 template <typename Value, typename T>
701 bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
702 MatchResultListener* listener) {
703 if (!listener->IsInterested()) {
704 // If the listener is not interested, we do not need to construct the
705 // inner explanation.
706 return matcher.Matches(value);
709 StringMatchResultListener inner_listener;
710 const bool match = matcher.MatchAndExplain(value, &inner_listener);
712 UniversalPrint(value, listener->stream());
714 const string& type_name = GetTypeName<Value>();
715 if (IsReadableTypeName(type_name))
716 *listener->stream() << " (of type " << type_name << ")";
718 PrintIfNotEmpty(inner_listener.str(), listener->stream());
723 // An internal helper class for doing compile-time loop on a tuple's
728 // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
729 // iff the first N fields of matcher_tuple matches the first N
730 // fields of value_tuple, respectively.
731 template <typename MatcherTuple, typename ValueTuple>
732 static bool Matches(const MatcherTuple& matcher_tuple,
733 const ValueTuple& value_tuple) {
734 return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple)
735 && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
738 // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
739 // describes failures in matching the first N fields of matchers
740 // against the first N fields of values. If there is no failure,
741 // nothing will be streamed to os.
742 template <typename MatcherTuple, typename ValueTuple>
743 static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
744 const ValueTuple& values,
745 ::std::ostream* os) {
746 // First, describes failures in the first N - 1 fields.
747 TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
749 // Then describes the failure (if any) in the (N - 1)-th (0-based)
751 typename tuple_element<N - 1, MatcherTuple>::type matcher =
752 get<N - 1>(matchers);
753 typedef typename tuple_element<N - 1, ValueTuple>::type Value;
754 Value value = get<N - 1>(values);
755 StringMatchResultListener listener;
756 if (!matcher.MatchAndExplain(value, &listener)) {
757 // TODO(wan): include in the message the name of the parameter
758 // as used in MOCK_METHOD*() when possible.
759 *os << " Expected arg #" << N - 1 << ": ";
760 get<N - 1>(matchers).DescribeTo(os);
761 *os << "\n Actual: ";
762 // We remove the reference in type Value to prevent the
763 // universal printer from printing the address of value, which
764 // isn't interesting to the user most of the time. The
765 // matcher's MatchAndExplain() method handles the case when
766 // the address is interesting.
767 internal::UniversalPrint(value, os);
768 PrintIfNotEmpty(listener.str(), os);
776 class TuplePrefix<0> {
778 template <typename MatcherTuple, typename ValueTuple>
779 static bool Matches(const MatcherTuple& /* matcher_tuple */,
780 const ValueTuple& /* value_tuple */) {
784 template <typename MatcherTuple, typename ValueTuple>
785 static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
786 const ValueTuple& /* values */,
787 ::std::ostream* /* os */) {}
790 // TupleMatches(matcher_tuple, value_tuple) returns true iff all
791 // matchers in matcher_tuple match the corresponding fields in
792 // value_tuple. It is a compiler error if matcher_tuple and
793 // value_tuple have different number of fields or incompatible field
795 template <typename MatcherTuple, typename ValueTuple>
796 bool TupleMatches(const MatcherTuple& matcher_tuple,
797 const ValueTuple& value_tuple) {
798 // Makes sure that matcher_tuple and value_tuple have the same
800 GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
801 tuple_size<ValueTuple>::value,
802 matcher_and_value_have_different_numbers_of_fields);
803 return TuplePrefix<tuple_size<ValueTuple>::value>::
804 Matches(matcher_tuple, value_tuple);
807 // Describes failures in matching matchers against values. If there
808 // is no failure, nothing will be streamed to os.
809 template <typename MatcherTuple, typename ValueTuple>
810 void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
811 const ValueTuple& values,
812 ::std::ostream* os) {
813 TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
814 matchers, values, os);
817 // TransformTupleValues and its helper.
819 // TransformTupleValuesHelper hides the internal machinery that
820 // TransformTupleValues uses to implement a tuple traversal.
821 template <typename Tuple, typename Func, typename OutIter>
822 class TransformTupleValuesHelper {
824 typedef ::testing::tuple_size<Tuple> TupleSize;
827 // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
828 // Returns the final value of 'out' in case the caller needs it.
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 /* f */, const Tup& /* t */, OutIter out) const {
849 // Successively invokes 'f(element)' on each element of the tuple 't',
850 // appending each result to the 'out' iterator. Returns the final value
852 template <typename Tuple, typename Func, typename OutIter>
853 OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
854 return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
857 // Implements A<T>().
858 template <typename T>
859 class AnyMatcherImpl : public MatcherInterface<T> {
861 virtual bool MatchAndExplain(
862 T /* x */, MatchResultListener* /* listener */) const { return true; }
863 virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
864 virtual void DescribeNegationTo(::std::ostream* os) const {
865 // This is mostly for completeness' safe, as it's not very useful
866 // to write Not(A<bool>()). However we cannot completely rule out
867 // such a possibility, and it doesn't hurt to be prepared.
868 *os << "never matches";
872 // Implements _, a matcher that matches any value of any
873 // type. This is a polymorphic matcher, so we need a template type
874 // conversion operator to make it appearing as a Matcher<T> for any
876 class AnythingMatcher {
878 template <typename T>
879 operator Matcher<T>() const { return A<T>(); }
882 // Implements a matcher that compares a given value with a
883 // pre-supplied value using one of the ==, <=, <, etc, operators. The
884 // two values being compared don't have to have the same type.
886 // The matcher defined here is polymorphic (for example, Eq(5) can be
887 // used to match an int, a short, a double, etc). Therefore we use
888 // a template type conversion operator in the implementation.
890 // The following template definition assumes that the Rhs parameter is
891 // a "bare" type (i.e. neither 'const T' nor 'T&').
892 template <typename D, typename Rhs, typename Op>
893 class ComparisonBase {
895 explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
896 template <typename Lhs>
897 operator Matcher<Lhs>() const {
898 return MakeMatcher(new Impl<Lhs>(rhs_));
902 template <typename Lhs>
903 class Impl : public MatcherInterface<Lhs> {
905 explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
906 virtual bool MatchAndExplain(
907 Lhs lhs, MatchResultListener* /* listener */) const {
908 return Op()(lhs, rhs_);
910 virtual void DescribeTo(::std::ostream* os) const {
911 *os << D::Desc() << " ";
912 UniversalPrint(rhs_, os);
914 virtual void DescribeNegationTo(::std::ostream* os) const {
915 *os << D::NegatedDesc() << " ";
916 UniversalPrint(rhs_, os);
920 GTEST_DISALLOW_ASSIGN_(Impl);
923 GTEST_DISALLOW_ASSIGN_(ComparisonBase);
926 template <typename Rhs>
927 class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
929 explicit EqMatcher(const Rhs& rhs)
930 : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
931 static const char* Desc() { return "is equal to"; }
932 static const char* NegatedDesc() { return "isn't equal to"; }
934 template <typename Rhs>
935 class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
937 explicit NeMatcher(const Rhs& rhs)
938 : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
939 static const char* Desc() { return "isn't equal to"; }
940 static const char* NegatedDesc() { return "is equal to"; }
942 template <typename Rhs>
943 class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
945 explicit LtMatcher(const Rhs& rhs)
946 : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
947 static const char* Desc() { return "is <"; }
948 static const char* NegatedDesc() { return "isn't <"; }
950 template <typename Rhs>
951 class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
953 explicit GtMatcher(const Rhs& rhs)
954 : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
955 static const char* Desc() { return "is >"; }
956 static const char* NegatedDesc() { return "isn't >"; }
958 template <typename Rhs>
959 class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
961 explicit LeMatcher(const Rhs& rhs)
962 : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
963 static const char* Desc() { return "is <="; }
964 static const char* NegatedDesc() { return "isn't <="; }
966 template <typename Rhs>
967 class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
969 explicit GeMatcher(const Rhs& rhs)
970 : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
971 static const char* Desc() { return "is >="; }
972 static const char* NegatedDesc() { return "isn't >="; }
975 // Implements the polymorphic IsNull() matcher, which matches any raw or smart
976 // pointer that is NULL.
977 class IsNullMatcher {
979 template <typename Pointer>
980 bool MatchAndExplain(const Pointer& p,
981 MatchResultListener* /* listener */) const {
984 #else // GTEST_LANG_CXX11
985 return GetRawPointer(p) == NULL;
986 #endif // GTEST_LANG_CXX11
989 void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
990 void DescribeNegationTo(::std::ostream* os) const {
995 // Implements the polymorphic NotNull() matcher, which matches any raw or smart
996 // pointer that is not NULL.
997 class NotNullMatcher {
999 template <typename Pointer>
1000 bool MatchAndExplain(const Pointer& p,
1001 MatchResultListener* /* listener */) const {
1002 #if GTEST_LANG_CXX11
1003 return p != nullptr;
1004 #else // GTEST_LANG_CXX11
1005 return GetRawPointer(p) != NULL;
1006 #endif // GTEST_LANG_CXX11
1009 void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
1010 void DescribeNegationTo(::std::ostream* os) const {
1015 // Ref(variable) matches any argument that is a reference to
1016 // 'variable'. This matcher is polymorphic as it can match any
1017 // super type of the type of 'variable'.
1019 // The RefMatcher template class implements Ref(variable). It can
1020 // only be instantiated with a reference type. This prevents a user
1021 // from mistakenly using Ref(x) to match a non-reference function
1022 // argument. For example, the following will righteously cause a
1026 // Matcher<int> m1 = Ref(n); // This won't compile.
1027 // Matcher<int&> m2 = Ref(n); // This will compile.
1028 template <typename T>
1031 template <typename T>
1032 class RefMatcher<T&> {
1033 // Google Mock is a generic framework and thus needs to support
1034 // mocking any function types, including those that take non-const
1035 // reference arguments. Therefore the template parameter T (and
1036 // Super below) can be instantiated to either a const type or a
1039 // RefMatcher() takes a T& instead of const T&, as we want the
1040 // compiler to catch using Ref(const_value) as a matcher for a
1041 // non-const reference.
1042 explicit RefMatcher(T& x) : object_(x) {} // NOLINT
1044 template <typename Super>
1045 operator Matcher<Super&>() const {
1046 // By passing object_ (type T&) to Impl(), which expects a Super&,
1047 // we make sure that Super is a super type of T. In particular,
1048 // this catches using Ref(const_value) as a matcher for a
1049 // non-const reference, as you cannot implicitly convert a const
1050 // reference to a non-const reference.
1051 return MakeMatcher(new Impl<Super>(object_));
1055 template <typename Super>
1056 class Impl : public MatcherInterface<Super&> {
1058 explicit Impl(Super& x) : object_(x) {} // NOLINT
1060 // MatchAndExplain() takes a Super& (as opposed to const Super&)
1061 // in order to match the interface MatcherInterface<Super&>.
1062 virtual bool MatchAndExplain(
1063 Super& x, MatchResultListener* listener) const {
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 ";
1070 UniversalPrinter<Super&>::Print(object_, os);
1073 virtual void DescribeNegationTo(::std::ostream* os) const {
1074 *os << "does not reference the variable ";
1075 UniversalPrinter<Super&>::Print(object_, os);
1079 const Super& object_;
1081 GTEST_DISALLOW_ASSIGN_(Impl);
1086 GTEST_DISALLOW_ASSIGN_(RefMatcher);
1089 // Polymorphic helper functions for narrow and wide string matchers.
1090 inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
1091 return String::CaseInsensitiveCStringEquals(lhs, rhs);
1094 inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
1095 const wchar_t* rhs) {
1096 return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
1099 // String comparison for narrow or wide strings that can have embedded NUL
1101 template <typename StringType>
1102 bool CaseInsensitiveStringEquals(const StringType& s1,
1103 const StringType& s2) {
1104 // Are the heads equal?
1105 if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
1109 // Skip the equal heads.
1110 const typename StringType::value_type nul = 0;
1111 const size_t i1 = s1.find(nul), i2 = s2.find(nul);
1113 // Are we at the end of either s1 or s2?
1114 if (i1 == StringType::npos || i2 == StringType::npos) {
1118 // Are the tails equal?
1119 return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
1124 // Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
1125 template <typename StringType>
1126 class StrEqualityMatcher {
1128 StrEqualityMatcher(const StringType& str, bool expect_eq,
1129 bool case_sensitive)
1130 : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
1132 // Accepts pointer types, particularly:
1137 template <typename CharType>
1138 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
1142 return MatchAndExplain(StringType(s), listener);
1145 // Matches anything that can convert to StringType.
1147 // This is a template, not just a plain function with const StringType&,
1148 // because StringPiece has some interfering non-explicit constructors.
1149 template <typename MatcheeStringType>
1150 bool MatchAndExplain(const MatcheeStringType& s,
1151 MatchResultListener* /* listener */) const {
1152 const StringType& s2(s);
1153 const bool eq = case_sensitive_ ? s2 == string_ :
1154 CaseInsensitiveStringEquals(s2, string_);
1155 return expect_eq_ == eq;
1158 void DescribeTo(::std::ostream* os) const {
1159 DescribeToHelper(expect_eq_, os);
1162 void DescribeNegationTo(::std::ostream* os) const {
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) ";
1173 UniversalPrint(string_, os);
1176 const StringType string_;
1177 const bool expect_eq_;
1178 const bool case_sensitive_;
1180 GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
1183 // Implements the polymorphic HasSubstr(substring) matcher, which
1184 // can be used as a Matcher<T> as long as T can be converted to a
1186 template <typename StringType>
1187 class HasSubstrMatcher {
1189 explicit HasSubstrMatcher(const StringType& substring)
1190 : substring_(substring) {}
1192 // Accepts pointer types, particularly:
1197 template <typename CharType>
1198 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
1199 return s != NULL && MatchAndExplain(StringType(s), listener);
1202 // Matches anything that can convert to StringType.
1204 // This is a template, not just a plain function with const StringType&,
1205 // because StringPiece has some interfering non-explicit constructors.
1206 template <typename MatcheeStringType>
1207 bool MatchAndExplain(const MatcheeStringType& s,
1208 MatchResultListener* /* listener */) const {
1209 const StringType& s2(s);
1210 return s2.find(substring_) != StringType::npos;
1213 // Describes what this matcher matches.
1214 void DescribeTo(::std::ostream* os) const {
1215 *os << "has substring ";
1216 UniversalPrint(substring_, os);
1219 void DescribeNegationTo(::std::ostream* os) const {
1220 *os << "has no substring ";
1221 UniversalPrint(substring_, os);
1225 const StringType substring_;
1227 GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
1230 // Implements the polymorphic StartsWith(substring) matcher, which
1231 // can be used as a Matcher<T> as long as T can be converted to a
1233 template <typename StringType>
1234 class StartsWithMatcher {
1236 explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
1239 // Accepts pointer types, particularly:
1244 template <typename CharType>
1245 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
1246 return s != NULL && MatchAndExplain(StringType(s), listener);
1249 // Matches anything that can convert to StringType.
1251 // This is a template, not just a plain function with const StringType&,
1252 // because StringPiece has some interfering non-explicit constructors.
1253 template <typename MatcheeStringType>
1254 bool MatchAndExplain(const MatcheeStringType& s,
1255 MatchResultListener* /* listener */) const {
1256 const StringType& s2(s);
1257 return s2.length() >= prefix_.length() &&
1258 s2.substr(0, prefix_.length()) == prefix_;
1261 void DescribeTo(::std::ostream* os) const {
1262 *os << "starts with ";
1263 UniversalPrint(prefix_, os);
1266 void DescribeNegationTo(::std::ostream* os) const {
1267 *os << "doesn't start with ";
1268 UniversalPrint(prefix_, os);
1272 const StringType prefix_;
1274 GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
1277 // Implements the polymorphic EndsWith(substring) matcher, which
1278 // can be used as a Matcher<T> as long as T can be converted to a
1280 template <typename StringType>
1281 class EndsWithMatcher {
1283 explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
1285 // Accepts pointer types, particularly:
1290 template <typename CharType>
1291 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
1292 return s != NULL && MatchAndExplain(StringType(s), listener);
1295 // Matches anything that can convert to StringType.
1297 // This is a template, not just a plain function with const StringType&,
1298 // because StringPiece has some interfering non-explicit constructors.
1299 template <typename MatcheeStringType>
1300 bool MatchAndExplain(const MatcheeStringType& s,
1301 MatchResultListener* /* listener */) const {
1302 const StringType& s2(s);
1303 return s2.length() >= suffix_.length() &&
1304 s2.substr(s2.length() - suffix_.length()) == suffix_;
1307 void DescribeTo(::std::ostream* os) const {
1308 *os << "ends with ";
1309 UniversalPrint(suffix_, os);
1312 void DescribeNegationTo(::std::ostream* os) const {
1313 *os << "doesn't end with ";
1314 UniversalPrint(suffix_, os);
1318 const StringType suffix_;
1320 GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
1323 // Implements polymorphic matchers MatchesRegex(regex) and
1324 // ContainsRegex(regex), which can be used as a Matcher<T> as long as
1325 // T can be converted to a string.
1326 class MatchesRegexMatcher {
1328 MatchesRegexMatcher(const RE* regex, bool full_match)
1329 : regex_(regex), full_match_(full_match) {}
1331 // Accepts pointer types, particularly:
1336 template <typename CharType>
1337 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
1338 return s != NULL && MatchAndExplain(internal::string(s), listener);
1341 // Matches anything that can convert to internal::string.
1343 // This is a template, not just a plain function with const internal::string&,
1344 // because StringPiece has some interfering non-explicit constructors.
1345 template <class MatcheeStringType>
1346 bool MatchAndExplain(const MatcheeStringType& s,
1347 MatchResultListener* /* listener */) const {
1348 const internal::string& s2(s);
1349 return full_match_ ? RE::FullMatch(s2, *regex_) :
1350 RE::PartialMatch(s2, *regex_);
1353 void DescribeTo(::std::ostream* os) const {
1354 *os << (full_match_ ? "matches" : "contains")
1355 << " regular expression ";
1356 UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
1359 void DescribeNegationTo(::std::ostream* os) const {
1360 *os << "doesn't " << (full_match_ ? "match" : "contain")
1361 << " regular expression ";
1362 UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
1366 const internal::linked_ptr<const RE> regex_;
1367 const bool full_match_;
1369 GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
1372 // Implements a matcher that compares the two fields of a 2-tuple
1373 // using one of the ==, <=, <, etc, operators. The two fields being
1374 // compared don't have to have the same type.
1376 // The matcher defined here is polymorphic (for example, Eq() can be
1377 // used to match a tuple<int, short>, a tuple<const long&, double>,
1378 // etc). Therefore we use a template type conversion operator in the
1380 template <typename D, typename Op>
1381 class PairMatchBase {
1383 template <typename T1, typename T2>
1384 operator Matcher< ::testing::tuple<T1, T2> >() const {
1385 return MakeMatcher(new Impl< ::testing::tuple<T1, T2> >);
1387 template <typename T1, typename T2>
1388 operator Matcher<const ::testing::tuple<T1, T2>&>() const {
1389 return MakeMatcher(new Impl<const ::testing::tuple<T1, T2>&>);
1393 static ::std::ostream& GetDesc(::std::ostream& os) { // NOLINT
1394 return os << D::Desc();
1397 template <typename Tuple>
1398 class Impl : public MatcherInterface<Tuple> {
1400 virtual bool MatchAndExplain(
1402 MatchResultListener* /* listener */) const {
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;
1414 class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
1416 static const char* Desc() { return "an equal pair"; }
1418 class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
1420 static const char* Desc() { return "an unequal pair"; }
1422 class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
1424 static const char* Desc() { return "a pair where the first < the second"; }
1426 class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
1428 static const char* Desc() { return "a pair where the first > the second"; }
1430 class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
1432 static const char* Desc() { return "a pair where the first <= the second"; }
1434 class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
1436 static const char* Desc() { return "a pair where the first >= the second"; }
1439 // Implements the Not(...) matcher for a particular argument type T.
1440 // We do not nest it inside the NotMatcher class template, as that
1441 // will prevent different instantiations of NotMatcher from sharing
1442 // the same NotMatcherImpl<T> class.
1443 template <typename T>
1444 class NotMatcherImpl : public MatcherInterface<T> {
1446 explicit NotMatcherImpl(const Matcher<T>& matcher)
1447 : matcher_(matcher) {}
1449 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
1450 return !matcher_.MatchAndExplain(x, listener);
1453 virtual void DescribeTo(::std::ostream* os) const {
1454 matcher_.DescribeNegationTo(os);
1457 virtual void DescribeNegationTo(::std::ostream* os) const {
1458 matcher_.DescribeTo(os);
1462 const Matcher<T> matcher_;
1464 GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
1467 // Implements the Not(m) matcher, which matches a value that doesn't
1469 template <typename InnerMatcher>
1472 explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
1474 // This template type conversion operator allows Not(m) to be used
1475 // to match any type m can match.
1476 template <typename T>
1477 operator Matcher<T>() const {
1478 return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
1482 InnerMatcher matcher_;
1484 GTEST_DISALLOW_ASSIGN_(NotMatcher);
1487 // Implements the AllOf(m1, m2) matcher for a particular argument type
1488 // T. We do not nest it inside the BothOfMatcher class template, as
1489 // that will prevent different instantiations of BothOfMatcher from
1490 // sharing the same BothOfMatcherImpl<T> class.
1491 template <typename T>
1492 class BothOfMatcherImpl : public MatcherInterface<T> {
1494 BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
1495 : matcher1_(matcher1), matcher2_(matcher2) {}
1497 virtual void DescribeTo(::std::ostream* os) const {
1499 matcher1_.DescribeTo(os);
1501 matcher2_.DescribeTo(os);
1505 virtual void DescribeNegationTo(::std::ostream* os) const {
1507 matcher1_.DescribeNegationTo(os);
1509 matcher2_.DescribeNegationTo(os);
1513 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
1514 // If either matcher1_ or matcher2_ doesn't match x, we only need
1515 // to explain why one of them fails.
1516 StringMatchResultListener listener1;
1517 if (!matcher1_.MatchAndExplain(x, &listener1)) {
1518 *listener << listener1.str();
1522 StringMatchResultListener listener2;
1523 if (!matcher2_.MatchAndExplain(x, &listener2)) {
1524 *listener << listener2.str();
1528 // Otherwise we need to explain why *both* of them match.
1529 const internal::string s1 = listener1.str();
1530 const internal::string s2 = listener2.str();
1537 *listener << ", and " << s2;
1544 const Matcher<T> matcher1_;
1545 const Matcher<T> matcher2_;
1547 GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
1550 #if GTEST_LANG_CXX11
1551 // MatcherList provides mechanisms for storing a variable number of matchers in
1552 // a list structure (ListType) and creating a combining matcher from such a
1554 // The template is defined recursively using the following template paramters:
1555 // * kSize is the length of the MatcherList.
1556 // * Head is the type of the first matcher of the list.
1557 // * Tail denotes the types of the remaining matchers of the list.
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;
1563 // BuildList stores variadic type values in a nested pair structure.
1565 // MatcherList<3, int, string, float>::BuildList(5, "foo", 2.0) will return
1566 // the corresponding result of type pair<int, pair<string, float>>.
1567 static ListType BuildList(const Head& matcher, const Tail&... tail) {
1568 return ListType(matcher, MatcherListTail::BuildList(tail...));
1571 // CreateMatcher<T> creates a Matcher<T> from a given list of matchers (built
1572 // by BuildList()). CombiningMatcher<T> is used to combine the matchers of the
1573 // list. CombiningMatcher<T> must implement MatcherInterface<T> and have a
1574 // constructor taking two Matcher<T>s as input.
1575 template <typename T, template <typename /* T */> 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>(
1584 // The following defines the base case for the recursive definition of
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 /* T */> 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)));
1603 // VariadicMatcher is used for the variadic implementation of
1604 // AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
1605 // CombiningMatcher<T> is used to recursively combine the provided matchers
1606 // (of type Args...).
1607 template <template <typename T> class CombiningMatcher, typename... Args>
1608 class VariadicMatcher {
1610 VariadicMatcher(const Args&... matchers) // NOLINT
1611 : matchers_(MatcherListType::BuildList(matchers...)) {}
1613 // This template type conversion operator allows an
1614 // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
1615 // all of the provided matchers (Matcher1, Matcher2, ...) can match.
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_;
1627 GTEST_DISALLOW_ASSIGN_(VariadicMatcher);
1630 template <typename... Args>
1631 using AllOfMatcher = VariadicMatcher<BothOfMatcherImpl, Args...>;
1633 #endif // GTEST_LANG_CXX11
1635 // Used for implementing the AllOf(m_1, ..., m_n) matcher, which
1636 // matches a value that matches all of the matchers m_1, ..., and m_n.
1637 template <typename Matcher1, typename Matcher2>
1638 class BothOfMatcher {
1640 BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
1641 : matcher1_(matcher1), matcher2_(matcher2) {}
1643 // This template type conversion operator allows a
1644 // BothOfMatcher<Matcher1, Matcher2> object to match any type that
1645 // both Matcher1 and Matcher2 can match.
1646 template <typename T>
1647 operator Matcher<T>() const {
1648 return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
1649 SafeMatcherCast<T>(matcher2_)));
1656 GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
1659 // Implements the AnyOf(m1, m2) matcher for a particular argument type
1660 // T. We do not nest it inside the AnyOfMatcher class template, as
1661 // that will prevent different instantiations of AnyOfMatcher from
1662 // sharing the same EitherOfMatcherImpl<T> class.
1663 template <typename T>
1664 class EitherOfMatcherImpl : public MatcherInterface<T> {
1666 EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
1667 : matcher1_(matcher1), matcher2_(matcher2) {}
1669 virtual void DescribeTo(::std::ostream* os) const {
1671 matcher1_.DescribeTo(os);
1673 matcher2_.DescribeTo(os);
1677 virtual void DescribeNegationTo(::std::ostream* os) const {
1679 matcher1_.DescribeNegationTo(os);
1681 matcher2_.DescribeNegationTo(os);
1685 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
1686 // If either matcher1_ or matcher2_ matches x, we just need to
1687 // explain why *one* of them matches.
1688 StringMatchResultListener listener1;
1689 if (matcher1_.MatchAndExplain(x, &listener1)) {
1690 *listener << listener1.str();
1694 StringMatchResultListener listener2;
1695 if (matcher2_.MatchAndExplain(x, &listener2)) {
1696 *listener << listener2.str();
1700 // Otherwise we need to explain why *both* of them fail.
1701 const internal::string s1 = listener1.str();
1702 const internal::string s2 = listener2.str();
1709 *listener << ", and " << s2;
1716 const Matcher<T> matcher1_;
1717 const Matcher<T> matcher2_;
1719 GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
1722 #if GTEST_LANG_CXX11
1723 // AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
1724 template <typename... Args>
1725 using AnyOfMatcher = VariadicMatcher<EitherOfMatcherImpl, Args...>;
1727 #endif // GTEST_LANG_CXX11
1729 // Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
1730 // matches a value that matches at least one of the matchers m_1, ...,
1732 template <typename Matcher1, typename Matcher2>
1733 class EitherOfMatcher {
1735 EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
1736 : matcher1_(matcher1), matcher2_(matcher2) {}
1738 // This template type conversion operator allows a
1739 // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
1740 // both Matcher1 and Matcher2 can match.
1741 template <typename T>
1742 operator Matcher<T>() const {
1743 return Matcher<T>(new EitherOfMatcherImpl<T>(
1744 SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
1751 GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
1754 // Used for implementing Truly(pred), which turns a predicate into a
1756 template <typename Predicate>
1757 class TrulyMatcher {
1759 explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
1761 // This method template allows Truly(pred) to be used as a matcher
1762 // for type T where T is the argument type of predicate 'pred'. The
1763 // argument is passed by reference as the predicate may be
1764 // interested in the address of the argument.
1765 template <typename T>
1766 bool MatchAndExplain(T& x, // NOLINT
1767 MatchResultListener* /* listener */) const {
1768 // Without the if-statement, MSVC sometimes warns about converting
1769 // a value to bool (warning 4800).
1771 // We cannot write 'return !!predicate_(x);' as that doesn't work
1772 // when predicate_(x) returns a class convertible to bool but
1773 // having no operator!().
1779 void DescribeTo(::std::ostream* os) const {
1780 *os << "satisfies the given predicate";
1783 void DescribeNegationTo(::std::ostream* os) const {
1784 *os << "doesn't satisfy the given predicate";
1788 Predicate predicate_;
1790 GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
1793 // Used for implementing Matches(matcher), which turns a matcher into
1795 template <typename M>
1796 class MatcherAsPredicate {
1798 explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
1800 // This template operator() allows Matches(m) to be used as a
1801 // predicate on type T where m is a matcher on type T.
1803 // The argument x is passed by reference instead of by value, as
1804 // some matcher may be interested in its address (e.g. as in
1805 // Matches(Ref(n))(x)).
1806 template <typename T>
1807 bool operator()(const T& x) const {
1808 // We let matcher_ commit to a particular type here instead of
1809 // when the MatcherAsPredicate object was constructed. This
1810 // allows us to write Matches(m) where m is a polymorphic matcher
1813 // If we write Matcher<T>(matcher_).Matches(x) here, it won't
1814 // compile when matcher_ has type Matcher<const T&>; if we write
1815 // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
1816 // when matcher_ has type Matcher<T>; if we just write
1817 // matcher_.Matches(x), it won't compile when matcher_ is
1818 // polymorphic, e.g. Eq(5).
1820 // MatcherCast<const T&>() is necessary for making the code work
1821 // in all of the above situations.
1822 return MatcherCast<const T&>(matcher_).Matches(x);
1828 GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
1831 // For implementing ASSERT_THAT() and EXPECT_THAT(). The template
1832 // argument M must be a type that can be converted to a matcher.
1833 template <typename M>
1834 class PredicateFormatterFromMatcher {
1836 explicit PredicateFormatterFromMatcher(M m) : matcher_(internal::move(m)) {}
1838 // This template () operator allows a PredicateFormatterFromMatcher
1839 // object to act as a predicate-formatter suitable for using with
1840 // Google Test's EXPECT_PRED_FORMAT1() macro.
1841 template <typename T>
1842 AssertionResult operator()(const char* value_text, const T& x) const {
1843 // We convert matcher_ to a Matcher<const T&> *now* instead of
1844 // when the PredicateFormatterFromMatcher object was constructed,
1845 // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
1846 // know which type to instantiate it to until we actually see the
1849 // We write SafeMatcherCast<const T&>(matcher_) instead of
1850 // Matcher<const T&>(matcher_), as the latter won't compile when
1851 // matcher_ has type Matcher<T> (e.g. An<int>()).
1852 // We don't write MatcherCast<const T&> either, as that allows
1853 // potentially unsafe downcasting of the matcher argument.
1854 const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
1855 StringMatchResultListener listener;
1856 if (MatchPrintAndExplain(x, matcher, &listener))
1857 return AssertionSuccess();
1859 ::std::stringstream ss;
1860 ss << "Value of: " << value_text << "\n"
1862 matcher.DescribeTo(&ss);
1863 ss << "\n Actual: " << listener.str();
1864 return AssertionFailure() << ss.str();
1870 GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
1873 // A helper function for converting a matcher to a predicate-formatter
1874 // without the user needing to explicitly write the type. This is
1875 // used for implementing ASSERT_THAT() and EXPECT_THAT().
1876 // Implementation detail: 'matcher' is received by-value to force decaying.
1877 template <typename M>
1878 inline PredicateFormatterFromMatcher<M>
1879 MakePredicateFormatterFromMatcher(M matcher) {
1880 return PredicateFormatterFromMatcher<M>(internal::move(matcher));
1883 // Implements the polymorphic floating point equality matcher, which matches
1884 // two float values using ULP-based approximation or, optionally, a
1885 // user-specified epsilon. The template is meant to be instantiated with
1886 // FloatType being either float or double.
1887 template <typename FloatType>
1888 class FloatingEqMatcher {
1890 // Constructor for FloatingEqMatcher.
1891 // The matcher's input will be compared with expected. The matcher treats two
1892 // NANs as equal if nan_eq_nan is true. Otherwise, under IEEE standards,
1893 // equality comparisons between NANs will always return false. We specify a
1894 // negative max_abs_error_ term to indicate that ULP-based approximation will
1895 // be used for comparison.
1896 FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
1897 expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
1900 // Constructor that supports a user-specified max_abs_error that will be used
1901 // for comparison instead of ULP-based approximation. The max absolute
1902 // should be non-negative.
1903 FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
1904 FloatType max_abs_error)
1905 : expected_(expected),
1906 nan_eq_nan_(nan_eq_nan),
1907 max_abs_error_(max_abs_error) {
1908 GTEST_CHECK_(max_abs_error >= 0)
1909 << ", where max_abs_error is" << max_abs_error;
1912 // Implements floating point equality matcher as a Matcher<T>.
1913 template <typename T>
1914 class Impl : public MatcherInterface<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) {}
1921 virtual bool MatchAndExplain(T value,
1922 MatchResultListener* listener) const {
1923 const FloatingPoint<FloatType> actual(value), expected(expected_);
1925 // Compares NaNs first, if nan_eq_nan_ is true.
1926 if (actual.is_nan() || expected.is_nan()) {
1927 if (actual.is_nan() && expected.is_nan()) {
1930 // One is nan; the other is not nan.
1933 if (HasMaxAbsError()) {
1934 // We perform an equality check so that inf will match inf, regardless
1935 // of error bounds. If the result of value - expected_ would result in
1936 // overflow or if either value is inf, the default result is infinity,
1937 // which should only match if max_abs_error_ is also infinity.
1938 if (value == expected_) {
1942 const FloatType diff = value - expected_;
1943 if (fabs(diff) <= max_abs_error_) {
1947 if (listener->IsInterested()) {
1948 *listener << "which is " << diff << " from " << expected_;
1952 return actual.AlmostEquals(expected);
1956 virtual void DescribeTo(::std::ostream* os) const {
1957 // os->precision() returns the previously set precision, which we
1958 // store to restore the ostream to its original configuration
1959 // after outputting.
1960 const ::std::streamsize old_precision = os->precision(
1961 ::std::numeric_limits<FloatType>::digits10 + 2);
1962 if (FloatingPoint<FloatType>(expected_).is_nan()) {
1966 *os << "never matches";
1969 *os << "is approximately " << expected_;
1970 if (HasMaxAbsError()) {
1971 *os << " (absolute error <= " << max_abs_error_ << ")";
1974 os->precision(old_precision);
1977 virtual void DescribeNegationTo(::std::ostream* os) const {
1978 // As before, get original precision.
1979 const ::std::streamsize old_precision = os->precision(
1980 ::std::numeric_limits<FloatType>::digits10 + 2);
1981 if (FloatingPoint<FloatType>(expected_).is_nan()) {
1985 *os << "is anything";
1988 *os << "isn't approximately " << expected_;
1989 if (HasMaxAbsError()) {
1990 *os << " (absolute error > " << max_abs_error_ << ")";
1993 // Restore original precision.
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_;
2004 // max_abs_error will be used for value comparison when >= 0.
2005 const FloatType max_abs_error_;
2007 GTEST_DISALLOW_ASSIGN_(Impl);
2010 // The following 3 type conversion operators allow FloatEq(expected) and
2011 // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
2012 // Matcher<const float&>, or a Matcher<float&>, but nothing else.
2013 // (While Google's C++ coding style doesn't allow arguments passed
2014 // by non-const reference, we may see them in code not conforming to
2015 // the style. Therefore Google Mock needs to support them.)
2016 operator Matcher<FloatType>() const {
2018 new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
2021 operator Matcher<const FloatType&>() const {
2023 new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
2026 operator Matcher<FloatType&>() const {
2028 new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
2032 const FloatType expected_;
2033 const bool nan_eq_nan_;
2034 // max_abs_error will be used for value comparison when >= 0.
2035 const FloatType max_abs_error_;
2037 GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
2040 // Implements the Pointee(m) matcher for matching a pointer whose
2041 // pointee matches matcher m. The pointer can be either raw or smart.
2042 template <typename InnerMatcher>
2043 class PointeeMatcher {
2045 explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
2047 // This type conversion operator template allows Pointee(m) to be
2048 // used as a matcher for any pointer type whose pointee type is
2049 // compatible with the inner matcher, where type Pointer can be
2050 // either a raw pointer or a smart pointer.
2052 // The reason we do this instead of relying on
2053 // MakePolymorphicMatcher() is that the latter is not flexible
2054 // enough for implementing the DescribeTo() method of Pointee().
2055 template <typename Pointer>
2056 operator Matcher<Pointer>() const {
2057 return MakeMatcher(new Impl<Pointer>(matcher_));
2061 // The monomorphic implementation that works for a particular pointer type.
2062 template <typename Pointer>
2063 class Impl : public MatcherInterface<Pointer> {
2065 typedef typename PointeeOf<GTEST_REMOVE_CONST_( // NOLINT
2066 GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
2068 explicit Impl(const InnerMatcher& matcher)
2069 : matcher_(MatcherCast<const Pointee&>(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);
2081 virtual bool MatchAndExplain(Pointer pointer,
2082 MatchResultListener* listener) const {
2083 if (GetRawPointer(pointer) == NULL)
2086 *listener << "which points to ";
2087 return MatchPrintAndExplain(*pointer, matcher_, listener);
2091 const Matcher<const Pointee&> matcher_;
2093 GTEST_DISALLOW_ASSIGN_(Impl);
2096 const InnerMatcher matcher_;
2098 GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
2101 // Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
2102 // reference that matches inner_matcher when dynamic_cast<T> is applied.
2103 // The result of dynamic_cast<To> is forwarded to the inner matcher.
2104 // If To is a pointer and the cast fails, the inner matcher will receive NULL.
2105 // If To is a reference and the cast fails, this matcher returns false
2107 template <typename To>
2108 class WhenDynamicCastToMatcherBase {
2110 explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
2111 : matcher_(matcher) {}
2113 void DescribeTo(::std::ostream* os) const {
2114 GetCastTypeDescription(os);
2115 matcher_.DescribeTo(os);
2118 void DescribeNegationTo(::std::ostream* os) const {
2119 GetCastTypeDescription(os);
2120 matcher_.DescribeNegationTo(os);
2124 const Matcher<To> matcher_;
2126 static string GetToName() {
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() << ", ";
2139 GTEST_DISALLOW_ASSIGN_(WhenDynamicCastToMatcherBase);
2142 // Primary template.
2143 // To is a pointer. Cast and forward the result.
2144 template <typename To>
2145 class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
2147 explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
2148 : WhenDynamicCastToMatcherBase<To>(matcher) {}
2150 template <typename From>
2151 bool MatchAndExplain(From from, MatchResultListener* listener) const {
2152 // TODO(sbenza): Add more detail on failures. ie did the dyn_cast fail?
2153 To to = dynamic_cast<To>(from);
2154 return MatchPrintAndExplain(to, this->matcher_, listener);
2158 // Specialize for references.
2159 // In this case we return false if the dynamic_cast fails.
2160 template <typename To>
2161 class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
2163 explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
2164 : WhenDynamicCastToMatcherBase<To&>(matcher) {}
2166 template <typename From>
2167 bool MatchAndExplain(From& from, MatchResultListener* listener) const {
2168 // We don't want an std::bad_cast here, so do the cast with pointers.
2169 To* to = dynamic_cast<To*>(&from);
2171 *listener << "which cannot be dynamic_cast to " << this->GetToName();
2174 return MatchPrintAndExplain(*to, this->matcher_, listener);
2178 // Implements the Field() matcher for matching a field (i.e. member
2179 // variable) of an object.
2180 template <typename Class, typename FieldType>
2181 class FieldMatcher {
2183 FieldMatcher(FieldType Class::*field,
2184 const Matcher<const FieldType&>& matcher)
2185 : field_(field), matcher_(matcher) {}
2187 void DescribeTo(::std::ostream* os) const {
2188 *os << "is an object whose given field ";
2189 matcher_.DescribeTo(os);
2192 void DescribeNegationTo(::std::ostream* os) const {
2193 *os << "is an object whose given field ";
2194 matcher_.DescribeNegationTo(os);
2197 template <typename T>
2198 bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
2199 return MatchAndExplainImpl(
2200 typename ::testing::internal::
2201 is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
2206 // The first argument of MatchAndExplainImpl() is needed to help
2207 // Symbian's C++ compiler choose which overload to use. Its type is
2208 // true_type iff the Field() matcher is used to match a pointer.
2209 bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
2210 MatchResultListener* listener) const {
2211 *listener << "whose given field is ";
2212 return MatchPrintAndExplain(obj.*field_, matcher_, listener);
2215 bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
2216 MatchResultListener* listener) const {
2220 *listener << "which points to an object ";
2221 // Since *p has a field, it must be a class/struct/union type and
2222 // thus cannot be a pointer. Therefore we pass false_type() as
2223 // the first argument.
2224 return MatchAndExplainImpl(false_type(), *p, listener);
2227 const FieldType Class::*field_;
2228 const Matcher<const FieldType&> matcher_;
2230 GTEST_DISALLOW_ASSIGN_(FieldMatcher);
2233 // Implements the Property() matcher for matching a property
2234 // (i.e. return value of a getter method) of an object.
2235 template <typename Class, typename PropertyType>
2236 class PropertyMatcher {
2238 // The property may have a reference type, so 'const PropertyType&'
2239 // may cause double references and fail to compile. That's why we
2240 // need GTEST_REFERENCE_TO_CONST, which works regardless of
2241 // PropertyType being a reference or not.
2242 typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
2244 PropertyMatcher(PropertyType (Class::*property)() const,
2245 const Matcher<RefToConstProperty>& matcher)
2246 : property_(property), matcher_(matcher) {}
2248 void DescribeTo(::std::ostream* os) const {
2249 *os << "is an object whose given property ";
2250 matcher_.DescribeTo(os);
2253 void DescribeNegationTo(::std::ostream* os) const {
2254 *os << "is an object whose given property ";
2255 matcher_.DescribeNegationTo(os);
2258 template <typename T>
2259 bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
2260 return MatchAndExplainImpl(
2261 typename ::testing::internal::
2262 is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
2267 // The first argument of MatchAndExplainImpl() is needed to help
2268 // Symbian's C++ compiler choose which overload to use. Its type is
2269 // true_type iff the Property() matcher is used to match a pointer.
2270 bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
2271 MatchResultListener* listener) const {
2272 *listener << "whose given property is ";
2273 // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
2274 // which takes a non-const reference as argument.
2275 #if defined(_PREFAST_ ) && _MSC_VER == 1800
2276 // Workaround bug in VC++ 2013's /analyze parser.
2277 // https://connect.microsoft.com/VisualStudio/feedback/details/1106363/internal-compiler-error-with-analyze-due-to-failure-to-infer-move
2278 posix::Abort(); // To make sure it is never run.
2281 RefToConstProperty result = (obj.*property_)();
2282 return MatchPrintAndExplain(result, matcher_, listener);
2286 bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
2287 MatchResultListener* listener) const {
2291 *listener << "which points to an object ";
2292 // Since *p has a property method, it must be a class/struct/union
2293 // type and thus cannot be a pointer. Therefore we pass
2294 // false_type() as the first argument.
2295 return MatchAndExplainImpl(false_type(), *p, listener);
2298 PropertyType (Class::*property_)() const;
2299 const Matcher<RefToConstProperty> matcher_;
2301 GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
2304 // Type traits specifying various features of different functors for ResultOf.
2305 // The default template specifies features for functor objects.
2306 // Functor classes have to typedef argument_type and result_type
2307 // to be compatible with ResultOf.
2308 template <typename Functor>
2309 struct CallableTraits {
2310 typedef typename Functor::result_type ResultType;
2311 typedef Functor StorageType;
2313 static void CheckIsValid(Functor /* functor */) {}
2314 template <typename T>
2315 static ResultType Invoke(Functor f, T arg) { return f(arg); }
2318 // Specialization for function pointers.
2319 template <typename ArgType, typename ResType>
2320 struct CallableTraits<ResType(*)(ArgType)> {
2321 typedef ResType ResultType;
2322 typedef ResType(*StorageType)(ArgType);
2324 static void CheckIsValid(ResType(*f)(ArgType)) {
2325 GTEST_CHECK_(f != NULL)
2326 << "NULL function pointer is passed into ResultOf().";
2328 template <typename T>
2329 static ResType Invoke(ResType(*f)(ArgType), T arg) {
2334 // Implements the ResultOf() matcher for matching a return value of a
2335 // unary function of an object.
2336 template <typename Callable>
2337 class ResultOfMatcher {
2339 typedef typename CallableTraits<Callable>::ResultType ResultType;
2341 ResultOfMatcher(Callable callable, const Matcher<ResultType>& matcher)
2342 : callable_(callable), matcher_(matcher) {
2343 CallableTraits<Callable>::CheckIsValid(callable_);
2346 template <typename T>
2347 operator Matcher<T>() const {
2348 return Matcher<T>(new Impl<T>(callable_, matcher_));
2352 typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
2354 template <typename T>
2355 class Impl : public MatcherInterface<T> {
2357 Impl(CallableStorageType callable, const Matcher<ResultType>& matcher)
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 ";
2372 // Cannot pass the return value (for example, int) to
2373 // MatchPrintAndExplain, which takes a non-const reference as argument.
2375 CallableTraits<Callable>::template Invoke<T>(callable_, obj);
2376 return MatchPrintAndExplain(result, matcher_, listener);
2380 // Functors often define operator() as non-const method even though
2381 // they are actualy stateless. But we need to use them even when
2382 // 'this' is a const pointer. It's the user's responsibility not to
2383 // use stateful callables with ResultOf(), which does't guarantee
2384 // how many times the callable will be invoked.
2385 mutable CallableStorageType callable_;
2386 const Matcher<ResultType> matcher_;
2388 GTEST_DISALLOW_ASSIGN_(Impl);
2391 const CallableStorageType callable_;
2392 const Matcher<ResultType> matcher_;
2394 GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
2397 // Implements a matcher that checks the size of an STL-style container.
2398 template <typename SizeMatcher>
2399 class SizeIsMatcher {
2401 explicit SizeIsMatcher(const SizeMatcher& size_matcher)
2402 : size_matcher_(size_matcher) {
2405 template <typename Container>
2406 operator Matcher<Container>() const {
2407 return MakeMatcher(new Impl<Container>(size_matcher_));
2410 template <typename Container>
2411 class Impl : public MatcherInterface<Container> {
2413 typedef internal::StlContainerView<
2414 GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
2415 typedef typename ContainerView::type::size_type SizeType;
2416 explicit Impl(const SizeMatcher& size_matcher)
2417 : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
2419 virtual void DescribeTo(::std::ostream* os) const {
2421 size_matcher_.DescribeTo(os);
2423 virtual void DescribeNegationTo(::std::ostream* os) const {
2425 size_matcher_.DescribeNegationTo(os);
2428 virtual bool MatchAndExplain(Container container,
2429 MatchResultListener* listener) const {
2430 SizeType size = container.size();
2431 StringMatchResultListener size_listener;
2432 const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
2434 << "whose size " << size << (result ? " matches" : " doesn't match");
2435 PrintIfNotEmpty(size_listener.str(), listener->stream());
2440 const Matcher<SizeType> size_matcher_;
2441 GTEST_DISALLOW_ASSIGN_(Impl);
2445 const SizeMatcher size_matcher_;
2446 GTEST_DISALLOW_ASSIGN_(SizeIsMatcher);
2449 // Implements a matcher that checks the begin()..end() distance of an STL-style
2451 template <typename DistanceMatcher>
2452 class BeginEndDistanceIsMatcher {
2454 explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
2455 : distance_matcher_(distance_matcher) {}
2457 template <typename Container>
2458 operator Matcher<Container>() const {
2459 return MakeMatcher(new Impl<Container>(distance_matcher_));
2462 template <typename Container>
2463 class Impl : public MatcherInterface<Container> {
2465 typedef internal::StlContainerView<
2466 GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
2467 typedef typename std::iterator_traits<
2468 typename ContainerView::type::const_iterator>::difference_type
2470 explicit Impl(const DistanceMatcher& distance_matcher)
2471 : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
2473 virtual void DescribeTo(::std::ostream* os) const {
2474 *os << "distance between begin() and end() ";
2475 distance_matcher_.DescribeTo(os);
2477 virtual void DescribeNegationTo(::std::ostream* os) const {
2478 *os << "distance between begin() and end() ";
2479 distance_matcher_.DescribeNegationTo(os);
2482 virtual bool MatchAndExplain(Container container,
2483 MatchResultListener* listener) const {
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());
2491 StringMatchResultListener distance_listener;
2493 distance_matcher_.MatchAndExplain(distance, &distance_listener);
2494 *listener << "whose distance between begin() and end() " << distance
2495 << (result ? " matches" : " doesn't match");
2496 PrintIfNotEmpty(distance_listener.str(), listener->stream());
2501 const Matcher<DistanceType> distance_matcher_;
2502 GTEST_DISALLOW_ASSIGN_(Impl);
2506 const DistanceMatcher distance_matcher_;
2507 GTEST_DISALLOW_ASSIGN_(BeginEndDistanceIsMatcher);
2510 // Implements an equality matcher for any STL-style container whose elements
2511 // support ==. This matcher is like Eq(), but its failure explanations provide
2512 // more detailed information that is useful when the container is used as a set.
2513 // The failure message reports elements that are in one of the operands but not
2514 // the other. The failure messages do not report duplicate or out-of-order
2515 // elements in the containers (which don't properly matter to sets, but can
2516 // occur if the containers are vectors or lists, for example).
2518 // Uses the container's const_iterator, value_type, operator ==,
2519 // begin(), and end().
2520 template <typename Container>
2521 class ContainerEqMatcher {
2523 typedef internal::StlContainerView<Container> View;
2524 typedef typename View::type StlContainer;
2525 typedef typename View::const_reference StlContainerReference;
2527 // We make a copy of expected in case the elements in it are modified
2528 // after this matcher is created.
2529 explicit ContainerEqMatcher(const Container& expected)
2530 : expected_(View::Copy(expected)) {
2531 // Makes sure the user doesn't instantiate this class template
2532 // with a const or reference type.
2533 (void)testing::StaticAssertTypeEq<Container,
2534 GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>();
2537 void DescribeTo(::std::ostream* os) const {
2539 UniversalPrint(expected_, os);
2541 void DescribeNegationTo(::std::ostream* os) const {
2542 *os << "does not equal ";
2543 UniversalPrint(expected_, os);
2546 template <typename LhsContainer>
2547 bool MatchAndExplain(const LhsContainer& lhs,
2548 MatchResultListener* listener) const {
2549 // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
2550 // that causes LhsContainer to be a const type sometimes.
2551 typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
2553 typedef typename LhsView::type LhsStlContainer;
2554 StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
2555 if (lhs_stl_container == expected_)
2558 ::std::ostream* const os = listener->stream();
2560 // Something is different. Check for extra values first.
2561 bool printed_header = false;
2562 for (typename LhsStlContainer::const_iterator it =
2563 lhs_stl_container.begin();
2564 it != lhs_stl_container.end(); ++it) {
2565 if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
2567 if (printed_header) {
2570 *os << "which has these unexpected elements: ";
2571 printed_header = true;
2573 UniversalPrint(*it, os);
2577 // Now check for missing values.
2578 bool printed_header2 = false;
2579 for (typename StlContainer::const_iterator it = expected_.begin();
2580 it != expected_.end(); ++it) {
2581 if (internal::ArrayAwareFind(
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;
2591 UniversalPrint(*it, os);
2600 const StlContainer expected_;
2602 GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
2605 // A comparator functor that uses the < operator to compare two values.
2606 struct LessComparator {
2607 template <typename T, typename U>
2608 bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
2611 // Implements WhenSortedBy(comparator, container_matcher).
2612 template <typename Comparator, typename ContainerMatcher>
2613 class WhenSortedByMatcher {
2615 WhenSortedByMatcher(const Comparator& comparator,
2616 const ContainerMatcher& matcher)
2617 : comparator_(comparator), matcher_(matcher) {}
2619 template <typename LhsContainer>
2620 operator Matcher<LhsContainer>() const {
2621 return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
2624 template <typename LhsContainer>
2625 class Impl : public MatcherInterface<LhsContainer> {
2627 typedef internal::StlContainerView<
2628 GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
2629 typedef typename LhsView::type LhsStlContainer;
2630 typedef typename LhsView::const_reference LhsStlContainerReference;
2631 // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
2632 // so that we can match associative containers.
2633 typedef typename RemoveConstFromKey<
2634 typename LhsStlContainer::value_type>::type LhsValue;
2636 Impl(const Comparator& comparator, const ContainerMatcher& matcher)
2637 : comparator_(comparator), matcher_(matcher) {}
2639 virtual void DescribeTo(::std::ostream* os) const {
2640 *os << "(when sorted) ";
2641 matcher_.DescribeTo(os);
2644 virtual void DescribeNegationTo(::std::ostream* os) const {
2645 *os << "(when sorted) ";
2646 matcher_.DescribeNegationTo(os);
2649 virtual bool MatchAndExplain(LhsContainer lhs,
2650 MatchResultListener* listener) const {
2651 LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
2652 ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
2653 lhs_stl_container.end());
2655 sorted_container.begin(), sorted_container.end(), comparator_);
2657 if (!listener->IsInterested()) {
2658 // If the listener is not interested, we do not need to
2659 // construct the inner explanation.
2660 return matcher_.Matches(sorted_container);
2663 *listener << "which is ";
2664 UniversalPrint(sorted_container, listener->stream());
2665 *listener << " when sorted";
2667 StringMatchResultListener inner_listener;
2668 const bool match = matcher_.MatchAndExplain(sorted_container,
2670 PrintIfNotEmpty(inner_listener.str(), listener->stream());
2675 const Comparator comparator_;
2676 const Matcher<const ::std::vector<LhsValue>&> matcher_;
2678 GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
2682 const Comparator comparator_;
2683 const ContainerMatcher matcher_;
2685 GTEST_DISALLOW_ASSIGN_(WhenSortedByMatcher);
2688 // Implements Pointwise(tuple_matcher, rhs_container). tuple_matcher
2689 // must be able to be safely cast to Matcher<tuple<const T1&, const
2690 // T2&> >, where T1 and T2 are the types of elements in the LHS
2691 // container and the RHS container respectively.
2692 template <typename TupleMatcher, typename RhsContainer>
2693 class PointwiseMatcher {
2695 typedef internal::StlContainerView<RhsContainer> RhsView;
2696 typedef typename RhsView::type RhsStlContainer;
2697 typedef typename RhsStlContainer::value_type RhsValue;
2699 // Like ContainerEq, we make a copy of rhs in case the elements in
2700 // it are modified after this matcher is created.
2701 PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
2702 : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {
2703 // Makes sure the user doesn't instantiate this class template
2704 // with a const or reference type.
2705 (void)testing::StaticAssertTypeEq<RhsContainer,
2706 GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>();
2709 template <typename LhsContainer>
2710 operator Matcher<LhsContainer>() const {
2711 return MakeMatcher(new Impl<LhsContainer>(tuple_matcher_, rhs_));
2714 template <typename LhsContainer>
2715 class Impl : public MatcherInterface<LhsContainer> {
2717 typedef internal::StlContainerView<
2718 GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
2719 typedef typename LhsView::type LhsStlContainer;
2720 typedef typename LhsView::const_reference LhsStlContainerReference;
2721 typedef typename LhsStlContainer::value_type LhsValue;
2722 // We pass the LHS value and the RHS value to the inner matcher by
2723 // reference, as they may be expensive to copy. We must use tuple
2724 // instead of pair here, as a pair cannot hold references (C++ 98,
2725 // 20.2.2 [lib.pairs]).
2726 typedef ::testing::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
2728 Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
2729 // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
2730 : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
2733 virtual void DescribeTo(::std::ostream* os) const {
2734 *os << "contains " << rhs_.size()
2735 << " values, where each value and its corresponding value in ";
2736 UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
2738 mono_tuple_matcher_.DescribeTo(os);
2740 virtual void DescribeNegationTo(::std::ostream* os) const {
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 ";
2744 UniversalPrint(rhs_, os);
2746 mono_tuple_matcher_.DescribeNegationTo(os);
2749 virtual bool MatchAndExplain(LhsContainer lhs,
2750 MatchResultListener* listener) const {
2751 LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
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) {
2761 const InnerMatcherArg value_pair(*left, *right);
2763 if (listener->IsInterested()) {
2764 StringMatchResultListener inner_listener;
2765 if (!mono_tuple_matcher_.MatchAndExplain(
2766 value_pair, &inner_listener)) {
2767 *listener << "where the value pair (";
2768 UniversalPrint(*left, listener->stream());
2770 UniversalPrint(*right, listener->stream());
2771 *listener << ") at index #" << i << " don't match";
2772 PrintIfNotEmpty(inner_listener.str(), listener->stream());
2776 if (!mono_tuple_matcher_.Matches(value_pair))
2785 const Matcher<InnerMatcherArg> mono_tuple_matcher_;
2786 const RhsStlContainer rhs_;
2788 GTEST_DISALLOW_ASSIGN_(Impl);
2792 const TupleMatcher tuple_matcher_;
2793 const RhsStlContainer rhs_;
2795 GTEST_DISALLOW_ASSIGN_(PointwiseMatcher);
2798 // Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
2799 template <typename Container>
2800 class QuantifierMatcherImpl : public MatcherInterface<Container> {
2802 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
2803 typedef StlContainerView<RawContainer> View;
2804 typedef typename View::type StlContainer;
2805 typedef typename View::const_reference StlContainerReference;
2806 typedef typename StlContainer::value_type Element;
2808 template <typename InnerMatcher>
2809 explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
2811 testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
2814 // * All elements in the container match, if all_elements_should_match.
2815 // * Any element in the container matches, if !all_elements_should_match.
2816 bool MatchAndExplainImpl(bool all_elements_should_match,
2817 Container container,
2818 MatchResultListener* listener) const {
2819 StlContainerReference stl_container = View::ConstReference(container);
2821 for (typename StlContainer::const_iterator it = stl_container.begin();
2822 it != stl_container.end(); ++it, ++i) {
2823 StringMatchResultListener inner_listener;
2824 const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
2826 if (matches != all_elements_should_match) {
2827 *listener << "whose element #" << i
2828 << (matches ? " matches" : " doesn't match");
2829 PrintIfNotEmpty(inner_listener.str(), listener->stream());
2830 return !all_elements_should_match;
2833 return all_elements_should_match;
2837 const Matcher<const Element&> inner_matcher_;
2839 GTEST_DISALLOW_ASSIGN_(QuantifierMatcherImpl);
2842 // Implements Contains(element_matcher) for the given argument type Container.
2843 // Symmetric to EachMatcherImpl.
2844 template <typename Container>
2845 class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
2847 template <typename InnerMatcher>
2848 explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
2849 : QuantifierMatcherImpl<Container>(inner_matcher) {}
2851 // Describes what this matcher does.
2852 virtual void DescribeTo(::std::ostream* os) const {
2853 *os << "contains at least one element that ";
2854 this->inner_matcher_.DescribeTo(os);
2857 virtual void DescribeNegationTo(::std::ostream* os) const {
2858 *os << "doesn't contain any element that ";
2859 this->inner_matcher_.DescribeTo(os);
2862 virtual bool MatchAndExplain(Container container,
2863 MatchResultListener* listener) const {
2864 return this->MatchAndExplainImpl(false, container, listener);
2868 GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
2871 // Implements Each(element_matcher) for the given argument type Container.
2872 // Symmetric to ContainsMatcherImpl.
2873 template <typename Container>
2874 class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
2876 template <typename InnerMatcher>
2877 explicit EachMatcherImpl(InnerMatcher inner_matcher)
2878 : QuantifierMatcherImpl<Container>(inner_matcher) {}
2880 // Describes what this matcher does.
2881 virtual void DescribeTo(::std::ostream* os) const {
2882 *os << "only contains elements that ";
2883 this->inner_matcher_.DescribeTo(os);
2886 virtual void DescribeNegationTo(::std::ostream* os) const {
2887 *os << "contains some element that ";
2888 this->inner_matcher_.DescribeNegationTo(os);
2891 virtual bool MatchAndExplain(Container container,
2892 MatchResultListener* listener) const {
2893 return this->MatchAndExplainImpl(true, container, listener);
2897 GTEST_DISALLOW_ASSIGN_(EachMatcherImpl);
2900 // Implements polymorphic Contains(element_matcher).
2901 template <typename M>
2902 class ContainsMatcher {
2904 explicit ContainsMatcher(M m) : inner_matcher_(m) {}
2906 template <typename Container>
2907 operator Matcher<Container>() const {
2908 return MakeMatcher(new ContainsMatcherImpl<Container>(inner_matcher_));
2912 const M inner_matcher_;
2914 GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
2917 // Implements polymorphic Each(element_matcher).
2918 template <typename M>
2921 explicit EachMatcher(M m) : inner_matcher_(m) {}
2923 template <typename Container>
2924 operator Matcher<Container>() const {
2925 return MakeMatcher(new EachMatcherImpl<Container>(inner_matcher_));
2929 const M inner_matcher_;
2931 GTEST_DISALLOW_ASSIGN_(EachMatcher);
2934 // Implements Key(inner_matcher) for the given argument pair type.
2935 // Key(inner_matcher) matches an std::pair whose 'first' field matches
2936 // inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an
2937 // std::map that contains at least one element whose key is >= 5.
2938 template <typename PairType>
2939 class KeyMatcherImpl : public MatcherInterface<PairType> {
2941 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
2942 typedef typename RawPairType::first_type KeyType;
2944 template <typename InnerMatcher>
2945 explicit KeyMatcherImpl(InnerMatcher inner_matcher)
2947 testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
2950 // Returns true iff 'key_value.first' (the key) matches the inner matcher.
2951 virtual bool MatchAndExplain(PairType key_value,
2952 MatchResultListener* listener) const {
2953 StringMatchResultListener inner_listener;
2954 const bool match = inner_matcher_.MatchAndExplain(key_value.first,
2956 const internal::string explanation = inner_listener.str();
2957 if (explanation != "") {
2958 *listener << "whose first field is a value " << explanation;
2963 // Describes what this matcher does.
2964 virtual void DescribeTo(::std::ostream* os) const {
2965 *os << "has a key that ";
2966 inner_matcher_.DescribeTo(os);
2969 // Describes what the negation of this matcher does.
2970 virtual void DescribeNegationTo(::std::ostream* os) const {
2971 *os << "doesn't have a key that ";
2972 inner_matcher_.DescribeTo(os);
2976 const Matcher<const KeyType&> inner_matcher_;
2978 GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
2981 // Implements polymorphic Key(matcher_for_key).
2982 template <typename M>
2985 explicit KeyMatcher(M m) : matcher_for_key_(m) {}
2987 template <typename PairType>
2988 operator Matcher<PairType>() const {
2989 return MakeMatcher(new KeyMatcherImpl<PairType>(matcher_for_key_));
2993 const M matcher_for_key_;
2995 GTEST_DISALLOW_ASSIGN_(KeyMatcher);
2998 // Implements Pair(first_matcher, second_matcher) for the given argument pair
2999 // type with its two matchers. See Pair() function below.
3000 template <typename PairType>
3001 class PairMatcherImpl : public MatcherInterface<PairType> {
3003 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
3004 typedef typename RawPairType::first_type FirstType;
3005 typedef typename RawPairType::second_type SecondType;
3007 template <typename FirstMatcher, typename SecondMatcher>
3008 PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
3010 testing::SafeMatcherCast<const FirstType&>(first_matcher)),
3012 testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
3015 // Describes what this matcher does.
3016 virtual void DescribeTo(::std::ostream* os) const {
3017 *os << "has a first field that ";
3018 first_matcher_.DescribeTo(os);
3019 *os << ", and has a second field that ";
3020 second_matcher_.DescribeTo(os);
3023 // Describes what the negation of this matcher does.
3024 virtual void DescribeNegationTo(::std::ostream* os) const {
3025 *os << "has a first field that ";
3026 first_matcher_.DescribeNegationTo(os);
3027 *os << ", or has a second field that ";
3028 second_matcher_.DescribeNegationTo(os);
3031 // Returns true iff 'a_pair.first' matches first_matcher and 'a_pair.second'
3032 // matches second_matcher.
3033 virtual bool MatchAndExplain(PairType a_pair,
3034 MatchResultListener* listener) const {
3035 if (!listener->IsInterested()) {
3036 // If the listener is not interested, we don't need to construct the
3038 return first_matcher_.Matches(a_pair.first) &&
3039 second_matcher_.Matches(a_pair.second);
3041 StringMatchResultListener first_inner_listener;
3042 if (!first_matcher_.MatchAndExplain(a_pair.first,
3043 &first_inner_listener)) {
3044 *listener << "whose first field does not match";
3045 PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
3048 StringMatchResultListener second_inner_listener;
3049 if (!second_matcher_.MatchAndExplain(a_pair.second,
3050 &second_inner_listener)) {
3051 *listener << "whose second field does not match";
3052 PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
3055 ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
3061 void ExplainSuccess(const internal::string& first_explanation,
3062 const internal::string& second_explanation,
3063 MatchResultListener* listener) const {
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_;
3082 GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
3085 // Implements polymorphic Pair(first_matcher, second_matcher).
3086 template <typename FirstMatcher, typename SecondMatcher>
3089 PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
3090 : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
3092 template <typename PairType>
3093 operator Matcher<PairType> () const {
3095 new PairMatcherImpl<PairType>(
3096 first_matcher_, second_matcher_));
3100 const FirstMatcher first_matcher_;
3101 const SecondMatcher second_matcher_;
3103 GTEST_DISALLOW_ASSIGN_(PairMatcher);
3106 // Implements ElementsAre() and ElementsAreArray().
3107 template <typename Container>
3108 class ElementsAreMatcherImpl : public MatcherInterface<Container> {
3110 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
3111 typedef internal::StlContainerView<RawContainer> View;
3112 typedef typename View::type StlContainer;
3113 typedef typename View::const_reference StlContainerReference;
3114 typedef typename StlContainer::value_type Element;
3116 // Constructs the matcher from a sequence of element values or
3117 // element matchers.
3118 template <typename InputIter>
3119 ElementsAreMatcherImpl(InputIter first, InputIter last) {
3120 while (first != last) {
3121 matchers_.push_back(MatcherCast<const Element&>(*first++));
3125 // Describes what this matcher does.
3126 virtual void DescribeTo(::std::ostream* os) const {
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()) {
3144 // Describes what the negation of this matcher does.
3145 virtual void DescribeNegationTo(::std::ostream* os) const {
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()) {
3161 virtual bool MatchAndExplain(Container container,
3162 MatchResultListener* listener) const {
3163 // To work with stream-like "containers", we must only walk
3164 // through the elements in one pass.
3166 const bool listener_interested = listener->IsInterested();
3168 // explanations[i] is the explanation of the element at index i.
3169 ::std::vector<internal::string> explanations(count());
3170 StlContainerReference stl_container = View::ConstReference(container);
3171 typename StlContainer::const_iterator it = stl_container.begin();
3172 size_t exam_pos = 0;
3173 bool mismatch_found = false; // Have we found a mismatched element yet?
3175 // Go through the elements and matchers in pairs, until we reach
3176 // the end of either the elements or the matchers, or until we find a
3178 for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
3179 bool match; // Does the current element match the current matcher?
3180 if (listener_interested) {
3181 StringMatchResultListener s;
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;
3193 // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
3195 // Find how many elements the actual container has. We avoid
3196 // calling size() s.t. this code works for stream-like "containers"
3197 // that don't define size().
3198 size_t actual_count = exam_pos;
3199 for (; it != stl_container.end(); ++it) {
3203 if (actual_count != count()) {
3204 // The element count doesn't match. If the container is empty,
3205 // there's no need to explain anything as Google Mock already
3206 // prints the empty container. Otherwise we just need to show
3207 // how many elements there actually are.
3208 if (listener_interested && (actual_count != 0)) {
3209 *listener << "which has " << Elements(actual_count);
3214 if (mismatch_found) {
3215 // The element count matches, but the exam_pos-th element doesn't match.
3216 if (listener_interested) {
3217 *listener << "whose element #" << exam_pos << " doesn't match";
3218 PrintIfNotEmpty(explanations[exam_pos], listener->stream());
3223 // Every element matches its expectation. We need to explain why
3224 // (the obvious ones can be skipped).
3225 if (listener_interested) {
3226 bool reason_printed = false;
3227 for (size_t i = 0; i != count(); ++i) {
3228 const internal::string& s = explanations[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_;
3250 GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
3253 // Connectivity matrix of (elements X matchers), in element-major order.
3254 // Initially, there are no edges.
3255 // Use NextGraph() to iterate over all possible edge configurations.
3256 // Use Randomize() to generate a random edge configuration.
3257 class GTEST_API_ MatchMatrix {
3259 MatchMatrix(size_t num_elements, size_t num_matchers)
3260 : num_elements_(num_elements),
3261 num_matchers_(num_matchers),
3262 matched_(num_elements_* num_matchers_, 0) {
3265 size_t LhsSize() const { return num_elements_; }
3266 size_t RhsSize() const { return num_matchers_; }
3267 bool HasEdge(size_t ilhs, size_t irhs) const {
3268 return matched_[SpaceIndex(ilhs, irhs)] == 1;
3270 void SetEdge(size_t ilhs, size_t irhs, bool b) {
3271 matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
3274 // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
3275 // adds 1 to that number; returns false if incrementing the graph left it
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_;
3291 // Each element is a char interpreted as bool. They are stored as a
3292 // flattened array in lhs-major order, use 'SpaceIndex()' to translate
3293 // a (ilhs, irhs) matrix coordinate into an offset.
3294 ::std::vector<char> matched_;
3297 typedef ::std::pair<size_t, size_t> ElementMatcherPair;
3298 typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
3300 // Returns a maximum bipartite matching for the specified graph 'g'.
3301 // The matching is represented as a vector of {element, matcher} pairs.
3302 GTEST_API_ ElementMatcherPairs
3303 FindMaxBipartiteMatching(const MatchMatrix& g);
3305 GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
3306 MatchResultListener* listener);
3308 // Untyped base class for implementing UnorderedElementsAre. By
3309 // putting logic that's not specific to the element type here, we
3310 // reduce binary bloat and increase compilation speed.
3311 class GTEST_API_ UnorderedElementsAreMatcherImplBase {
3313 // A vector of matcher describers, one for each element matcher.
3314 // Does not own the describers (and thus can be used only when the
3315 // element matchers are alive).
3316 typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
3318 // Describes this UnorderedElementsAre matcher.
3319 void DescribeToImpl(::std::ostream* os) const;
3321 // Describes the negation of this UnorderedElementsAre matcher.
3322 void DescribeNegationToImpl(::std::ostream* os) const;
3324 bool VerifyAllElementsAndMatchersAreMatched(
3325 const ::std::vector<string>& element_printouts,
3326 const MatchMatrix& matrix,
3327 MatchResultListener* listener) const;
3329 MatcherDescriberVec& matcher_describers() {
3330 return matcher_describers_;
3333 static Message Elements(size_t n) {
3334 return Message() << n << " element" << (n == 1 ? "" : "s");
3338 MatcherDescriberVec matcher_describers_;
3340 GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImplBase);
3343 // Implements unordered ElementsAre and unordered ElementsAreArray.
3344 template <typename Container>
3345 class UnorderedElementsAreMatcherImpl
3346 : public MatcherInterface<Container>,
3347 public UnorderedElementsAreMatcherImplBase {
3349 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
3350 typedef internal::StlContainerView<RawContainer> View;
3351 typedef typename View::type StlContainer;
3352 typedef typename View::const_reference StlContainerReference;
3353 typedef typename StlContainer::const_iterator StlContainerConstIterator;
3354 typedef typename StlContainer::value_type Element;
3356 // Constructs the matcher from a sequence of element values or
3357 // element matchers.
3358 template <typename InputIter>
3359 UnorderedElementsAreMatcherImpl(InputIter first, InputIter last) {
3360 for (; first != last; ++first) {
3361 matchers_.push_back(MatcherCast<const Element&>(*first));
3362 matcher_describers().push_back(matchers_.back().GetDescriber());
3366 // Describes what this matcher does.
3367 virtual void DescribeTo(::std::ostream* os) const {
3368 return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
3371 // Describes what the negation of this matcher does.
3372 virtual void DescribeNegationTo(::std::ostream* os) const {
3373 return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
3376 virtual bool MatchAndExplain(Container container,
3377 MatchResultListener* listener) const {
3378 StlContainerReference stl_container = View::ConstReference(container);
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()) {
3390 // The element count doesn't match. If the container is empty,
3391 // there's no need to explain anything as Google Mock already
3392 // prints the empty container. Otherwise we just need to show
3393 // how many elements there actually are.
3394 if (actual_count != 0 && listener->IsInterested()) {
3395 *listener << "which has " << Elements(actual_count);
3400 return VerifyAllElementsAndMatchersAreMatched(element_printouts,
3401 matrix, listener) &&
3402 FindPairing(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,
3411 MatchResultListener* listener) const {
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) {
3416 if (listener->IsInterested()) {
3417 element_printouts->push_back(PrintToString(*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_;
3436 GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcherImpl);
3439 // Functor for use in TransformTuple.
3440 // Performs MatcherCast<Target> on an input argument of any type.
3441 template <typename Target>
3442 struct CastAndAppendTransform {
3443 template <typename Arg>
3444 Matcher<Target> operator()(const Arg& a) const {
3445 return MatcherCast<Target>(a);
3449 // Implements UnorderedElementsAre.
3450 template <typename MatcherTuple>
3451 class UnorderedElementsAreMatcher {
3453 explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
3454 : matchers_(args) {}
3456 template <typename Container>
3457 operator Matcher<Container>() const {
3458 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
3459 typedef typename internal::StlContainerView<RawContainer>::type View;
3460 typedef typename View::value_type Element;
3461 typedef ::std::vector<Matcher<const Element&> > MatcherVec;
3462 MatcherVec matchers;
3463 matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
3464 TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
3465 ::std::back_inserter(matchers));
3466 return MakeMatcher(new UnorderedElementsAreMatcherImpl<Container>(
3467 matchers.begin(), matchers.end()));
3471 const MatcherTuple matchers_;
3472 GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreMatcher);
3475 // Implements ElementsAre.
3476 template <typename MatcherTuple>
3477 class ElementsAreMatcher {
3479 explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
3481 template <typename Container>
3482 operator Matcher<Container>() const {
3483 typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
3484 typedef typename internal::StlContainerView<RawContainer>::type View;
3485 typedef typename View::value_type Element;
3486 typedef ::std::vector<Matcher<const Element&> > MatcherVec;
3487 MatcherVec matchers;
3488 matchers.reserve(::testing::tuple_size<MatcherTuple>::value);
3489 TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
3490 ::std::back_inserter(matchers));
3491 return MakeMatcher(new ElementsAreMatcherImpl<Container>(
3492 matchers.begin(), matchers.end()));
3496 const MatcherTuple matchers_;
3497 GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher);
3500 // Implements UnorderedElementsAreArray().
3501 template <typename T>
3502 class UnorderedElementsAreArrayMatcher {
3504 UnorderedElementsAreArrayMatcher() {}
3506 template <typename Iter>
3507 UnorderedElementsAreArrayMatcher(Iter first, Iter last)
3508 : matchers_(first, last) {}
3510 template <typename Container>
3511 operator Matcher<Container>() const {
3513 new UnorderedElementsAreMatcherImpl<Container>(matchers_.begin(),
3518 ::std::vector<T> matchers_;
3520 GTEST_DISALLOW_ASSIGN_(UnorderedElementsAreArrayMatcher);
3523 // Implements ElementsAreArray().
3524 template <typename T>
3525 class ElementsAreArrayMatcher {
3527 template <typename Iter>
3528 ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
3530 template <typename Container>
3531 operator Matcher<Container>() const {
3532 return MakeMatcher(new ElementsAreMatcherImpl<Container>(
3533 matchers_.begin(), matchers_.end()));
3537 const ::std::vector<T> matchers_;
3539 GTEST_DISALLOW_ASSIGN_(ElementsAreArrayMatcher);
3542 // Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
3543 // of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
3544 // second) is a polymorphic matcher that matches a value x iff tm
3545 // matches tuple (x, second). Useful for implementing
3546 // UnorderedPointwise() in terms of UnorderedElementsAreArray().
3548 // BoundSecondMatcher is copyable and assignable, as we need to put
3549 // instances of this class in a vector when implementing
3550 // UnorderedPointwise().
3551 template <typename Tuple2Matcher, typename Second>
3552 class BoundSecondMatcher {
3554 BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
3555 : tuple2_matcher_(tm), second_value_(second) {}
3557 template <typename T>
3558 operator Matcher<T>() const {
3559 return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
3562 // We have to define this for UnorderedPointwise() to compile in
3563 // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
3564 // which requires the elements to be assignable in C++98. The
3565 // compiler cannot generate the operator= for us, as Tuple2Matcher
3566 // and Second may not be assignable.
3568 // However, this should never be called, so the implementation just
3570 void operator=(const BoundSecondMatcher& /*rhs*/) {
3571 GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
3575 template <typename T>
3576 class Impl : public MatcherInterface<T> {
3578 typedef ::testing::tuple<T, Second> ArgTuple;
3580 Impl(const Tuple2Matcher& tm, const Second& second)
3581 : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
3582 second_value_(second) {}
3584 virtual void DescribeTo(::std::ostream* os) const {
3586 UniversalPrint(second_value_, os);
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_;
3600 GTEST_DISALLOW_ASSIGN_(Impl);
3603 const Tuple2Matcher tuple2_matcher_;
3604 const Second second_value_;
3607 // Given a 2-tuple matcher tm and a value second,
3608 // MatcherBindSecond(tm, second) returns a matcher that matches a
3609 // value x iff tm matches tuple (x, second). Useful for implementing
3610 // UnorderedPointwise() in terms of UnorderedElementsAreArray().
3611 template <typename Tuple2Matcher, typename Second>
3612 BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
3613 const Tuple2Matcher& tm, const Second& second) {
3614 return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
3617 // Returns the description for a matcher defined using the MATCHER*()
3618 // macro where the user-supplied description string is "", if
3619 // 'negation' is false; otherwise returns the description of the
3620 // negation of the matcher. 'param_values' contains a list of strings
3621 // that are the print-out of the matcher's parameters.
3622 GTEST_API_ string FormatMatcherDescription(bool negation,
3623 const char* matcher_name,
3624 const Strings& param_values);
3626 } // namespace internal
3628 // ElementsAreArray(first, last)
3629 // ElementsAreArray(pointer, count)
3630 // ElementsAreArray(array)
3631 // ElementsAreArray(container)
3632 // ElementsAreArray({ e1, e2, ..., en })
3634 // The ElementsAreArray() functions are like ElementsAre(...), except
3635 // that they are given a homogeneous sequence rather than taking each
3636 // element as a function argument. The sequence can be specified as an
3637 // array, a pointer and count, a vector, an initializer list, or an
3638 // STL iterator range. In each of these cases, the underlying sequence
3639 // can be either a sequence of values or a sequence of matchers.
3641 // All forms of ElementsAreArray() make a copy of the input matcher sequence.
3643 template <typename Iter>
3644 inline internal::ElementsAreArrayMatcher<
3645 typename ::std::iterator_traits<Iter>::value_type>
3646 ElementsAreArray(Iter first, Iter last) {
3647 typedef typename ::std::iterator_traits<Iter>::value_type T;
3648 return internal::ElementsAreArrayMatcher<T>(first, last);
3651 template <typename T>
3652 inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
3653 const T* pointer, size_t count) {
3654 return ElementsAreArray(pointer, pointer + count);
3657 template <typename T, size_t N>
3658 inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
3659 const T (&array)[N]) {
3660 return ElementsAreArray(array, N);
3663 template <typename Container>
3664 inline internal::ElementsAreArrayMatcher<typename Container::value_type>
3665 ElementsAreArray(const Container& container) {
3666 return ElementsAreArray(container.begin(), container.end());
3669 #if GTEST_HAS_STD_INITIALIZER_LIST_
3670 template <typename T>
3671 inline internal::ElementsAreArrayMatcher<T>
3672 ElementsAreArray(::std::initializer_list<T> xs) {
3673 return ElementsAreArray(xs.begin(), xs.end());
3677 // UnorderedElementsAreArray(first, last)
3678 // UnorderedElementsAreArray(pointer, count)
3679 // UnorderedElementsAreArray(array)
3680 // UnorderedElementsAreArray(container)
3681 // UnorderedElementsAreArray({ e1, e2, ..., en })
3683 // The UnorderedElementsAreArray() functions are like
3684 // ElementsAreArray(...), but allow matching the elements in any order.
3685 template <typename Iter>
3686 inline internal::UnorderedElementsAreArrayMatcher<
3687 typename ::std::iterator_traits<Iter>::value_type>
3688 UnorderedElementsAreArray(Iter first, Iter last) {
3689 typedef typename ::std::iterator_traits<Iter>::value_type T;
3690 return internal::UnorderedElementsAreArrayMatcher<T>(first, last);
3693 template <typename T>
3694 inline internal::UnorderedElementsAreArrayMatcher<T>
3695 UnorderedElementsAreArray(const T* pointer, size_t count) {
3696 return UnorderedElementsAreArray(pointer, pointer + count);
3699 template <typename T, size_t N>
3700 inline internal::UnorderedElementsAreArrayMatcher<T>
3701 UnorderedElementsAreArray(const T (&array)[N]) {
3702 return UnorderedElementsAreArray(array, N);
3705 template <typename Container>
3706 inline internal::UnorderedElementsAreArrayMatcher<
3707 typename Container::value_type>
3708 UnorderedElementsAreArray(const Container& container) {
3709 return UnorderedElementsAreArray(container.begin(), container.end());
3712 #if GTEST_HAS_STD_INITIALIZER_LIST_
3713 template <typename T>
3714 inline internal::UnorderedElementsAreArrayMatcher<T>
3715 UnorderedElementsAreArray(::std::initializer_list<T> xs) {
3716 return UnorderedElementsAreArray(xs.begin(), xs.end());
3720 // _ is a matcher that matches anything of any type.
3722 // This definition is fine as:
3724 // 1. The C++ standard permits using the name _ in a namespace that
3725 // is not the global namespace or ::std.
3726 // 2. The AnythingMatcher class has no data member or constructor,
3727 // so it's OK to create global variables of this type.
3728 // 3. c-style has approved of using _ in this case.
3729 const internal::AnythingMatcher _ = {};
3730 // Creates a matcher that matches any value of the given type T.
3731 template <typename T>
3732 inline Matcher<T> A() { return MakeMatcher(new internal::AnyMatcherImpl<T>()); }
3734 // Creates a matcher that matches any value of the given type T.
3735 template <typename T>
3736 inline Matcher<T> An() { return A<T>(); }
3738 // Creates a polymorphic matcher that matches anything equal to x.
3739 // Note: if the parameter of Eq() were declared as const T&, Eq("foo")
3740 // wouldn't compile.
3741 template <typename T>
3742 inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
3744 // Constructs a Matcher<T> from a 'value' of type T. The constructed
3745 // matcher matches any value that's equal to 'value'.
3746 template <typename T>
3747 Matcher<T>::Matcher(T value) { *this = Eq(value); }
3749 // Creates a monomorphic matcher that matches anything with type Lhs
3750 // and equal to rhs. A user may need to use this instead of Eq(...)
3751 // in order to resolve an overloading ambiguity.
3753 // TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
3754 // or Matcher<T>(x), but more readable than the latter.
3756 // We could define similar monomorphic matchers for other comparison
3757 // operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
3758 // it yet as those are used much less than Eq() in practice. A user
3759 // can always write Matcher<T>(Lt(5)) to be explicit about the type,
3761 template <typename Lhs, typename Rhs>
3762 inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
3764 // Creates a polymorphic matcher that matches anything >= x.
3765 template <typename Rhs>
3766 inline internal::GeMatcher<Rhs> Ge(Rhs x) {
3767 return internal::GeMatcher<Rhs>(x);
3770 // Creates a polymorphic matcher that matches anything > x.
3771 template <typename Rhs>
3772 inline internal::GtMatcher<Rhs> Gt(Rhs x) {
3773 return internal::GtMatcher<Rhs>(x);
3776 // Creates a polymorphic matcher that matches anything <= x.
3777 template <typename Rhs>
3778 inline internal::LeMatcher<Rhs> Le(Rhs x) {
3779 return internal::LeMatcher<Rhs>(x);
3782 // Creates a polymorphic matcher that matches anything < x.
3783 template <typename Rhs>
3784 inline internal::LtMatcher<Rhs> Lt(Rhs x) {
3785 return internal::LtMatcher<Rhs>(x);
3788 // Creates a polymorphic matcher that matches anything != x.
3789 template <typename Rhs>
3790 inline internal::NeMatcher<Rhs> Ne(Rhs x) {
3791 return internal::NeMatcher<Rhs>(x);
3794 // Creates a polymorphic matcher that matches any NULL pointer.
3795 inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
3796 return MakePolymorphicMatcher(internal::IsNullMatcher());
3799 // Creates a polymorphic matcher that matches any non-NULL pointer.
3800 // This is convenient as Not(NULL) doesn't compile (the compiler
3801 // thinks that that expression is comparing a pointer with an integer).
3802 inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
3803 return MakePolymorphicMatcher(internal::NotNullMatcher());
3806 // Creates a polymorphic matcher that matches any argument that
3807 // references variable x.
3808 template <typename T>
3809 inline internal::RefMatcher<T&> Ref(T& x) { // NOLINT
3810 return internal::RefMatcher<T&>(x);
3813 // Creates a matcher that matches any double argument approximately
3814 // equal to rhs, where two NANs are considered unequal.
3815 inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
3816 return internal::FloatingEqMatcher<double>(rhs, false);
3819 // Creates a matcher that matches any double argument approximately
3820 // equal to rhs, including NaN values when rhs is NaN.
3821 inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
3822 return internal::FloatingEqMatcher<double>(rhs, true);
3825 // Creates a matcher that matches any double argument approximately equal to
3826 // rhs, up to the specified max absolute error bound, where two NANs are
3827 // considered unequal. The max absolute error bound must be non-negative.
3828 inline internal::FloatingEqMatcher<double> DoubleNear(
3829 double rhs, double max_abs_error) {
3830 return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
3833 // Creates a matcher that matches any double argument approximately equal to
3834 // rhs, up to the specified max absolute error bound, including NaN values when
3835 // rhs is NaN. The max absolute error bound must be non-negative.
3836 inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
3837 double rhs, double max_abs_error) {
3838 return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
3841 // Creates a matcher that matches any float argument approximately
3842 // equal to rhs, where two NANs are considered unequal.
3843 inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
3844 return internal::FloatingEqMatcher<float>(rhs, false);
3847 // Creates a matcher that matches any float argument approximately
3848 // equal to rhs, including NaN values when rhs is NaN.
3849 inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
3850 return internal::FloatingEqMatcher<float>(rhs, true);
3853 // Creates a matcher that matches any float argument approximately equal to
3854 // rhs, up to the specified max absolute error bound, where two NANs are
3855 // considered unequal. The max absolute error bound must be non-negative.
3856 inline internal::FloatingEqMatcher<float> FloatNear(
3857 float rhs, float max_abs_error) {
3858 return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
3861 // Creates a matcher that matches any float argument approximately equal to
3862 // rhs, up to the specified max absolute error bound, including NaN values when
3863 // rhs is NaN. The max absolute error bound must be non-negative.
3864 inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
3865 float rhs, float max_abs_error) {
3866 return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
3869 // Creates a matcher that matches a pointer (raw or smart) that points
3870 // to a value that matches inner_matcher.
3871 template <typename InnerMatcher>
3872 inline internal::PointeeMatcher<InnerMatcher> Pointee(
3873 const InnerMatcher& inner_matcher) {
3874 return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
3877 // Creates a matcher that matches a pointer or reference that matches
3878 // inner_matcher when dynamic_cast<To> is applied.
3879 // The result of dynamic_cast<To> is forwarded to the inner matcher.
3880 // If To is a pointer and the cast fails, the inner matcher will receive NULL.
3881 // If To is a reference and the cast fails, this matcher returns false
3883 template <typename To>
3884 inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
3885 WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
3886 return MakePolymorphicMatcher(
3887 internal::WhenDynamicCastToMatcher<To>(inner_matcher));
3890 // Creates a matcher that matches an object whose given field matches
3891 // 'matcher'. For example,
3892 // Field(&Foo::number, Ge(5))
3893 // matches a Foo object x iff x.number >= 5.
3894 template <typename Class, typename FieldType, typename FieldMatcher>
3895 inline PolymorphicMatcher<
3896 internal::FieldMatcher<Class, FieldType> > Field(
3897 FieldType Class::*field, const FieldMatcher& matcher) {
3898 return MakePolymorphicMatcher(
3899 internal::FieldMatcher<Class, FieldType>(
3900 field, MatcherCast<const FieldType&>(matcher)));
3901 // The call to MatcherCast() is required for supporting inner
3902 // matchers of compatible types. For example, it allows
3903 // Field(&Foo::bar, m)
3904 // to compile where bar is an int32 and m is a matcher for int64.
3907 // Creates a matcher that matches an object whose given property
3908 // matches 'matcher'. For example,
3909 // Property(&Foo::str, StartsWith("hi"))
3910 // matches a Foo object x iff x.str() starts with "hi".
3911 template <typename Class, typename PropertyType, typename PropertyMatcher>
3912 inline PolymorphicMatcher<
3913 internal::PropertyMatcher<Class, PropertyType> > Property(
3914 PropertyType (Class::*property)() const, const PropertyMatcher& matcher) {
3915 return MakePolymorphicMatcher(
3916 internal::PropertyMatcher<Class, PropertyType>(
3918 MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
3919 // The call to MatcherCast() is required for supporting inner
3920 // matchers of compatible types. For example, it allows
3921 // Property(&Foo::bar, m)
3922 // to compile where bar() returns an int32 and m is a matcher for int64.
3925 // Creates a matcher that matches an object iff the result of applying
3926 // a callable to x matches 'matcher'.
3928 // ResultOf(f, StartsWith("hi"))
3929 // matches a Foo object x iff f(x) starts with "hi".
3930 // callable parameter can be a function, function pointer, or a functor.
3931 // Callable has to satisfy the following conditions:
3932 // * It is required to keep no state affecting the results of
3933 // the calls on it and make no assumptions about how many calls
3934 // will be made. Any state it keeps must be protected from the
3935 // concurrent access.
3936 // * If it is a function object, it has to define type result_type.
3937 // We recommend deriving your functor classes from std::unary_function.
3938 template <typename Callable, typename ResultOfMatcher>
3939 internal::ResultOfMatcher<Callable> ResultOf(
3940 Callable callable, const ResultOfMatcher& matcher) {
3941 return internal::ResultOfMatcher<Callable>(
3943 MatcherCast<typename internal::CallableTraits<Callable>::ResultType>(
3945 // The call to MatcherCast() is required for supporting inner
3946 // matchers of compatible types. For example, it allows
3947 // ResultOf(Function, m)
3948 // to compile where Function() returns an int32 and m is a matcher for int64.
3953 // Matches a string equal to str.
3954 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3955 StrEq(const internal::string& str) {
3956 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3960 // Matches a string not equal to str.
3961 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3962 StrNe(const internal::string& str) {
3963 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3967 // Matches a string equal to str, ignoring case.
3968 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3969 StrCaseEq(const internal::string& str) {
3970 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3974 // Matches a string not equal to str, ignoring case.
3975 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::string> >
3976 StrCaseNe(const internal::string& str) {
3977 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::string>(
3978 str, false, false));
3981 // Creates a matcher that matches any string, std::string, or C string
3982 // that contains the given substring.
3983 inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::string> >
3984 HasSubstr(const internal::string& substring) {
3985 return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::string>(
3989 // Matches a string that starts with 'prefix' (case-sensitive).
3990 inline PolymorphicMatcher<internal::StartsWithMatcher<internal::string> >
3991 StartsWith(const internal::string& prefix) {
3992 return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::string>(
3996 // Matches a string that ends with 'suffix' (case-sensitive).
3997 inline PolymorphicMatcher<internal::EndsWithMatcher<internal::string> >
3998 EndsWith(const internal::string& suffix) {
3999 return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::string>(
4003 // Matches a string that fully matches regular expression 'regex'.
4004 // The matcher takes ownership of 'regex'.
4005 inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
4006 const internal::RE* regex) {
4007 return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
4009 inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
4010 const internal::string& regex) {
4011 return MatchesRegex(new internal::RE(regex));
4014 // Matches a string that contains regular expression 'regex'.
4015 // The matcher takes ownership of 'regex'.
4016 inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
4017 const internal::RE* regex) {
4018 return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
4020 inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
4021 const internal::string& regex) {
4022 return ContainsRegex(new internal::RE(regex));
4025 #if GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
4026 // Wide string matchers.
4028 // Matches a string equal to str.
4029 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4030 StrEq(const internal::wstring& str) {
4031 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
4035 // Matches a string not equal to str.
4036 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4037 StrNe(const internal::wstring& str) {
4038 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
4042 // Matches a string equal to str, ignoring case.
4043 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4044 StrCaseEq(const internal::wstring& str) {
4045 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
4049 // Matches a string not equal to str, ignoring case.
4050 inline PolymorphicMatcher<internal::StrEqualityMatcher<internal::wstring> >
4051 StrCaseNe(const internal::wstring& str) {
4052 return MakePolymorphicMatcher(internal::StrEqualityMatcher<internal::wstring>(
4053 str, false, false));
4056 // Creates a matcher that matches any wstring, std::wstring, or C wide string
4057 // that contains the given substring.
4058 inline PolymorphicMatcher<internal::HasSubstrMatcher<internal::wstring> >
4059 HasSubstr(const internal::wstring& substring) {
4060 return MakePolymorphicMatcher(internal::HasSubstrMatcher<internal::wstring>(
4064 // Matches a string that starts with 'prefix' (case-sensitive).
4065 inline PolymorphicMatcher<internal::StartsWithMatcher<internal::wstring> >
4066 StartsWith(const internal::wstring& prefix) {
4067 return MakePolymorphicMatcher(internal::StartsWithMatcher<internal::wstring>(
4071 // Matches a string that ends with 'suffix' (case-sensitive).
4072 inline PolymorphicMatcher<internal::EndsWithMatcher<internal::wstring> >
4073 EndsWith(const internal::wstring& suffix) {
4074 return MakePolymorphicMatcher(internal::EndsWithMatcher<internal::wstring>(
4078 #endif // GTEST_HAS_GLOBAL_WSTRING || GTEST_HAS_STD_WSTRING
4080 // Creates a polymorphic matcher that matches a 2-tuple where the
4081 // first field == the second field.
4082 inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
4084 // Creates a polymorphic matcher that matches a 2-tuple where the
4085 // first field >= the second field.
4086 inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
4088 // Creates a polymorphic matcher that matches a 2-tuple where the
4089 // first field > the second field.
4090 inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
4092 // Creates a polymorphic matcher that matches a 2-tuple where the
4093 // first field <= the second field.
4094 inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
4096 // Creates a polymorphic matcher that matches a 2-tuple where the
4097 // first field < the second field.
4098 inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
4100 // Creates a polymorphic matcher that matches a 2-tuple where the
4101 // first field != the second field.
4102 inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
4104 // Creates a matcher that matches any value of type T that m doesn't
4106 template <typename InnerMatcher>
4107 inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
4108 return internal::NotMatcher<InnerMatcher>(m);
4111 // Returns a matcher that matches anything that satisfies the given
4112 // predicate. The predicate can be any unary function or functor
4113 // whose return type can be implicitly converted to bool.
4114 template <typename Predicate>
4115 inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
4116 Truly(Predicate pred) {
4117 return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
4120 // Returns a matcher that matches the container size. The container must
4121 // support both size() and size_type which all STL-like containers provide.
4122 // Note that the parameter 'size' can be a value of type size_type as well as
4123 // matcher. For instance:
4124 // EXPECT_THAT(container, SizeIs(2)); // Checks container has 2 elements.
4125 // EXPECT_THAT(container, SizeIs(Le(2)); // Checks container has at most 2.
4126 template <typename SizeMatcher>
4127 inline internal::SizeIsMatcher<SizeMatcher>
4128 SizeIs(const SizeMatcher& size_matcher) {
4129 return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
4132 // Returns a matcher that matches the distance between the container's begin()
4133 // iterator and its end() iterator, i.e. the size of the container. This matcher
4134 // can be used instead of SizeIs with containers such as std::forward_list which
4135 // do not implement size(). The container must provide const_iterator (with
4136 // valid iterator_traits), begin() and end().
4137 template <typename DistanceMatcher>
4138 inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
4139 BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
4140 return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
4143 // Returns a matcher that matches an equal container.
4144 // This matcher behaves like Eq(), but in the event of mismatch lists the
4145 // values that are included in one container but not the other. (Duplicate
4146 // values and order differences are not explained.)
4147 template <typename Container>
4148 inline PolymorphicMatcher<internal::ContainerEqMatcher< // NOLINT
4149 GTEST_REMOVE_CONST_(Container)> >
4150 ContainerEq(const Container& rhs) {
4151 // This following line is for working around a bug in MSVC 8.0,
4152 // which causes Container to be a const type sometimes.
4153 typedef GTEST_REMOVE_CONST_(Container) RawContainer;
4154 return MakePolymorphicMatcher(
4155 internal::ContainerEqMatcher<RawContainer>(rhs));
4158 // Returns a matcher that matches a container that, when sorted using
4159 // the given comparator, matches container_matcher.
4160 template <typename Comparator, typename ContainerMatcher>
4161 inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
4162 WhenSortedBy(const Comparator& comparator,
4163 const ContainerMatcher& container_matcher) {
4164 return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
4165 comparator, container_matcher);
4168 // Returns a matcher that matches a container that, when sorted using
4169 // the < operator, matches container_matcher.
4170 template <typename ContainerMatcher>
4171 inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
4172 WhenSorted(const ContainerMatcher& container_matcher) {
4174 internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
4175 internal::LessComparator(), container_matcher);
4178 // Matches an STL-style container or a native array that contains the
4179 // same number of elements as in rhs, where its i-th element and rhs's
4180 // i-th element (as a pair) satisfy the given pair matcher, for all i.
4181 // TupleMatcher must be able to be safely cast to Matcher<tuple<const
4182 // T1&, const T2&> >, where T1 and T2 are the types of elements in the
4183 // LHS container and the RHS container respectively.
4184 template <typename TupleMatcher, typename Container>
4185 inline internal::PointwiseMatcher<TupleMatcher,
4186 GTEST_REMOVE_CONST_(Container)>
4187 Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
4188 // This following line is for working around a bug in MSVC 8.0,
4189 // which causes Container to be a const type sometimes (e.g. when
4190 // rhs is a const int[])..
4191 typedef GTEST_REMOVE_CONST_(Container) RawContainer;
4192 return internal::PointwiseMatcher<TupleMatcher, RawContainer>(
4193 tuple_matcher, rhs);
4196 #if GTEST_HAS_STD_INITIALIZER_LIST_
4198 // Supports the Pointwise(m, {a, b, c}) syntax.
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_
4207 // UnorderedPointwise(pair_matcher, rhs) matches an STL-style
4208 // container or a native array that contains the same number of
4209 // elements as in rhs, where in some permutation of the container, its
4210 // i-th element and rhs's i-th element (as a pair) satisfy the given
4211 // pair matcher, for all i. Tuple2Matcher must be able to be safely
4212 // cast to Matcher<tuple<const T1&, const T2&> >, where T1 and T2 are
4213 // the types of elements in the LHS container and the RHS container
4216 // This is like Pointwise(pair_matcher, rhs), except that the element
4217 // order doesn't matter.
4218 template <typename Tuple2Matcher, typename RhsContainer>
4219 inline internal::UnorderedElementsAreArrayMatcher<
4220 typename internal::BoundSecondMatcher<
4221 Tuple2Matcher, typename internal::StlContainerView<GTEST_REMOVE_CONST_(
4222 RhsContainer)>::type::value_type> >
4223 UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
4224 const RhsContainer& rhs_container) {
4225 // This following line is for working around a bug in MSVC 8.0,
4226 // which causes RhsContainer to be a const type sometimes (e.g. when
4227 // rhs_container is a const int[]).
4228 typedef GTEST_REMOVE_CONST_(RhsContainer) RawRhsContainer;
4230 // RhsView allows the same code to handle RhsContainer being a
4231 // STL-style container and it being a native C-style array.
4232 typedef typename internal::StlContainerView<RawRhsContainer> RhsView;
4233 typedef typename RhsView::type RhsStlContainer;
4234 typedef typename RhsStlContainer::value_type Second;
4235 const RhsStlContainer& rhs_stl_container =
4236 RhsView::ConstReference(rhs_container);
4238 // Create a matcher for each element in 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) {
4243 internal::MatcherBindSecond(tuple2_matcher, *it));
4246 // Delegate the work to UnorderedElementsAreArray().
4247 return UnorderedElementsAreArray(matchers);
4250 #if GTEST_HAS_STD_INITIALIZER_LIST_
4252 // Supports the UnorderedPointwise(m, {a, b, c}) syntax.
4253 template <typename Tuple2Matcher, typename T>
4254 inline internal::UnorderedElementsAreArrayMatcher<
4255 typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
4256 UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
4257 std::initializer_list<T> rhs) {
4258 return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
4261 #endif // GTEST_HAS_STD_INITIALIZER_LIST_
4263 // Matches an STL-style container or a native array that contains at
4264 // least one element matching the given value or matcher.
4267 // ::std::set<int> page_ids;
4268 // page_ids.insert(3);
4269 // page_ids.insert(1);
4270 // EXPECT_THAT(page_ids, Contains(1));
4271 // EXPECT_THAT(page_ids, Contains(Gt(2)));
4272 // EXPECT_THAT(page_ids, Not(Contains(4)));
4274 // ::std::map<int, size_t> page_lengths;
4275 // page_lengths[1] = 100;
4276 // EXPECT_THAT(page_lengths,
4277 // Contains(::std::pair<const int, size_t>(1, 100)));
4279 // const char* user_ids[] = { "joe", "mike", "tom" };
4280 // EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
4281 template <typename M>
4282 inline internal::ContainsMatcher<M> Contains(M matcher) {
4283 return internal::ContainsMatcher<M>(matcher);
4286 // Matches an STL-style container or a native array that contains only
4287 // elements matching the given value or matcher.
4289 // Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
4290 // the messages are different.
4293 // ::std::set<int> page_ids;
4294 // // Each(m) matches an empty container, regardless of what m is.
4295 // EXPECT_THAT(page_ids, Each(Eq(1)));
4296 // EXPECT_THAT(page_ids, Each(Eq(77)));
4298 // page_ids.insert(3);
4299 // EXPECT_THAT(page_ids, Each(Gt(0)));
4300 // EXPECT_THAT(page_ids, Not(Each(Gt(4))));
4301 // page_ids.insert(1);
4302 // EXPECT_THAT(page_ids, Not(Each(Lt(2))));
4304 // ::std::map<int, size_t> page_lengths;
4305 // page_lengths[1] = 100;
4306 // page_lengths[2] = 200;
4307 // page_lengths[3] = 300;
4308 // EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
4309 // EXPECT_THAT(page_lengths, Each(Key(Le(3))));
4311 // const char* user_ids[] = { "joe", "mike", "tom" };
4312 // EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
4313 template <typename M>
4314 inline internal::EachMatcher<M> Each(M matcher) {
4315 return internal::EachMatcher<M>(matcher);
4318 // Key(inner_matcher) matches an std::pair whose 'first' field matches
4319 // inner_matcher. For example, Contains(Key(Ge(5))) can be used to match an
4320 // std::map that contains at least one element whose key is >= 5.
4321 template <typename M>
4322 inline internal::KeyMatcher<M> Key(M inner_matcher) {
4323 return internal::KeyMatcher<M>(inner_matcher);
4326 // Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
4327 // matches first_matcher and whose 'second' field matches second_matcher. For
4328 // example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
4329 // to match a std::map<int, string> that contains exactly one element whose key
4330 // is >= 5 and whose value equals "foo".
4331 template <typename FirstMatcher, typename SecondMatcher>
4332 inline internal::PairMatcher<FirstMatcher, SecondMatcher>
4333 Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
4334 return internal::PairMatcher<FirstMatcher, SecondMatcher>(
4335 first_matcher, second_matcher);
4338 // Returns a predicate that is satisfied by anything that matches the
4340 template <typename M>
4341 inline internal::MatcherAsPredicate<M> Matches(M matcher) {
4342 return internal::MatcherAsPredicate<M>(matcher);
4345 // Returns true iff the value matches the matcher.
4346 template <typename T, typename M>
4347 inline bool Value(const T& value, M matcher) {
4348 return testing::Matches(matcher)(value);
4351 // Matches the value against the given matcher and explains the match
4352 // result to listener.
4353 template <typename T, typename M>
4354 inline bool ExplainMatchResult(
4355 M matcher, const T& value, MatchResultListener* listener) {
4356 return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
4359 #if GTEST_LANG_CXX11
4360 // Define variadic matcher versions. They are overloaded in
4361 // gmock-generated-matchers.h for the cases supported by pre C++11 compilers.
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
4374 // AllArgs(m) is a synonym of m. This is useful in
4376 // EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
4378 // which is easier to read than
4380 // EXPECT_CALL(foo, Bar(_, _)).With(Eq());
4381 template <typename InnerMatcher>
4382 inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
4384 // These macros allow using matchers to check values in Google Test
4385 // tests. ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
4386 // succeed iff the value matches the matcher. If the assertion fails,
4387 // the value and the description of the matcher will be printed.
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)
4393 } // namespace testing
4395 // Include any custom callback matchers added by the local installation.
4396 // We must include this header at the end to make sure it can use the
4397 // declarations from this file.
4398 #include "gmock/internal/custom/gmock-matchers.h"
4399 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_