/testlibs/gmock/include/gmock/gmock-matchers.h
https://github.com/deltaforge/nebu-app-mongo · C Header · 3066 lines · 1846 code · 427 blank · 793 comment · 142 complexity · 0993f8cc8b4762f2903ce55c8ea73ade MD5 · raw file
Large files are truncated click here to view the full file
- // Copyright 2007, Google Inc.
- // All rights reserved.
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // * Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- // * Redistributions in binary form must reproduce the above
- // copyright notice, this list of conditions and the following disclaimer
- // in the documentation and/or other materials provided with the
- // distribution.
- // * Neither the name of Google Inc. nor the names of its
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- //
- // Author: wan@google.com (Zhanyong Wan)
- // Google Mock - a framework for writing C++ mock classes.
- //
- // This file implements some commonly used argument matchers. More
- // matchers can be defined by the user implementing the
- // MatcherInterface<T> interface if necessary.
- #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
- #define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
- #include <algorithm>
- #include <limits>
- #include <ostream> // NOLINT
- #include <sstream>
- #include <string>
- #include <utility>
- #include <vector>
- #include "gmock/internal/gmock-internal-utils.h"
- #include "gmock/internal/gmock-port.h"
- #include "gtest/gtest.h"
- namespace testing {
- // To implement a matcher Foo for type T, define:
- // 1. a class FooMatcherImpl that implements the
- // MatcherInterface<T> interface, and
- // 2. a factory function that creates a Matcher<T> object from a
- // FooMatcherImpl*.
- //
- // The two-level delegation design makes it possible to allow a user
- // to write "v" instead of "Eq(v)" where a Matcher is expected, which
- // is impossible if we pass matchers by pointers. It also eases
- // ownership management as Matcher objects can now be copied like
- // plain values.
- // MatchResultListener is an abstract class. Its << operator can be
- // used by a matcher to explain why a value matches or doesn't match.
- //
- // TODO(wan@google.com): add method
- // bool InterestedInWhy(bool result) const;
- // to indicate whether the listener is interested in why the match
- // result is 'result'.
- class MatchResultListener {
- public:
- // Creates a listener object with the given underlying ostream. The
- // listener does not own the ostream.
- explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
- virtual ~MatchResultListener() = 0; // Makes this class abstract.
- // Streams x to the underlying ostream; does nothing if the ostream
- // is NULL.
- template <typename T>
- MatchResultListener& operator<<(const T& x) {
- if (stream_ != NULL)
- *stream_ << x;
- return *this;
- }
- // Returns the underlying ostream.
- ::std::ostream* stream() { return stream_; }
- // Returns true iff the listener is interested in an explanation of
- // the match result. A matcher's MatchAndExplain() method can use
- // this information to avoid generating the explanation when no one
- // intends to hear it.
- bool IsInterested() const { return stream_ != NULL; }
- private:
- ::std::ostream* const stream_;
- GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
- };
- inline MatchResultListener::~MatchResultListener() {
- }
- // The implementation of a matcher.
- template <typename T>
- class MatcherInterface {
- public:
- virtual ~MatcherInterface() {}
- // Returns true iff the matcher matches x; also explains the match
- // result to 'listener', in the form of a non-restrictive relative
- // clause ("which ...", "whose ...", etc) that describes x. For
- // example, the MatchAndExplain() method of the Pointee(...) matcher
- // should generate an explanation like "which points to ...".
- //
- // You should override this method when defining a new matcher.
- //
- // It's the responsibility of the caller (Google Mock) to guarantee
- // that 'listener' is not NULL. This helps to simplify a matcher's
- // implementation when it doesn't care about the performance, as it
- // can talk to 'listener' without checking its validity first.
- // However, in order to implement dummy listeners efficiently,
- // listener->stream() may be NULL.
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
- // Describes this matcher to an ostream. The function should print
- // a verb phrase that describes the property a value matching this
- // matcher should have. The subject of the verb phrase is the value
- // being matched. For example, the DescribeTo() method of the Gt(7)
- // matcher prints "is greater than 7".
- virtual void DescribeTo(::std::ostream* os) const = 0;
- // Describes the negation of this matcher to an ostream. For
- // example, if the description of this matcher is "is greater than
- // 7", the negated description could be "is not greater than 7".
- // You are not required to override this when implementing
- // MatcherInterface, but it is highly advised so that your matcher
- // can produce good error messages.
- virtual void DescribeNegationTo(::std::ostream* os) const {
- *os << "not (";
- DescribeTo(os);
- *os << ")";
- }
- };
- namespace internal {
- // A match result listener that ignores the explanation.
- class DummyMatchResultListener : public MatchResultListener {
- public:
- DummyMatchResultListener() : MatchResultListener(NULL) {}
- private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
- };
- // A match result listener that forwards the explanation to a given
- // ostream. The difference between this and MatchResultListener is
- // that the former is concrete.
- class StreamMatchResultListener : public MatchResultListener {
- public:
- explicit StreamMatchResultListener(::std::ostream* os)
- : MatchResultListener(os) {}
- private:
- GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
- };
- // A match result listener that stores the explanation in a string.
- class StringMatchResultListener : public MatchResultListener {
- public:
- StringMatchResultListener() : MatchResultListener(&ss_) {}
- // Returns the explanation heard so far.
- internal::string str() const { return ss_.str(); }
- private:
- ::std::stringstream ss_;
- GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
- };
- // An internal class for implementing Matcher<T>, which will derive
- // from it. We put functionalities common to all Matcher<T>
- // specializations here to avoid code duplication.
- template <typename T>
- class MatcherBase {
- public:
- // Returns true iff the matcher matches x; also explains the match
- // result to 'listener'.
- bool MatchAndExplain(T x, MatchResultListener* listener) const {
- return impl_->MatchAndExplain(x, listener);
- }
- // Returns true iff this matcher matches x.
- bool Matches(T x) const {
- DummyMatchResultListener dummy;
- return MatchAndExplain(x, &dummy);
- }
- // Describes this matcher to an ostream.
- void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
- // Describes the negation of this matcher to an ostream.
- void DescribeNegationTo(::std::ostream* os) const {
- impl_->DescribeNegationTo(os);
- }
- // Explains why x matches, or doesn't match, the matcher.
- void ExplainMatchResultTo(T x, ::std::ostream* os) const {
- StreamMatchResultListener listener(os);
- MatchAndExplain(x, &listener);
- }
- protected:
- MatcherBase() {}
- // Constructs a matcher from its implementation.
- explicit MatcherBase(const MatcherInterface<T>* impl)
- : impl_(impl) {}
- virtual ~MatcherBase() {}
- private:
- // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
- // interfaces. The former dynamically allocates a chunk of memory
- // to hold the reference count, while the latter tracks all
- // references using a circular linked list without allocating
- // memory. It has been observed that linked_ptr performs better in
- // typical scenarios. However, shared_ptr can out-perform
- // linked_ptr when there are many more uses of the copy constructor
- // than the default constructor.
- //
- // If performance becomes a problem, we should see if using
- // shared_ptr helps.
- ::testing::internal::linked_ptr<const MatcherInterface<T> > impl_;
- };
- } // namespace internal
- // A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
- // object that can check whether a value of type T matches. The
- // implementation of Matcher<T> is just a linked_ptr to const
- // MatcherInterface<T>, so copying is fairly cheap. Don't inherit
- // from Matcher!
- template <typename T>
- class Matcher : public internal::MatcherBase<T> {
- public:
- // Constructs a null matcher. Needed for storing Matcher objects in STL
- // containers. A default-constructed matcher is not yet initialized. You
- // cannot use it until a valid value has been assigned to it.
- Matcher() {}
- // Constructs a matcher from its implementation.
- explicit Matcher(const MatcherInterface<T>* impl)
- : internal::MatcherBase<T>(impl) {}
- // Implicit constructor here allows people to write
- // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
- Matcher(T value); // NOLINT
- };
- // The following two specializations allow the user to write str
- // instead of Eq(str) and "foo" instead of Eq("foo") when a string
- // matcher is expected.
- template <>
- class Matcher<const internal::string&>
- : public internal::MatcherBase<const internal::string&> {
- public:
- Matcher() {}
- explicit Matcher(const MatcherInterface<const internal::string&>* impl)
- : internal::MatcherBase<const internal::string&>(impl) {}
- // Allows the user to write str instead of Eq(str) sometimes, where
- // str is a string object.
- Matcher(const internal::string& s); // NOLINT
- // Allows the user to write "foo" instead of Eq("foo") sometimes.
- Matcher(const char* s); // NOLINT
- };
- template <>
- class Matcher<internal::string>
- : public internal::MatcherBase<internal::string> {
- public:
- Matcher() {}
- explicit Matcher(const MatcherInterface<internal::string>* impl)
- : internal::MatcherBase<internal::string>(impl) {}
- // Allows the user to write str instead of Eq(str) sometimes, where
- // str is a string object.
- Matcher(const internal::string& s); // NOLINT
- // Allows the user to write "foo" instead of Eq("foo") sometimes.
- Matcher(const char* s); // NOLINT
- };
- // The PolymorphicMatcher class template makes it easy to implement a
- // polymorphic matcher (i.e. a matcher that can match values of more
- // than one type, e.g. Eq(n) and NotNull()).
- //
- // To define a polymorphic matcher, a user should provide an Impl
- // class that has a DescribeTo() method and a DescribeNegationTo()
- // method, and define a member function (or member function template)
- //
- // bool MatchAndExplain(const Value& value,
- // MatchResultListener* listener) const;
- //
- // See the definition of NotNull() for a complete example.
- template <class Impl>
- class PolymorphicMatcher {
- public:
- explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
- // Returns a mutable reference to the underlying matcher
- // implementation object.
- Impl& mutable_impl() { return impl_; }
- // Returns an immutable reference to the underlying matcher
- // implementation object.
- const Impl& impl() const { return impl_; }
- template <typename T>
- operator Matcher<T>() const {
- return Matcher<T>(new MonomorphicImpl<T>(impl_));
- }
- private:
- template <typename T>
- class MonomorphicImpl : public MatcherInterface<T> {
- public:
- explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
- virtual void DescribeTo(::std::ostream* os) const {
- impl_.DescribeTo(os);
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- impl_.DescribeNegationTo(os);
- }
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
- return impl_.MatchAndExplain(x, listener);
- }
- private:
- const Impl impl_;
- GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
- };
- Impl impl_;
- GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
- };
- // Creates a matcher from its implementation. This is easier to use
- // than the Matcher<T> constructor as it doesn't require you to
- // explicitly write the template argument, e.g.
- //
- // MakeMatcher(foo);
- // vs
- // Matcher<const string&>(foo);
- template <typename T>
- inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
- return Matcher<T>(impl);
- };
- // Creates a polymorphic matcher from its implementation. This is
- // easier to use than the PolymorphicMatcher<Impl> constructor as it
- // doesn't require you to explicitly write the template argument, e.g.
- //
- // MakePolymorphicMatcher(foo);
- // vs
- // PolymorphicMatcher<TypeOfFoo>(foo);
- template <class Impl>
- inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
- return PolymorphicMatcher<Impl>(impl);
- }
- // In order to be safe and clear, casting between different matcher
- // types is done explicitly via MatcherCast<T>(m), which takes a
- // matcher m and returns a Matcher<T>. It compiles only when T can be
- // statically converted to the argument type of m.
- template <typename T, typename M>
- Matcher<T> MatcherCast(M m);
- // Implements SafeMatcherCast().
- //
- // We use an intermediate class to do the actual safe casting as Nokia's
- // Symbian compiler cannot decide between
- // template <T, M> ... (M) and
- // template <T, U> ... (const Matcher<U>&)
- // for function templates but can for member function templates.
- template <typename T>
- class SafeMatcherCastImpl {
- public:
- // This overload handles polymorphic matchers only since monomorphic
- // matchers are handled by the next one.
- template <typename M>
- static inline Matcher<T> Cast(M polymorphic_matcher) {
- return Matcher<T>(polymorphic_matcher);
- }
- // This overload handles monomorphic matchers.
- //
- // In general, if type T can be implicitly converted to type U, we can
- // safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
- // contravariant): just keep a copy of the original Matcher<U>, convert the
- // argument from type T to U, and then pass it to the underlying Matcher<U>.
- // The only exception is when U is a reference and T is not, as the
- // underlying Matcher<U> may be interested in the argument's address, which
- // is not preserved in the conversion from T to U.
- template <typename U>
- static inline Matcher<T> Cast(const Matcher<U>& matcher) {
- // Enforce that T can be implicitly converted to U.
- GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
- T_must_be_implicitly_convertible_to_U);
- // Enforce that we are not converting a non-reference type T to a reference
- // type U.
- GTEST_COMPILE_ASSERT_(
- internal::is_reference<T>::value || !internal::is_reference<U>::value,
- cannot_convert_non_referentce_arg_to_reference);
- // In case both T and U are arithmetic types, enforce that the
- // conversion is not lossy.
- typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
- typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
- const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
- const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
- GTEST_COMPILE_ASSERT_(
- kTIsOther || kUIsOther ||
- (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
- conversion_of_arithmetic_types_must_be_lossless);
- return MatcherCast<T>(matcher);
- }
- };
- template <typename T, typename M>
- inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
- return SafeMatcherCastImpl<T>::Cast(polymorphic_matcher);
- }
- // A<T>() returns a matcher that matches any value of type T.
- template <typename T>
- Matcher<T> A();
- // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
- // and MUST NOT BE USED IN USER CODE!!!
- namespace internal {
- // If the explanation is not empty, prints it to the ostream.
- inline void PrintIfNotEmpty(const internal::string& explanation,
- std::ostream* os) {
- if (explanation != "" && os != NULL) {
- *os << ", " << explanation;
- }
- }
- // Returns true if the given type name is easy to read by a human.
- // This is used to decide whether printing the type of a value might
- // be helpful.
- inline bool IsReadableTypeName(const string& type_name) {
- // We consider a type name readable if it's short or doesn't contain
- // a template or function type.
- return (type_name.length() <= 20 ||
- type_name.find_first_of("<(") == string::npos);
- }
- // Matches the value against the given matcher, prints the value and explains
- // the match result to the listener. Returns the match result.
- // 'listener' must not be NULL.
- // Value cannot be passed by const reference, because some matchers take a
- // non-const argument.
- template <typename Value, typename T>
- bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
- MatchResultListener* listener) {
- if (!listener->IsInterested()) {
- // If the listener is not interested, we do not need to construct the
- // inner explanation.
- return matcher.Matches(value);
- }
- StringMatchResultListener inner_listener;
- const bool match = matcher.MatchAndExplain(value, &inner_listener);
- UniversalPrint(value, listener->stream());
- #if GTEST_HAS_RTTI
- const string& type_name = GetTypeName<Value>();
- if (IsReadableTypeName(type_name))
- *listener->stream() << " (of type " << type_name << ")";
- #endif
- PrintIfNotEmpty(inner_listener.str(), listener->stream());
- return match;
- }
- // An internal helper class for doing compile-time loop on a tuple's
- // fields.
- template <size_t N>
- class TuplePrefix {
- public:
- // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
- // iff the first N fields of matcher_tuple matches the first N
- // fields of value_tuple, respectively.
- template <typename MatcherTuple, typename ValueTuple>
- static bool Matches(const MatcherTuple& matcher_tuple,
- const ValueTuple& value_tuple) {
- using ::std::tr1::get;
- return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple)
- && get<N - 1>(matcher_tuple).Matches(get<N - 1>(value_tuple));
- }
- // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
- // describes failures in matching the first N fields of matchers
- // against the first N fields of values. If there is no failure,
- // nothing will be streamed to os.
- template <typename MatcherTuple, typename ValueTuple>
- static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
- const ValueTuple& values,
- ::std::ostream* os) {
- using ::std::tr1::tuple_element;
- using ::std::tr1::get;
- // First, describes failures in the first N - 1 fields.
- TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
- // Then describes the failure (if any) in the (N - 1)-th (0-based)
- // field.
- typename tuple_element<N - 1, MatcherTuple>::type matcher =
- get<N - 1>(matchers);
- typedef typename tuple_element<N - 1, ValueTuple>::type Value;
- Value value = get<N - 1>(values);
- StringMatchResultListener listener;
- if (!matcher.MatchAndExplain(value, &listener)) {
- // TODO(wan): include in the message the name of the parameter
- // as used in MOCK_METHOD*() when possible.
- *os << " Expected arg #" << N - 1 << ": ";
- get<N - 1>(matchers).DescribeTo(os);
- *os << "\n Actual: ";
- // We remove the reference in type Value to prevent the
- // universal printer from printing the address of value, which
- // isn't interesting to the user most of the time. The
- // matcher's MatchAndExplain() method handles the case when
- // the address is interesting.
- internal::UniversalPrint(value, os);
- PrintIfNotEmpty(listener.str(), os);
- *os << "\n";
- }
- }
- };
- // The base case.
- template <>
- class TuplePrefix<0> {
- public:
- template <typename MatcherTuple, typename ValueTuple>
- static bool Matches(const MatcherTuple& /* matcher_tuple */,
- const ValueTuple& /* value_tuple */) {
- return true;
- }
- template <typename MatcherTuple, typename ValueTuple>
- static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
- const ValueTuple& /* values */,
- ::std::ostream* /* os */) {}
- };
- // TupleMatches(matcher_tuple, value_tuple) returns true iff all
- // matchers in matcher_tuple match the corresponding fields in
- // value_tuple. It is a compiler error if matcher_tuple and
- // value_tuple have different number of fields or incompatible field
- // types.
- template <typename MatcherTuple, typename ValueTuple>
- bool TupleMatches(const MatcherTuple& matcher_tuple,
- const ValueTuple& value_tuple) {
- using ::std::tr1::tuple_size;
- // Makes sure that matcher_tuple and value_tuple have the same
- // number of fields.
- GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
- tuple_size<ValueTuple>::value,
- matcher_and_value_have_different_numbers_of_fields);
- return TuplePrefix<tuple_size<ValueTuple>::value>::
- Matches(matcher_tuple, value_tuple);
- }
- // Describes failures in matching matchers against values. If there
- // is no failure, nothing will be streamed to os.
- template <typename MatcherTuple, typename ValueTuple>
- void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
- const ValueTuple& values,
- ::std::ostream* os) {
- using ::std::tr1::tuple_size;
- TuplePrefix<tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
- matchers, values, os);
- }
- // The MatcherCastImpl class template is a helper for implementing
- // MatcherCast(). We need this helper in order to partially
- // specialize the implementation of MatcherCast() (C++ allows
- // class/struct templates to be partially specialized, but not
- // function templates.).
- // This general version is used when MatcherCast()'s argument is a
- // polymorphic matcher (i.e. something that can be converted to a
- // Matcher but is not one yet; for example, Eq(value)).
- template <typename T, typename M>
- class MatcherCastImpl {
- public:
- static Matcher<T> Cast(M polymorphic_matcher) {
- return Matcher<T>(polymorphic_matcher);
- }
- };
- // This more specialized version is used when MatcherCast()'s argument
- // is already a Matcher. This only compiles when type T can be
- // statically converted to type U.
- template <typename T, typename U>
- class MatcherCastImpl<T, Matcher<U> > {
- public:
- static Matcher<T> Cast(const Matcher<U>& source_matcher) {
- return Matcher<T>(new Impl(source_matcher));
- }
- private:
- class Impl : public MatcherInterface<T> {
- public:
- explicit Impl(const Matcher<U>& source_matcher)
- : source_matcher_(source_matcher) {}
- // We delegate the matching logic to the source matcher.
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
- return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
- }
- virtual void DescribeTo(::std::ostream* os) const {
- source_matcher_.DescribeTo(os);
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- source_matcher_.DescribeNegationTo(os);
- }
- private:
- const Matcher<U> source_matcher_;
- GTEST_DISALLOW_ASSIGN_(Impl);
- };
- };
- // This even more specialized version is used for efficiently casting
- // a matcher to its own type.
- template <typename T>
- class MatcherCastImpl<T, Matcher<T> > {
- public:
- static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
- };
- // Implements A<T>().
- template <typename T>
- class AnyMatcherImpl : public MatcherInterface<T> {
- public:
- virtual bool MatchAndExplain(
- T /* x */, MatchResultListener* /* listener */) const { return true; }
- virtual void DescribeTo(::std::ostream* os) const { *os << "is anything"; }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- // This is mostly for completeness' safe, as it's not very useful
- // to write Not(A<bool>()). However we cannot completely rule out
- // such a possibility, and it doesn't hurt to be prepared.
- *os << "never matches";
- }
- };
- // Implements _, a matcher that matches any value of any
- // type. This is a polymorphic matcher, so we need a template type
- // conversion operator to make it appearing as a Matcher<T> for any
- // type T.
- class AnythingMatcher {
- public:
- template <typename T>
- operator Matcher<T>() const { return A<T>(); }
- };
- // Implements a matcher that compares a given value with a
- // pre-supplied value using one of the ==, <=, <, etc, operators. The
- // two values being compared don't have to have the same type.
- //
- // The matcher defined here is polymorphic (for example, Eq(5) can be
- // used to match an int, a short, a double, etc). Therefore we use
- // a template type conversion operator in the implementation.
- //
- // We define this as a macro in order to eliminate duplicated source
- // code.
- //
- // The following template definition assumes that the Rhs parameter is
- // a "bare" type (i.e. neither 'const T' nor 'T&').
- #define GMOCK_IMPLEMENT_COMPARISON_MATCHER_( \
- name, op, relation, negated_relation) \
- template <typename Rhs> class name##Matcher { \
- public: \
- explicit name##Matcher(const Rhs& rhs) : rhs_(rhs) {} \
- template <typename Lhs> \
- operator Matcher<Lhs>() const { \
- return MakeMatcher(new Impl<Lhs>(rhs_)); \
- } \
- private: \
- template <typename Lhs> \
- class Impl : public MatcherInterface<Lhs> { \
- public: \
- explicit Impl(const Rhs& rhs) : rhs_(rhs) {} \
- virtual bool MatchAndExplain(\
- Lhs lhs, MatchResultListener* /* listener */) const { \
- return lhs op rhs_; \
- } \
- virtual void DescribeTo(::std::ostream* os) const { \
- *os << relation " "; \
- UniversalPrint(rhs_, os); \
- } \
- virtual void DescribeNegationTo(::std::ostream* os) const { \
- *os << negated_relation " "; \
- UniversalPrint(rhs_, os); \
- } \
- private: \
- Rhs rhs_; \
- GTEST_DISALLOW_ASSIGN_(Impl); \
- }; \
- Rhs rhs_; \
- GTEST_DISALLOW_ASSIGN_(name##Matcher); \
- }
- // Implements Eq(v), Ge(v), Gt(v), Le(v), Lt(v), and Ne(v)
- // respectively.
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Eq, ==, "is equal to", "isn't equal to");
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Ge, >=, "is >=", "isn't >=");
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Gt, >, "is >", "isn't >");
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Le, <=, "is <=", "isn't <=");
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Lt, <, "is <", "isn't <");
- GMOCK_IMPLEMENT_COMPARISON_MATCHER_(Ne, !=, "isn't equal to", "is equal to");
- #undef GMOCK_IMPLEMENT_COMPARISON_MATCHER_
- // Implements the polymorphic IsNull() matcher, which matches any raw or smart
- // pointer that is NULL.
- class IsNullMatcher {
- public:
- template <typename Pointer>
- bool MatchAndExplain(const Pointer& p,
- MatchResultListener* /* listener */) const {
- return GetRawPointer(p) == NULL;
- }
- void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "isn't NULL";
- }
- };
- // Implements the polymorphic NotNull() matcher, which matches any raw or smart
- // pointer that is not NULL.
- class NotNullMatcher {
- public:
- template <typename Pointer>
- bool MatchAndExplain(const Pointer& p,
- MatchResultListener* /* listener */) const {
- return GetRawPointer(p) != NULL;
- }
- void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "is NULL";
- }
- };
- // Ref(variable) matches any argument that is a reference to
- // 'variable'. This matcher is polymorphic as it can match any
- // super type of the type of 'variable'.
- //
- // The RefMatcher template class implements Ref(variable). It can
- // only be instantiated with a reference type. This prevents a user
- // from mistakenly using Ref(x) to match a non-reference function
- // argument. For example, the following will righteously cause a
- // compiler error:
- //
- // int n;
- // Matcher<int> m1 = Ref(n); // This won't compile.
- // Matcher<int&> m2 = Ref(n); // This will compile.
- template <typename T>
- class RefMatcher;
- template <typename T>
- class RefMatcher<T&> {
- // Google Mock is a generic framework and thus needs to support
- // mocking any function types, including those that take non-const
- // reference arguments. Therefore the template parameter T (and
- // Super below) can be instantiated to either a const type or a
- // non-const type.
- public:
- // RefMatcher() takes a T& instead of const T&, as we want the
- // compiler to catch using Ref(const_value) as a matcher for a
- // non-const reference.
- explicit RefMatcher(T& x) : object_(x) {} // NOLINT
- template <typename Super>
- operator Matcher<Super&>() const {
- // By passing object_ (type T&) to Impl(), which expects a Super&,
- // we make sure that Super is a super type of T. In particular,
- // this catches using Ref(const_value) as a matcher for a
- // non-const reference, as you cannot implicitly convert a const
- // reference to a non-const reference.
- return MakeMatcher(new Impl<Super>(object_));
- }
- private:
- template <typename Super>
- class Impl : public MatcherInterface<Super&> {
- public:
- explicit Impl(Super& x) : object_(x) {} // NOLINT
- // MatchAndExplain() takes a Super& (as opposed to const Super&)
- // in order to match the interface MatcherInterface<Super&>.
- virtual bool MatchAndExplain(
- Super& x, MatchResultListener* listener) const {
- *listener << "which is located @" << static_cast<const void*>(&x);
- return &x == &object_;
- }
- virtual void DescribeTo(::std::ostream* os) const {
- *os << "references the variable ";
- UniversalPrinter<Super&>::Print(object_, os);
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- *os << "does not reference the variable ";
- UniversalPrinter<Super&>::Print(object_, os);
- }
- private:
- const Super& object_;
- GTEST_DISALLOW_ASSIGN_(Impl);
- };
- T& object_;
- GTEST_DISALLOW_ASSIGN_(RefMatcher);
- };
- // Polymorphic helper functions for narrow and wide string matchers.
- inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
- return String::CaseInsensitiveCStringEquals(lhs, rhs);
- }
- inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
- const wchar_t* rhs) {
- return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
- }
- // String comparison for narrow or wide strings that can have embedded NUL
- // characters.
- template <typename StringType>
- bool CaseInsensitiveStringEquals(const StringType& s1,
- const StringType& s2) {
- // Are the heads equal?
- if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
- return false;
- }
- // Skip the equal heads.
- const typename StringType::value_type nul = 0;
- const size_t i1 = s1.find(nul), i2 = s2.find(nul);
- // Are we at the end of either s1 or s2?
- if (i1 == StringType::npos || i2 == StringType::npos) {
- return i1 == i2;
- }
- // Are the tails equal?
- return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
- }
- // String matchers.
- // Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
- template <typename StringType>
- class StrEqualityMatcher {
- public:
- typedef typename StringType::const_pointer ConstCharPointer;
- StrEqualityMatcher(const StringType& str, bool expect_eq,
- bool case_sensitive)
- : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
- // When expect_eq_ is true, returns true iff s is equal to string_;
- // otherwise returns true iff s is not equal to string_.
- bool MatchAndExplain(ConstCharPointer s,
- MatchResultListener* listener) const {
- if (s == NULL) {
- return !expect_eq_;
- }
- return MatchAndExplain(StringType(s), listener);
- }
- bool MatchAndExplain(const StringType& s,
- MatchResultListener* /* listener */) const {
- const bool eq = case_sensitive_ ? s == string_ :
- CaseInsensitiveStringEquals(s, string_);
- return expect_eq_ == eq;
- }
- void DescribeTo(::std::ostream* os) const {
- DescribeToHelper(expect_eq_, os);
- }
- void DescribeNegationTo(::std::ostream* os) const {
- DescribeToHelper(!expect_eq_, os);
- }
- private:
- void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
- *os << (expect_eq ? "is " : "isn't ");
- *os << "equal to ";
- if (!case_sensitive_) {
- *os << "(ignoring case) ";
- }
- UniversalPrint(string_, os);
- }
- const StringType string_;
- const bool expect_eq_;
- const bool case_sensitive_;
- GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
- };
- // Implements the polymorphic HasSubstr(substring) matcher, which
- // can be used as a Matcher<T> as long as T can be converted to a
- // string.
- template <typename StringType>
- class HasSubstrMatcher {
- public:
- typedef typename StringType::const_pointer ConstCharPointer;
- explicit HasSubstrMatcher(const StringType& substring)
- : substring_(substring) {}
- // These overloaded methods allow HasSubstr(substring) to be used as a
- // Matcher<T> as long as T can be converted to string. Returns true
- // iff s contains substring_ as a substring.
- bool MatchAndExplain(ConstCharPointer s,
- MatchResultListener* listener) const {
- return s != NULL && MatchAndExplain(StringType(s), listener);
- }
- bool MatchAndExplain(const StringType& s,
- MatchResultListener* /* listener */) const {
- return s.find(substring_) != StringType::npos;
- }
- // Describes what this matcher matches.
- void DescribeTo(::std::ostream* os) const {
- *os << "has substring ";
- UniversalPrint(substring_, os);
- }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "has no substring ";
- UniversalPrint(substring_, os);
- }
- private:
- const StringType substring_;
- GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
- };
- // Implements the polymorphic StartsWith(substring) matcher, which
- // can be used as a Matcher<T> as long as T can be converted to a
- // string.
- template <typename StringType>
- class StartsWithMatcher {
- public:
- typedef typename StringType::const_pointer ConstCharPointer;
- explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
- }
- // These overloaded methods allow StartsWith(prefix) to be used as a
- // Matcher<T> as long as T can be converted to string. Returns true
- // iff s starts with prefix_.
- bool MatchAndExplain(ConstCharPointer s,
- MatchResultListener* listener) const {
- return s != NULL && MatchAndExplain(StringType(s), listener);
- }
- bool MatchAndExplain(const StringType& s,
- MatchResultListener* /* listener */) const {
- return s.length() >= prefix_.length() &&
- s.substr(0, prefix_.length()) == prefix_;
- }
- void DescribeTo(::std::ostream* os) const {
- *os << "starts with ";
- UniversalPrint(prefix_, os);
- }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "doesn't start with ";
- UniversalPrint(prefix_, os);
- }
- private:
- const StringType prefix_;
- GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
- };
- // Implements the polymorphic EndsWith(substring) matcher, which
- // can be used as a Matcher<T> as long as T can be converted to a
- // string.
- template <typename StringType>
- class EndsWithMatcher {
- public:
- typedef typename StringType::const_pointer ConstCharPointer;
- explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
- // These overloaded methods allow EndsWith(suffix) to be used as a
- // Matcher<T> as long as T can be converted to string. Returns true
- // iff s ends with suffix_.
- bool MatchAndExplain(ConstCharPointer s,
- MatchResultListener* listener) const {
- return s != NULL && MatchAndExplain(StringType(s), listener);
- }
- bool MatchAndExplain(const StringType& s,
- MatchResultListener* /* listener */) const {
- return s.length() >= suffix_.length() &&
- s.substr(s.length() - suffix_.length()) == suffix_;
- }
- void DescribeTo(::std::ostream* os) const {
- *os << "ends with ";
- UniversalPrint(suffix_, os);
- }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "doesn't end with ";
- UniversalPrint(suffix_, os);
- }
- private:
- const StringType suffix_;
- GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
- };
- // Implements polymorphic matchers MatchesRegex(regex) and
- // ContainsRegex(regex), which can be used as a Matcher<T> as long as
- // T can be converted to a string.
- class MatchesRegexMatcher {
- public:
- MatchesRegexMatcher(const RE* regex, bool full_match)
- : regex_(regex), full_match_(full_match) {}
- // These overloaded methods allow MatchesRegex(regex) to be used as
- // a Matcher<T> as long as T can be converted to string. Returns
- // true iff s matches regular expression regex. When full_match_ is
- // true, a full match is done; otherwise a partial match is done.
- bool MatchAndExplain(const char* s,
- MatchResultListener* listener) const {
- return s != NULL && MatchAndExplain(internal::string(s), listener);
- }
- bool MatchAndExplain(const internal::string& s,
- MatchResultListener* /* listener */) const {
- return full_match_ ? RE::FullMatch(s, *regex_) :
- RE::PartialMatch(s, *regex_);
- }
- void DescribeTo(::std::ostream* os) const {
- *os << (full_match_ ? "matches" : "contains")
- << " regular expression ";
- UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
- }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "doesn't " << (full_match_ ? "match" : "contain")
- << " regular expression ";
- UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
- }
- private:
- const internal::linked_ptr<const RE> regex_;
- const bool full_match_;
- GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
- };
- // Implements a matcher that compares the two fields of a 2-tuple
- // using one of the ==, <=, <, etc, operators. The two fields being
- // compared don't have to have the same type.
- //
- // The matcher defined here is polymorphic (for example, Eq() can be
- // used to match a tuple<int, short>, a tuple<const long&, double>,
- // etc). Therefore we use a template type conversion operator in the
- // implementation.
- //
- // We define this as a macro in order to eliminate duplicated source
- // code.
- #define GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(name, op, relation) \
- class name##2Matcher { \
- public: \
- template <typename T1, typename T2> \
- operator Matcher< ::std::tr1::tuple<T1, T2> >() const { \
- return MakeMatcher(new Impl< ::std::tr1::tuple<T1, T2> >); \
- } \
- template <typename T1, typename T2> \
- operator Matcher<const ::std::tr1::tuple<T1, T2>&>() const { \
- return MakeMatcher(new Impl<const ::std::tr1::tuple<T1, T2>&>); \
- } \
- private: \
- template <typename Tuple> \
- class Impl : public MatcherInterface<Tuple> { \
- public: \
- virtual bool MatchAndExplain( \
- Tuple args, \
- MatchResultListener* /* listener */) const { \
- return ::std::tr1::get<0>(args) op ::std::tr1::get<1>(args); \
- } \
- virtual void DescribeTo(::std::ostream* os) const { \
- *os << "are " relation; \
- } \
- virtual void DescribeNegationTo(::std::ostream* os) const { \
- *os << "aren't " relation; \
- } \
- }; \
- }
- // Implements Eq(), Ge(), Gt(), Le(), Lt(), and Ne() respectively.
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(Eq, ==, "an equal pair");
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(
- Ge, >=, "a pair where the first >= the second");
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(
- Gt, >, "a pair where the first > the second");
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(
- Le, <=, "a pair where the first <= the second");
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(
- Lt, <, "a pair where the first < the second");
- GMOCK_IMPLEMENT_COMPARISON2_MATCHER_(Ne, !=, "an unequal pair");
- #undef GMOCK_IMPLEMENT_COMPARISON2_MATCHER_
- // Implements the Not(...) matcher for a particular argument type T.
- // We do not nest it inside the NotMatcher class template, as that
- // will prevent different instantiations of NotMatcher from sharing
- // the same NotMatcherImpl<T> class.
- template <typename T>
- class NotMatcherImpl : public MatcherInterface<T> {
- public:
- explicit NotMatcherImpl(const Matcher<T>& matcher)
- : matcher_(matcher) {}
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
- return !matcher_.MatchAndExplain(x, listener);
- }
- virtual void DescribeTo(::std::ostream* os) const {
- matcher_.DescribeNegationTo(os);
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- matcher_.DescribeTo(os);
- }
- private:
- const Matcher<T> matcher_;
- GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
- };
- // Implements the Not(m) matcher, which matches a value that doesn't
- // match matcher m.
- template <typename InnerMatcher>
- class NotMatcher {
- public:
- explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
- // This template type conversion operator allows Not(m) to be used
- // to match any type m can match.
- template <typename T>
- operator Matcher<T>() const {
- return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
- }
- private:
- InnerMatcher matcher_;
- GTEST_DISALLOW_ASSIGN_(NotMatcher);
- };
- // Implements the AllOf(m1, m2) matcher for a particular argument type
- // T. We do not nest it inside the BothOfMatcher class template, as
- // that will prevent different instantiations of BothOfMatcher from
- // sharing the same BothOfMatcherImpl<T> class.
- template <typename T>
- class BothOfMatcherImpl : public MatcherInterface<T> {
- public:
- BothOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
- : matcher1_(matcher1), matcher2_(matcher2) {}
- virtual void DescribeTo(::std::ostream* os) const {
- *os << "(";
- matcher1_.DescribeTo(os);
- *os << ") and (";
- matcher2_.DescribeTo(os);
- *os << ")";
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- *os << "(";
- matcher1_.DescribeNegationTo(os);
- *os << ") or (";
- matcher2_.DescribeNegationTo(os);
- *os << ")";
- }
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
- // If either matcher1_ or matcher2_ doesn't match x, we only need
- // to explain why one of them fails.
- StringMatchResultListener listener1;
- if (!matcher1_.MatchAndExplain(x, &listener1)) {
- *listener << listener1.str();
- return false;
- }
- StringMatchResultListener listener2;
- if (!matcher2_.MatchAndExplain(x, &listener2)) {
- *listener << listener2.str();
- return false;
- }
- // Otherwise we need to explain why *both* of them match.
- const internal::string s1 = listener1.str();
- const internal::string s2 = listener2.str();
- if (s1 == "") {
- *listener << s2;
- } else {
- *listener << s1;
- if (s2 != "") {
- *listener << ", and " << s2;
- }
- }
- return true;
- }
- private:
- const Matcher<T> matcher1_;
- const Matcher<T> matcher2_;
- GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
- };
- // Used for implementing the AllOf(m_1, ..., m_n) matcher, which
- // matches a value that matches all of the matchers m_1, ..., and m_n.
- template <typename Matcher1, typename Matcher2>
- class BothOfMatcher {
- public:
- BothOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
- : matcher1_(matcher1), matcher2_(matcher2) {}
- // This template type conversion operator allows a
- // BothOfMatcher<Matcher1, Matcher2> object to match any type that
- // both Matcher1 and Matcher2 can match.
- template <typename T>
- operator Matcher<T>() const {
- return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
- SafeMatcherCast<T>(matcher2_)));
- }
- private:
- Matcher1 matcher1_;
- Matcher2 matcher2_;
- GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
- };
- // Implements the AnyOf(m1, m2) matcher for a particular argument type
- // T. We do not nest it inside the AnyOfMatcher class template, as
- // that will prevent different instantiations of AnyOfMatcher from
- // sharing the same EitherOfMatcherImpl<T> class.
- template <typename T>
- class EitherOfMatcherImpl : public MatcherInterface<T> {
- public:
- EitherOfMatcherImpl(const Matcher<T>& matcher1, const Matcher<T>& matcher2)
- : matcher1_(matcher1), matcher2_(matcher2) {}
- virtual void DescribeTo(::std::ostream* os) const {
- *os << "(";
- matcher1_.DescribeTo(os);
- *os << ") or (";
- matcher2_.DescribeTo(os);
- *os << ")";
- }
- virtual void DescribeNegationTo(::std::ostream* os) const {
- *os << "(";
- matcher1_.DescribeNegationTo(os);
- *os << ") and (";
- matcher2_.DescribeNegationTo(os);
- *os << ")";
- }
- virtual bool MatchAndExplain(T x, MatchResultListener* listener) const {
- // If either matcher1_ or matcher2_ matches x, we just need to
- // explain why *one* of them matches.
- StringMatchResultListener listener1;
- if (matcher1_.MatchAndExplain(x, &listener1)) {
- *listener << listener1.str();
- return true;
- }
- StringMatchResultListener listener2;
- if (matcher2_.MatchAndExplain(x, &listener2)) {
- *listener << listener2.str();
- return true;
- }
- // Otherwise we need to explain why *both* of them fail.
- const internal::string s1 = listener1.str();
- const internal::string s2 = listener2.str();
- if (s1 == "") {
- *listener << s2;
- } else {
- *listener << s1;
- if (s2 != "") {
- *listener << ", and " << s2;
- }
- }
- return false;
- }
- private:
- const Matcher<T> matcher1_;
- const Matcher<T> matcher2_;
- GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
- };
- // Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
- // matches a value that matches at least one of the matchers m_1, ...,
- // and m_n.
- template <typename Matcher1, typename Matcher2>
- class EitherOfMatcher {
- public:
- EitherOfMatcher(Matcher1 matcher1, Matcher2 matcher2)
- : matcher1_(matcher1), matcher2_(matcher2) {}
- // This template type conversion operator allows a
- // EitherOfMatcher<Matcher1, Matcher2> object to match any type that
- // both Matcher1 and Matcher2 can match.
- template <typename T>
- operator Matcher<T>() const {
- return Matcher<T>(new EitherOfMatcherImpl<T>(
- SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
- }
- private:
- Matcher1 matcher1_;
- Matcher2 matcher2_;
- GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
- };
- // Used for implementing Truly(pred), which turns a predicate into a
- // matcher.
- template <typename Predicate>
- class TrulyMatcher {
- public:
- explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
- // This method template allows Truly(pred) to be used as a matcher
- // for type T where T is the argument type of predicate 'pred'. The
- // argument is passed by reference as the predicate may be
- // interested in the address of the argument.
- template <typename T>
- bool MatchAndExplain(T& x, // NOLINT
- MatchResultListener* /* listener */) const {
- // Without the if-statement, MSVC sometimes warns about converting
- // a value to bool (warning 4800).
- //
- // We cannot write 'return !!predicate_(x);' as that doesn't work
- // when predicate_(x) returns a class convertible to bool but
- // having no operator!().
- if (predicate_(x))
- return true;
- return false;
- }
- void DescribeTo(::std::ostream* os) const {
- *os << "satisfies the given predicate";
- }
- void DescribeNegationTo(::std::ostream* os) const {
- *os << "doesn't satisfy the given predicate";
- }
- private:
- Predicate predicate_;
- GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
- };
- // Used for implementing Matches(matcher), which turns a matcher into
- // a predicate.
- template <typename M>
- class MatcherAsPredicate {
- public:
- explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
- // This template operator() allows Matches(m) to be used as a
- // predicate on type T where m is a matcher on type T.
- //
- // The argument x is passed by reference instead of by value, as
- // some matcher may be interested in its address (e.g. as in
- // Matches(Ref(n))(x)).
- template <typename T>
- bool operator()(const T& x) const {
- // We let matcher_ commit to a particular type here instead of
- // when the MatcherAsPredicate object was constructed. This
- // allows us to write Matches(m) where m is a polymorphic matcher
- // (e.g. Eq(5)).
- //
- // If we write Matcher<T>(matcher_).Matches(x) here, it won't
- // compile when matcher_ has type Matcher<const T&>; if we write
- // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
- // when matcher_ h…