text: // 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.
  
  // Google Mock - a framework for writing C++ mock classes.
  //
  // This file tests some commonly used argument matchers.
  
  // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
  // possible loss of data and C4100, unreferenced local parameter
  #ifdef _MSC_VER
  #pragma warning(push)
  #pragma warning(disable : 4244)
  #pragma warning(disable : 4100)
  #endif
  
  #include "test/gmock-matchers_test.h"
  
  namespace testing {
  namespace gmock_matchers_test {
  namespace {
  
  TEST(MonotonicMatcherTest, IsPrintable) {
    stringstream ss;
    ss << GreaterThan(5);
    EXPECT_EQ("is > 5", ss.str());
  }
  
  TEST(MatchResultListenerTest, StreamingWorks) {
    StringMatchResultListener listener;
    listener << "hi" << 5;
    EXPECT_EQ("hi5", listener.str());
  
    listener.Clear();
    EXPECT_EQ("", listener.str());
  
    listener << 42;
    EXPECT_EQ("42", listener.str());
  
    // Streaming shouldn't crash when the underlying ostream is NULL.
    DummyMatchResultListener dummy;
    dummy << "hi" << 5;
  }
  
  TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
    EXPECT_TRUE(DummyMatchResultListener().stream() == nullptr);
    EXPECT_TRUE(StreamMatchResultListener(nullptr).stream() == nullptr);
  
    EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
  }
  
  TEST(MatchResultListenerTest, IsInterestedWorks) {
    EXPECT_TRUE(StringMatchResultListener().IsInterested());
    EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
  
    EXPECT_FALSE(DummyMatchResultListener().IsInterested());
    EXPECT_FALSE(StreamMatchResultListener(nullptr).IsInterested());
  }
  
  // Makes sure that the MatcherInterface<T> interface doesn't
  // change.
  class EvenMatcherImpl : public MatcherInterface<int> {
   public:
    bool MatchAndExplain(int x,
                         MatchResultListener* /* listener */) const override {
      return x % 2 == 0;
    }
  
    void DescribeTo(ostream* os) const override { *os << "is an even number"; }
  
    // We deliberately don't define DescribeNegationTo() and
    // ExplainMatchResultTo() here, to make sure the definition of these
    // two methods is optional.
  };
  
  // Makes sure that the MatcherInterface API doesn't change.
  TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
    EvenMatcherImpl m;
  }
  
  // Tests implementing a monomorphic matcher using MatchAndExplain().
  
  class NewEvenMatcherImpl : public MatcherInterface<int> {
   public:
    bool MatchAndExplain(int x, MatchResultListener* listener) const override {
      const bool match = x % 2 == 0;
      // Verifies that we can stream to a listener directly.
      *listener << "value % " << 2;
      if (listener->stream() != nullptr) {
        // Verifies that we can stream to a listener's underlying stream
        // too.
        *listener->stream() << " == " << (x % 2);
      }
      return match;
    }
  
    void DescribeTo(ostream* os) const override { *os << "is an even number"; }
  };
  
  TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
    Matcher<int> m = MakeMatcher(new NewEvenMatcherImpl);
    EXPECT_TRUE(m.Matches(2));
    EXPECT_FALSE(m.Matches(3));
    EXPECT_EQ("value % 2 == 0", Explain(m, 2));
    EXPECT_EQ("value % 2 == 1", Explain(m, 3));
  }
  
  // Tests default-constructing a matcher.
  TEST(MatcherTest, CanBeDefaultConstructed) { Matcher<double> m; }
  
  // Tests that Matcher<T> can be constructed from a MatcherInterface<T>*.
  TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
    const MatcherInterface<int>* impl = new EvenMatcherImpl;
    Matcher<int> m(impl);
    EXPECT_TRUE(m.Matches(4));
    EXPECT_FALSE(m.Matches(5));
  }
  
  // Tests that value can be used in place of Eq(value).
  TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
    Matcher<int> m1 = 5;
    EXPECT_TRUE(m1.Matches(5));
    EXPECT_FALSE(m1.Matches(6));
  }
  
  // Tests that NULL can be used in place of Eq(NULL).
  TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
    Matcher<int*> m1 = nullptr;
    EXPECT_TRUE(m1.Matches(nullptr));
    int n = 0;
    EXPECT_FALSE(m1.Matches(&n));
  }
  
  // Tests that matchers can be constructed from a variable that is not properly
  // defined. This should be illegal, but many users rely on this accidentally.
  struct Undefined {
    virtual ~Undefined() = 0;
    static const int kInt = 1;
  };
  
  TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
    Matcher<int> m1 = Undefined::kInt;
    EXPECT_TRUE(m1.Matches(1));
    EXPECT_FALSE(m1.Matches(2));
  }
  
  // Test that a matcher parameterized with an abstract class compiles.
  TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&> m = _; }
  
  // Tests that matchers are copyable.
  TEST(MatcherTest, IsCopyable) {
    // Tests the copy constructor.
    Matcher<bool> m1 = Eq(false);
    EXPECT_TRUE(m1.Matches(false));
    EXPECT_FALSE(m1.Matches(true));
  
    // Tests the assignment operator.
    m1 = Eq(true);
    EXPECT_TRUE(m1.Matches(true));
    EXPECT_FALSE(m1.Matches(false));
  }
  
  // Tests that Matcher<T>::DescribeTo() calls
  // MatcherInterface<T>::DescribeTo().
  TEST(MatcherTest, CanDescribeItself) {
    EXPECT_EQ("is an even number", Describe(Matcher<int>(new EvenMatcherImpl)));
  }
  
  // Tests Matcher<T>::MatchAndExplain().
  TEST(MatcherTest, MatchAndExplain) {
    Matcher<int> m = GreaterThan(0);
    StringMatchResultListener listener1;
    EXPECT_TRUE(m.MatchAndExplain(42, &listener1));
    EXPECT_EQ("which is 42 more than 0", listener1.str());
  
    StringMatchResultListener listener2;
    EXPECT_FALSE(m.MatchAndExplain(-9, &listener2));
    EXPECT_EQ("which is 9 less than 0", listener2.str());
  }
  
  // Tests that a C-string literal can be implicitly converted to a
  // Matcher<std::string> or Matcher<const std::string&>.
  TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
    Matcher<std::string> m1 = "hi";
    EXPECT_TRUE(m1.Matches("hi"));
    EXPECT_FALSE(m1.Matches("hello"));
  
    Matcher<const std::string&> m2 = "hi";
    EXPECT_TRUE(m2.Matches("hi"));
    EXPECT_FALSE(m2.Matches("hello"));
  }
  
  // Tests that a string object can be implicitly converted to a
  // Matcher<std::string> or Matcher<const std::string&>.
  TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
    Matcher<std::string> m1 = std::string("hi");
    EXPECT_TRUE(m1.Matches("hi"));
    EXPECT_FALSE(m1.Matches("hello"));
  
    Matcher<const std::string&> m2 = std::string("hi");
    EXPECT_TRUE(m2.Matches("hi"));
    EXPECT_FALSE(m2.Matches("hello"));
  }
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
  // Tests that a C-string literal can be implicitly converted to a
  // Matcher<StringView> or Matcher<const StringView&>.
  TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
    Matcher<internal::StringView> m1 = "cats";
    EXPECT_TRUE(m1.Matches("cats"));
    EXPECT_FALSE(m1.Matches("dogs"));
  
    Matcher<const internal::StringView&> m2 = "cats";
    EXPECT_TRUE(m2.Matches("cats"));
    EXPECT_FALSE(m2.Matches("dogs"));
  }
  
  // Tests that a std::string object can be implicitly converted to a
  // Matcher<StringView> or Matcher<const StringView&>.
  TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
    Matcher<internal::StringView> m1 = std::string("cats");
    EXPECT_TRUE(m1.Matches("cats"));
    EXPECT_FALSE(m1.Matches("dogs"));
  
    Matcher<const internal::StringView&> m2 = std::string("cats");
    EXPECT_TRUE(m2.Matches("cats"));
    EXPECT_FALSE(m2.Matches("dogs"));
  }
  
  // Tests that a StringView object can be implicitly converted to a
  // Matcher<StringView> or Matcher<const StringView&>.
  TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
    Matcher<internal::StringView> m1 = internal::StringView("cats");
    EXPECT_TRUE(m1.Matches("cats"));
    EXPECT_FALSE(m1.Matches("dogs"));
  
    Matcher<const internal::StringView&> m2 = internal::StringView("cats");
    EXPECT_TRUE(m2.Matches("cats"));
    EXPECT_FALSE(m2.Matches("dogs"));
  }
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  
  // Tests that a std::reference_wrapper<std::string> object can be implicitly
  // converted to a Matcher<std::string> or Matcher<const std::string&> via Eq().
  TEST(StringMatcherTest,
       CanBeImplicitlyConstructedFromEqReferenceWrapperString) {
    std::string value = "cats";
    Matcher<std::string> m1 = Eq(std::ref(value));
    EXPECT_TRUE(m1.Matches("cats"));
    EXPECT_FALSE(m1.Matches("dogs"));
  
    Matcher<const std::string&> m2 = Eq(std::ref(value));
    EXPECT_TRUE(m2.Matches("cats"));
    EXPECT_FALSE(m2.Matches("dogs"));
  }
  
  // Tests that MakeMatcher() constructs a Matcher<T> from a
  // MatcherInterface* without requiring the user to explicitly
  // write the type.
  TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
    const MatcherInterface<int>* dummy_impl = new EvenMatcherImpl;
    Matcher<int> m = MakeMatcher(dummy_impl);
  }
  
  // Tests that MakePolymorphicMatcher() can construct a polymorphic
  // matcher from its implementation using the old API.
  const int g_bar = 1;
  class ReferencesBarOrIsZeroImpl {
   public:
    template <typename T>
    bool MatchAndExplain(const T& x, MatchResultListener* /* listener */) const {
      const void* p = &x;
      return p == &g_bar || x == 0;
    }
  
    void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
  
    void DescribeNegationTo(ostream* os) const {
      *os << "doesn't reference g_bar and is not zero";
    }
  };
  
  // This function verifies that MakePolymorphicMatcher() returns a
  // PolymorphicMatcher<T> where T is the argument's type.
  PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
    return MakePolymorphicMatcher(ReferencesBarOrIsZeroImpl());
  }
  
  TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
    // Using a polymorphic matcher to match a reference type.
    Matcher<const int&> m1 = ReferencesBarOrIsZero();
    EXPECT_TRUE(m1.Matches(0));
    // Verifies that the identity of a by-reference argument is preserved.
    EXPECT_TRUE(m1.Matches(g_bar));
    EXPECT_FALSE(m1.Matches(1));
    EXPECT_EQ("g_bar or zero", Describe(m1));
  
    // Using a polymorphic matcher to match a value type.
    Matcher<double> m2 = ReferencesBarOrIsZero();
    EXPECT_TRUE(m2.Matches(0.0));
    EXPECT_FALSE(m2.Matches(0.1));
    EXPECT_EQ("g_bar or zero", Describe(m2));
  }
  
  // Tests implementing a polymorphic matcher using MatchAndExplain().
  
  class PolymorphicIsEvenImpl {
   public:
    void DescribeTo(ostream* os) const { *os << "is even"; }
  
    void DescribeNegationTo(ostream* os) const { *os << "is odd"; }
  
    template <typename T>
    bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
      // Verifies that we can stream to the listener directly.
      *listener << "% " << 2;
      if (listener->stream() != nullptr) {
        // Verifies that we can stream to the listener's underlying stream
        // too.
        *listener->stream() << " == " << (x % 2);
      }
      return (x % 2) == 0;
    }
  };
  
  PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
    return MakePolymorphicMatcher(PolymorphicIsEvenImpl());
  }
  
  TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
    // Using PolymorphicIsEven() as a Matcher<int>.
    const Matcher<int> m1 = PolymorphicIsEven();
    EXPECT_TRUE(m1.Matches(42));
    EXPECT_FALSE(m1.Matches(43));
    EXPECT_EQ("is even", Describe(m1));
  
    const Matcher<int> not_m1 = Not(m1);
    EXPECT_EQ("is odd", Describe(not_m1));
  
    EXPECT_EQ("% 2 == 0", Explain(m1, 42));
  
    // Using PolymorphicIsEven() as a Matcher<char>.
    const Matcher<char> m2 = PolymorphicIsEven();
    EXPECT_TRUE(m2.Matches('\x42'));
    EXPECT_FALSE(m2.Matches('\x43'));
    EXPECT_EQ("is even", Describe(m2));
  
    const Matcher<char> not_m2 = Not(m2);
    EXPECT_EQ("is odd", Describe(not_m2));
  
    EXPECT_EQ("% 2 == 0", Explain(m2, '\x42'));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a polymorphic matcher.
  TEST(MatcherCastTest, FromPolymorphicMatcher) {
    Matcher<int> m = MatcherCast<int>(Eq(5));
    EXPECT_TRUE(m.Matches(5));
    EXPECT_FALSE(m.Matches(6));
  }
  
  // For testing casting matchers between compatible types.
  class IntValue {
   public:
    // An int can be statically (although not implicitly) cast to a
    // IntValue.
    explicit IntValue(int a_value) : value_(a_value) {}
  
    int value() const { return value_; }
  
   private:
    int value_;
  };
  
  // For testing casting matchers between compatible types.
  bool IsPositiveIntValue(const IntValue& foo) { return foo.value() > 0; }
  
  // Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
  // can be statically converted to U.
  TEST(MatcherCastTest, FromCompatibleType) {
    Matcher<double> m1 = Eq(2.0);
    Matcher<int> m2 = MatcherCast<int>(m1);
    EXPECT_TRUE(m2.Matches(2));
    EXPECT_FALSE(m2.Matches(3));
  
    Matcher<IntValue> m3 = Truly(IsPositiveIntValue);
    Matcher<int> m4 = MatcherCast<int>(m3);
    // In the following, the arguments 1 and 0 are statically converted
    // to IntValue objects, and then tested by the IsPositiveIntValue()
    // predicate.
    EXPECT_TRUE(m4.Matches(1));
    EXPECT_FALSE(m4.Matches(0));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
  TEST(MatcherCastTest, FromConstReferenceToNonReference) {
    Matcher<const int&> m1 = Eq(0);
    Matcher<int> m2 = MatcherCast<int>(m1);
    EXPECT_TRUE(m2.Matches(0));
    EXPECT_FALSE(m2.Matches(1));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
  TEST(MatcherCastTest, FromReferenceToNonReference) {
    Matcher<int&> m1 = Eq(0);
    Matcher<int> m2 = MatcherCast<int>(m1);
    EXPECT_TRUE(m2.Matches(0));
    EXPECT_FALSE(m2.Matches(1));
  }
  
  // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
  TEST(MatcherCastTest, FromNonReferenceToConstReference) {
    Matcher<int> m1 = Eq(0);
    Matcher<const int&> m2 = MatcherCast<const int&>(m1);
    EXPECT_TRUE(m2.Matches(0));
    EXPECT_FALSE(m2.Matches(1));
  }
  
  // Tests that MatcherCast<T&>(m) works when m is a Matcher<T>.
  TEST(MatcherCastTest, FromNonReferenceToReference) {
    Matcher<int> m1 = Eq(0);
    Matcher<int&> m2 = MatcherCast<int&>(m1);
    int n = 0;
    EXPECT_TRUE(m2.Matches(n));
    n = 1;
    EXPECT_FALSE(m2.Matches(n));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a Matcher<T>.
  TEST(MatcherCastTest, FromSameType) {
    Matcher<int> m1 = Eq(0);
    Matcher<int> m2 = MatcherCast<int>(m1);
    EXPECT_TRUE(m2.Matches(0));
    EXPECT_FALSE(m2.Matches(1));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a value of the same type as the
  // value type of the Matcher.
  TEST(MatcherCastTest, FromAValue) {
    Matcher<int> m = MatcherCast<int>(42);
    EXPECT_TRUE(m.Matches(42));
    EXPECT_FALSE(m.Matches(239));
  }
  
  // Tests that MatcherCast<T>(m) works when m is a value of the type implicitly
  // convertible to the value type of the Matcher.
  TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
    const int kExpected = 'c';
    Matcher<int> m = MatcherCast<int>('c');
    EXPECT_TRUE(m.Matches(kExpected));
    EXPECT_FALSE(m.Matches(kExpected + 1));
  }
  
  struct NonImplicitlyConstructibleTypeWithOperatorEq {
    friend bool operator==(
        const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */,
        int rhs) {
      return 42 == rhs;
    }
    friend bool operator==(
        int lhs,
        const NonImplicitlyConstructibleTypeWithOperatorEq& /* ignored */) {
      return lhs == 42;
    }
  };
  
  // Tests that MatcherCast<T>(m) works when m is a neither a matcher nor
  // implicitly convertible to the value type of the Matcher, but the value type
  // of the matcher has operator==() overload accepting m.
  TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
    Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m1 =
        MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(42);
    EXPECT_TRUE(m1.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
  
    Matcher<NonImplicitlyConstructibleTypeWithOperatorEq> m2 =
        MatcherCast<NonImplicitlyConstructibleTypeWithOperatorEq>(239);
    EXPECT_FALSE(m2.Matches(NonImplicitlyConstructibleTypeWithOperatorEq()));
  
    // When updating the following lines please also change the comment to
    // namespace convertible_from_any.
    Matcher<int> m3 =
        MatcherCast<int>(NonImplicitlyConstructibleTypeWithOperatorEq());
    EXPECT_TRUE(m3.Matches(42));
    EXPECT_FALSE(m3.Matches(239));
  }
  
  // ConvertibleFromAny does not work with MSVC. resulting in
  // error C2440: 'initializing': cannot convert from 'Eq' to 'M'
  // No constructor could take the source type, or constructor overload
  // resolution was ambiguous
  
  #if !defined _MSC_VER
  
  // The below ConvertibleFromAny struct is implicitly constructible from anything
  // and when in the same namespace can interact with other tests. In particular,
  // if it is in the same namespace as other tests and one removes
  //   NonImplicitlyConstructibleTypeWithOperatorEq::operator==(int lhs, ...);
  // then the corresponding test still compiles (and it should not!) by implicitly
  // converting NonImplicitlyConstructibleTypeWithOperatorEq to ConvertibleFromAny
  // in m3.Matcher().
  namespace convertible_from_any {
  // Implicitly convertible from any type.
  struct ConvertibleFromAny {
    ConvertibleFromAny(int a_value) : value(a_value) {}
    template <typename T>
    ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
      ADD_FAILURE() << "Conversion constructor called";
    }
    int value;
  };
  
  bool operator==(const ConvertibleFromAny& a, const ConvertibleFromAny& b) {
    return a.value == b.value;
  }
  
  ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
    return os << a.value;
  }
  
  TEST(MatcherCastTest, ConversionConstructorIsUsed) {
    Matcher<ConvertibleFromAny> m = MatcherCast<ConvertibleFromAny>(1);
    EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
    EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
  }
  
  TEST(MatcherCastTest, FromConvertibleFromAny) {
    Matcher<ConvertibleFromAny> m =
        MatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
    EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
    EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
  }
  }  // namespace convertible_from_any
  
  #endif  // !defined _MSC_VER
  
  struct IntReferenceWrapper {
    IntReferenceWrapper(const int& a_value) : value(&a_value) {}
    const int* value;
  };
  
  bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
    return a.value == b.value;
  }
  
  TEST(MatcherCastTest, ValueIsNotCopied) {
    int n = 42;
    Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
    // Verify that the matcher holds a reference to n, not to its temporary copy.
    EXPECT_TRUE(m.Matches(n));
  }
  
  class Base {
   public:
    virtual ~Base() {}
    Base() {}
  
   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(Base);
  };
  
  class Derived : public Base {
   public:
    Derived() : Base() {}
    int i;
  };
  
  class OtherDerived : public Base {};
  
  // Tests that SafeMatcherCast<T>(m) works when m is a polymorphic matcher.
  TEST(SafeMatcherCastTest, FromPolymorphicMatcher) {
    Matcher<char> m2 = SafeMatcherCast<char>(Eq(32));
    EXPECT_TRUE(m2.Matches(' '));
    EXPECT_FALSE(m2.Matches('\n'));
  }
  
  // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where
  // T and U are arithmetic types and T can be losslessly converted to
  // U.
  TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
    Matcher<double> m1 = DoubleEq(1.0);
    Matcher<float> m2 = SafeMatcherCast<float>(m1);
    EXPECT_TRUE(m2.Matches(1.0f));
    EXPECT_FALSE(m2.Matches(2.0f));
  
    Matcher<char> m3 = SafeMatcherCast<char>(TypedEq<int>('a'));
    EXPECT_TRUE(m3.Matches('a'));
    EXPECT_FALSE(m3.Matches('b'));
  }
  
  // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<U> where T and U
  // are pointers or references to a derived and a base class, correspondingly.
  TEST(SafeMatcherCastTest, FromBaseClass) {
    Derived d, d2;
    Matcher<Base*> m1 = Eq(&d);
    Matcher<Derived*> m2 = SafeMatcherCast<Derived*>(m1);
    EXPECT_TRUE(m2.Matches(&d));
    EXPECT_FALSE(m2.Matches(&d2));
  
    Matcher<Base&> m3 = Ref(d);
    Matcher<Derived&> m4 = SafeMatcherCast<Derived&>(m3);
    EXPECT_TRUE(m4.Matches(d));
    EXPECT_FALSE(m4.Matches(d2));
  }
  
  // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
  TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
    int n = 0;
    Matcher<const int&> m1 = Ref(n);
    Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
    int n1 = 0;
    EXPECT_TRUE(m2.Matches(n));
    EXPECT_FALSE(m2.Matches(n1));
  }
  
  // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
  TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
    Matcher<std::unique_ptr<int>> m1 = IsNull();
    Matcher<const std::unique_ptr<int>&> m2 =
        SafeMatcherCast<const std::unique_ptr<int>&>(m1);
    EXPECT_TRUE(m2.Matches(std::unique_ptr<int>()));
    EXPECT_FALSE(m2.Matches(std::unique_ptr<int>(new int)));
  }
  
  // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
  TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
    Matcher<int> m1 = Eq(0);
    Matcher<int&> m2 = SafeMatcherCast<int&>(m1);
    int n = 0;
    EXPECT_TRUE(m2.Matches(n));
    n = 1;
    EXPECT_FALSE(m2.Matches(n));
  }
  
  // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<T>.
  TEST(SafeMatcherCastTest, FromSameType) {
    Matcher<int> m1 = Eq(0);
    Matcher<int> m2 = SafeMatcherCast<int>(m1);
    EXPECT_TRUE(m2.Matches(0));
    EXPECT_FALSE(m2.Matches(1));
  }
  
  #if !defined _MSC_VER
  
  namespace convertible_from_any {
  TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
    Matcher<ConvertibleFromAny> m = SafeMatcherCast<ConvertibleFromAny>(1);
    EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
    EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
  }
  
  TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
    Matcher<ConvertibleFromAny> m =
        SafeMatcherCast<ConvertibleFromAny>(Eq(ConvertibleFromAny(1)));
    EXPECT_TRUE(m.Matches(ConvertibleFromAny(1)));
    EXPECT_FALSE(m.Matches(ConvertibleFromAny(2)));
  }
  }  // namespace convertible_from_any
  
  #endif  // !defined _MSC_VER
  
  TEST(SafeMatcherCastTest, ValueIsNotCopied) {
    int n = 42;
    Matcher<IntReferenceWrapper> m = SafeMatcherCast<IntReferenceWrapper>(n);
    // Verify that the matcher holds a reference to n, not to its temporary copy.
    EXPECT_TRUE(m.Matches(n));
  }
  
  TEST(ExpectThat, TakesLiterals) {
    EXPECT_THAT(1, 1);
    EXPECT_THAT(1.0, 1.0);
    EXPECT_THAT(std::string(), "");
  }
  
  TEST(ExpectThat, TakesFunctions) {
    struct Helper {
      static void Func() {}
    };
    void (*func)() = Helper::Func;
    EXPECT_THAT(func, Helper::Func);
    EXPECT_THAT(func, &Helper::Func);
  }
  
  // Tests that A<T>() matches any value of type T.
  TEST(ATest, MatchesAnyValue) {
    // Tests a matcher for a value type.
    Matcher<double> m1 = A<double>();
    EXPECT_TRUE(m1.Matches(91.43));
    EXPECT_TRUE(m1.Matches(-15.32));
  
    // Tests a matcher for a reference type.
    int a = 2;
    int b = -6;
    Matcher<int&> m2 = A<int&>();
    EXPECT_TRUE(m2.Matches(a));
    EXPECT_TRUE(m2.Matches(b));
  }
  
  TEST(ATest, WorksForDerivedClass) {
    Base base;
    Derived derived;
    EXPECT_THAT(&base, A<Base*>());
    // This shouldn't compile: EXPECT_THAT(&base, A<Derived*>());
    EXPECT_THAT(&derived, A<Base*>());
    EXPECT_THAT(&derived, A<Derived*>());
  }
  
  // Tests that A<T>() describes itself properly.
  TEST(ATest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(A<bool>())); }
  
  // Tests that An<T>() matches any value of type T.
  TEST(AnTest, MatchesAnyValue) {
    // Tests a matcher for a value type.
    Matcher<int> m1 = An<int>();
    EXPECT_TRUE(m1.Matches(9143));
    EXPECT_TRUE(m1.Matches(-1532));
  
    // Tests a matcher for a reference type.
    int a = 2;
    int b = -6;
    Matcher<int&> m2 = An<int&>();
    EXPECT_TRUE(m2.Matches(a));
    EXPECT_TRUE(m2.Matches(b));
  }
  
  // Tests that An<T>() describes itself properly.
  TEST(AnTest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(An<int>())); }
  
  // Tests that _ can be used as a matcher for any type and matches any
  // value of that type.
  TEST(UnderscoreTest, MatchesAnyValue) {
    // Uses _ as a matcher for a value type.
    Matcher<int> m1 = _;
    EXPECT_TRUE(m1.Matches(123));
    EXPECT_TRUE(m1.Matches(-242));
  
    // Uses _ as a matcher for a reference type.
    bool a = false;
    const bool b = true;
    Matcher<const bool&> m2 = _;
    EXPECT_TRUE(m2.Matches(a));
    EXPECT_TRUE(m2.Matches(b));
  }
  
  // Tests that _ describes itself properly.
  TEST(UnderscoreTest, CanDescribeSelf) {
    Matcher<int> m = _;
    EXPECT_EQ("is anything", Describe(m));
  }
  
  // Tests that Eq(x) matches any value equal to x.
  TEST(EqTest, MatchesEqualValue) {
    // 2 C-strings with same content but different addresses.
    const char a1[] = "hi";
    const char a2[] = "hi";
  
    Matcher<const char*> m1 = Eq(a1);
    EXPECT_TRUE(m1.Matches(a1));
    EXPECT_FALSE(m1.Matches(a2));
  }
  
  // Tests that Eq(v) describes itself properly.
  
  class Unprintable {
   public:
    Unprintable() : c_('a') {}
  
    bool operator==(const Unprintable& /* rhs */) const { return true; }
    // -Wunused-private-field: dummy accessor for `c_`.
    char dummy_c() { return c_; }
  
   private:
    char c_;
  };
  
  TEST(EqTest, CanDescribeSelf) {
    Matcher<Unprintable> m = Eq(Unprintable());
    EXPECT_EQ("is equal to 1-byte object <61>", Describe(m));
  }
  
  // Tests that Eq(v) can be used to match any type that supports
  // comparing with type T, where T is v's type.
  TEST(EqTest, IsPolymorphic) {
    Matcher<int> m1 = Eq(1);
    EXPECT_TRUE(m1.Matches(1));
    EXPECT_FALSE(m1.Matches(2));
  
    Matcher<char> m2 = Eq(1);
    EXPECT_TRUE(m2.Matches('\1'));
    EXPECT_FALSE(m2.Matches('a'));
  }
  
  // Tests that TypedEq<T>(v) matches values of type T that's equal to v.
  TEST(TypedEqTest, ChecksEqualityForGivenType) {
    Matcher<char> m1 = TypedEq<char>('a');
    EXPECT_TRUE(m1.Matches('a'));
    EXPECT_FALSE(m1.Matches('b'));
  
    Matcher<int> m2 = TypedEq<int>(6);
    EXPECT_TRUE(m2.Matches(6));
    EXPECT_FALSE(m2.Matches(7));
  }
  
  // Tests that TypedEq(v) describes itself properly.
  TEST(TypedEqTest, CanDescribeSelf) {
    EXPECT_EQ("is equal to 2", Describe(TypedEq<int>(2)));
  }
  
  // Tests that TypedEq<T>(v) has type Matcher<T>.
  
  // Type<T>::IsTypeOf(v) compiles if and only if the type of value v is T, where
  // T is a "bare" type (i.e. not in the form of const U or U&).  If v's type is
  // not T, the compiler will generate a message about "undefined reference".
  template <typename T>
  struct Type {
    static bool IsTypeOf(const T& /* v */) { return true; }
  
    template <typename T2>
    static void IsTypeOf(T2 v);
  };
  
  TEST(TypedEqTest, HasSpecifiedType) {
    // Verfies that the type of TypedEq<T>(v) is Matcher<T>.
    Type<Matcher<int>>::IsTypeOf(TypedEq<int>(5));
    Type<Matcher<double>>::IsTypeOf(TypedEq<double>(5));
  }
  
  // Tests that Ge(v) matches anything >= v.
  TEST(GeTest, ImplementsGreaterThanOrEqual) {
    Matcher<int> m1 = Ge(0);
    EXPECT_TRUE(m1.Matches(1));
    EXPECT_TRUE(m1.Matches(0));
    EXPECT_FALSE(m1.Matches(-1));
  }
  
  // Tests that Ge(v) describes itself properly.
  TEST(GeTest, CanDescribeSelf) {
    Matcher<int> m = Ge(5);
    EXPECT_EQ("is >= 5", Describe(m));
  }
  
  // Tests that Gt(v) matches anything > v.
  TEST(GtTest, ImplementsGreaterThan) {
    Matcher<double> m1 = Gt(0);
    EXPECT_TRUE(m1.Matches(1.0));
    EXPECT_FALSE(m1.Matches(0.0));
    EXPECT_FALSE(m1.Matches(-1.0));
  }
  
  // Tests that Gt(v) describes itself properly.
  TEST(GtTest, CanDescribeSelf) {
    Matcher<int> m = Gt(5);
    EXPECT_EQ("is > 5", Describe(m));
  }
  
  // Tests that Le(v) matches anything <= v.
  TEST(LeTest, ImplementsLessThanOrEqual) {
    Matcher<char> m1 = Le('b');
    EXPECT_TRUE(m1.Matches('a'));
    EXPECT_TRUE(m1.Matches('b'));
    EXPECT_FALSE(m1.Matches('c'));
  }
  
  // Tests that Le(v) describes itself properly.
  TEST(LeTest, CanDescribeSelf) {
    Matcher<int> m = Le(5);
    EXPECT_EQ("is <= 5", Describe(m));
  }
  
  // Tests that Lt(v) matches anything < v.
  TEST(LtTest, ImplementsLessThan) {
    Matcher<const std::string&> m1 = Lt("Hello");
    EXPECT_TRUE(m1.Matches("Abc"));
    EXPECT_FALSE(m1.Matches("Hello"));
    EXPECT_FALSE(m1.Matches("Hello, world!"));
  }
  
  // Tests that Lt(v) describes itself properly.
  TEST(LtTest, CanDescribeSelf) {
    Matcher<int> m = Lt(5);
    EXPECT_EQ("is < 5", Describe(m));
  }
  
  // Tests that Ne(v) matches anything != v.
  TEST(NeTest, ImplementsNotEqual) {
    Matcher<int> m1 = Ne(0);
    EXPECT_TRUE(m1.Matches(1));
    EXPECT_TRUE(m1.Matches(-1));
    EXPECT_FALSE(m1.Matches(0));
  }
  
  // Tests that Ne(v) describes itself properly.
  TEST(NeTest, CanDescribeSelf) {
    Matcher<int> m = Ne(5);
    EXPECT_EQ("isn't equal to 5", Describe(m));
  }
  
  class MoveOnly {
   public:
    explicit MoveOnly(int i) : i_(i) {}
    MoveOnly(const MoveOnly&) = delete;
    MoveOnly(MoveOnly&&) = default;
    MoveOnly& operator=(const MoveOnly&) = delete;
    MoveOnly& operator=(MoveOnly&&) = default;
  
    bool operator==(const MoveOnly& other) const { return i_ == other.i_; }
    bool operator!=(const MoveOnly& other) const { return i_ != other.i_; }
    bool operator<(const MoveOnly& other) const { return i_ < other.i_; }
    bool operator<=(const MoveOnly& other) const { return i_ <= other.i_; }
    bool operator>(const MoveOnly& other) const { return i_ > other.i_; }
    bool operator>=(const MoveOnly& other) const { return i_ >= other.i_; }
  
   private:
    int i_;
  };
  
  struct MoveHelper {
    MOCK_METHOD1(Call, void(MoveOnly));
  };
  
  // Disable this test in VS 2015 (version 14), where it fails when SEH is enabled
  #if defined(_MSC_VER) && (_MSC_VER < 1910)
  TEST(ComparisonBaseTest, DISABLED_WorksWithMoveOnly) {
  #else
  TEST(ComparisonBaseTest, WorksWithMoveOnly) {
  #endif
    MoveOnly m{0};
    MoveHelper helper;
  
    EXPECT_CALL(helper, Call(Eq(ByRef(m))));
    helper.Call(MoveOnly(0));
    EXPECT_CALL(helper, Call(Ne(ByRef(m))));
    helper.Call(MoveOnly(1));
    EXPECT_CALL(helper, Call(Le(ByRef(m))));
    helper.Call(MoveOnly(0));
    EXPECT_CALL(helper, Call(Lt(ByRef(m))));
    helper.Call(MoveOnly(-1));
    EXPECT_CALL(helper, Call(Ge(ByRef(m))));
    helper.Call(MoveOnly(0));
    EXPECT_CALL(helper, Call(Gt(ByRef(m))));
    helper.Call(MoveOnly(1));
  }
  
  // Tests that IsNull() matches any NULL pointer of any type.
  TEST(IsNullTest, MatchesNullPointer) {
    Matcher<int*> m1 = IsNull();
    int* p1 = nullptr;
    int n = 0;
    EXPECT_TRUE(m1.Matches(p1));
    EXPECT_FALSE(m1.Matches(&n));
  
    Matcher<const char*> m2 = IsNull();
    const char* p2 = nullptr;
    EXPECT_TRUE(m2.Matches(p2));
    EXPECT_FALSE(m2.Matches("hi"));
  
    Matcher<void*> m3 = IsNull();
    void* p3 = nullptr;
    EXPECT_TRUE(m3.Matches(p3));
    EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
  }
  
  TEST(IsNullTest, StdFunction) {
    const Matcher<std::function<void()>> m = IsNull();
  
    EXPECT_TRUE(m.Matches(std::function<void()>()));
    EXPECT_FALSE(m.Matches([] {}));
  }
  
  // Tests that IsNull() describes itself properly.
  TEST(IsNullTest, CanDescribeSelf) {
    Matcher<int*> m = IsNull();
    EXPECT_EQ("is NULL", Describe(m));
    EXPECT_EQ("isn't NULL", DescribeNegation(m));
  }
  
  // Tests that NotNull() matches any non-NULL pointer of any type.
  TEST(NotNullTest, MatchesNonNullPointer) {
    Matcher<int*> m1 = NotNull();
    int* p1 = nullptr;
    int n = 0;
    EXPECT_FALSE(m1.Matches(p1));
    EXPECT_TRUE(m1.Matches(&n));
  
    Matcher<const char*> m2 = NotNull();
    const char* p2 = nullptr;
    EXPECT_FALSE(m2.Matches(p2));
    EXPECT_TRUE(m2.Matches("hi"));
  }
  
  TEST(NotNullTest, LinkedPtr) {
    const Matcher<std::shared_ptr<int>> m = NotNull();
    const std::shared_ptr<int> null_p;
    const std::shared_ptr<int> non_null_p(new int);
  
    EXPECT_FALSE(m.Matches(null_p));
    EXPECT_TRUE(m.Matches(non_null_p));
  }
  
  TEST(NotNullTest, ReferenceToConstLinkedPtr) {
    const Matcher<const std::shared_ptr<double>&> m = NotNull();
    const std::shared_ptr<double> null_p;
    const std::shared_ptr<double> non_null_p(new double);
  
    EXPECT_FALSE(m.Matches(null_p));
    EXPECT_TRUE(m.Matches(non_null_p));
  }
  
  TEST(NotNullTest, StdFunction) {
    const Matcher<std::function<void()>> m = NotNull();
  
    EXPECT_TRUE(m.Matches([] {}));
    EXPECT_FALSE(m.Matches(std::function<void()>()));
  }
  
  // Tests that NotNull() describes itself properly.
  TEST(NotNullTest, CanDescribeSelf) {
    Matcher<int*> m = NotNull();
    EXPECT_EQ("isn't NULL", Describe(m));
  }
  
  // Tests that Ref(variable) matches an argument that references
  // 'variable'.
  TEST(RefTest, MatchesSameVariable) {
    int a = 0;
    int b = 0;
    Matcher<int&> m = Ref(a);
    EXPECT_TRUE(m.Matches(a));
    EXPECT_FALSE(m.Matches(b));
  }
  
  // Tests that Ref(variable) describes itself properly.
  TEST(RefTest, CanDescribeSelf) {
    int n = 5;
    Matcher<int&> m = Ref(n);
    stringstream ss;
    ss << "references the variable @" << &n << " 5";
    EXPECT_EQ(ss.str(), Describe(m));
  }
  
  // Test that Ref(non_const_varialbe) can be used as a matcher for a
  // const reference.
  TEST(RefTest, CanBeUsedAsMatcherForConstReference) {
    int a = 0;
    int b = 0;
    Matcher<const int&> m = Ref(a);
    EXPECT_TRUE(m.Matches(a));
    EXPECT_FALSE(m.Matches(b));
  }
  
  // Tests that Ref(variable) is covariant, i.e. Ref(derived) can be
  // used wherever Ref(base) can be used (Ref(derived) is a sub-type
  // of Ref(base), but not vice versa.
  
  TEST(RefTest, IsCovariant) {
    Base base, base2;
    Derived derived;
    Matcher<const Base&> m1 = Ref(base);
    EXPECT_TRUE(m1.Matches(base));
    EXPECT_FALSE(m1.Matches(base2));
    EXPECT_FALSE(m1.Matches(derived));
  
    m1 = Ref(derived);
    EXPECT_TRUE(m1.Matches(derived));
    EXPECT_FALSE(m1.Matches(base));
    EXPECT_FALSE(m1.Matches(base2));
  }
  
  TEST(RefTest, ExplainsResult) {
    int n = 0;
    EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), n),
                StartsWith("which is located @"));
  
    int m = 0;
    EXPECT_THAT(Explain(Matcher<const int&>(Ref(n)), m),
                StartsWith("which is located @"));
  }
  
  // Tests string comparison matchers.
  
  template <typename T = std::string>
  std::string FromStringLike(internal::StringLike<T> str) {
    return std::string(str);
  }
  
  TEST(StringLike, TestConversions) {
    EXPECT_EQ("foo", FromStringLike("foo"));
    EXPECT_EQ("foo", FromStringLike(std::string("foo")));
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    EXPECT_EQ("foo", FromStringLike(internal::StringView("foo")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  
    // Non deducible types.
    EXPECT_EQ("", FromStringLike({}));
    EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'}));
    const char buf[] = "foo";
    EXPECT_EQ("foo", FromStringLike({buf, buf + 3}));
  }
  
  TEST(StrEqTest, MatchesEqualString) {
    Matcher<const char*> m = StrEq(std::string("Hello"));
    EXPECT_TRUE(m.Matches("Hello"));
    EXPECT_FALSE(m.Matches("hello"));
    EXPECT_FALSE(m.Matches(nullptr));
  
    Matcher<const std::string&> m2 = StrEq("Hello");
    EXPECT_TRUE(m2.Matches("Hello"));
    EXPECT_FALSE(m2.Matches("Hi"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView&> m3 =
        StrEq(internal::StringView("Hello"));
    EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
    EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
    EXPECT_FALSE(m3.Matches(internal::StringView()));
  
    Matcher<const internal::StringView&> m_empty = StrEq("");
    EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
    EXPECT_TRUE(m_empty.Matches(internal::StringView()));
    EXPECT_FALSE(m_empty.Matches(internal::StringView("hello")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(StrEqTest, CanDescribeSelf) {
    Matcher<std::string> m = StrEq("Hi-\'\"?\\\a\b\f\n\r\t\v\xD3");
    EXPECT_EQ("is equal to \"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\\xD3\"",
              Describe(m));
  
    std::string str("01204500800");
    str[3] = '\0';
    Matcher<std::string> m2 = StrEq(str);
    EXPECT_EQ("is equal to \"012\\04500800\"", Describe(m2));
    str[0] = str[6] = str[7] = str[9] = str[10] = '\0';
    Matcher<std::string> m3 = StrEq(str);
    EXPECT_EQ("is equal to \"\\012\\045\\0\\08\\0\\0\"", Describe(m3));
  }
  
  TEST(StrNeTest, MatchesUnequalString) {
    Matcher<const char*> m = StrNe("Hello");
    EXPECT_TRUE(m.Matches(""));
    EXPECT_TRUE(m.Matches(nullptr));
    EXPECT_FALSE(m.Matches("Hello"));
  
    Matcher<std::string> m2 = StrNe(std::string("Hello"));
    EXPECT_TRUE(m2.Matches("hello"));
    EXPECT_FALSE(m2.Matches("Hello"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView> m3 = StrNe(internal::StringView("Hello"));
    EXPECT_TRUE(m3.Matches(internal::StringView("")));
    EXPECT_TRUE(m3.Matches(internal::StringView()));
    EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(StrNeTest, CanDescribeSelf) {
    Matcher<const char*> m = StrNe("Hi");
    EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
  }
  
  TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
    Matcher<const char*> m = StrCaseEq(std::string("Hello"));
    EXPECT_TRUE(m.Matches("Hello"));
    EXPECT_TRUE(m.Matches("hello"));
    EXPECT_FALSE(m.Matches("Hi"));
    EXPECT_FALSE(m.Matches(nullptr));
  
    Matcher<const std::string&> m2 = StrCaseEq("Hello");
    EXPECT_TRUE(m2.Matches("hello"));
    EXPECT_FALSE(m2.Matches("Hi"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView&> m3 =
        StrCaseEq(internal::StringView("Hello"));
    EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
    EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
    EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
    EXPECT_FALSE(m3.Matches(internal::StringView()));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
    std::string str1("oabocdooeoo");
    std::string str2("OABOCDOOEOO");
    Matcher<const std::string&> m0 = StrCaseEq(str1);
    EXPECT_FALSE(m0.Matches(str2 + std::string(1, '\0')));
  
    str1[3] = str2[3] = '\0';
    Matcher<const std::string&> m1 = StrCaseEq(str1);
    EXPECT_TRUE(m1.Matches(str2));
  
    str1[0] = str1[6] = str1[7] = str1[10] = '\0';
    str2[0] = str2[6] = str2[7] = str2[10] = '\0';
    Matcher<const std::string&> m2 = StrCaseEq(str1);
    str1[9] = str2[9] = '\0';
    EXPECT_FALSE(m2.Matches(str2));
  
    Matcher<const std::string&> m3 = StrCaseEq(str1);
    EXPECT_TRUE(m3.Matches(str2));
  
    EXPECT_FALSE(m3.Matches(str2 + "x"));
    str2.append(1, '\0');
    EXPECT_FALSE(m3.Matches(str2));
    EXPECT_FALSE(m3.Matches(std::string(str2, 0, 9)));
  }
  
  TEST(StrCaseEqTest, CanDescribeSelf) {
    Matcher<std::string> m = StrCaseEq("Hi");
    EXPECT_EQ("is equal to (ignoring case) \"Hi\"", Describe(m));
  }
  
  TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
    Matcher<const char*> m = StrCaseNe("Hello");
    EXPECT_TRUE(m.Matches("Hi"));
    EXPECT_TRUE(m.Matches(nullptr));
    EXPECT_FALSE(m.Matches("Hello"));
    EXPECT_FALSE(m.Matches("hello"));
  
    Matcher<std::string> m2 = StrCaseNe(std::string("Hello"));
    EXPECT_TRUE(m2.Matches(""));
    EXPECT_FALSE(m2.Matches("Hello"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView> m3 =
        StrCaseNe(internal::StringView("Hello"));
    EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
    EXPECT_TRUE(m3.Matches(internal::StringView()));
    EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
    EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(StrCaseNeTest, CanDescribeSelf) {
    Matcher<const char*> m = StrCaseNe("Hi");
    EXPECT_EQ("isn't equal to (ignoring case) \"Hi\"", Describe(m));
  }
  
  // Tests that HasSubstr() works for matching string-typed values.
  TEST(HasSubstrTest, WorksForStringClasses) {
    const Matcher<std::string> m1 = HasSubstr("foo");
    EXPECT_TRUE(m1.Matches(std::string("I love food.")));
    EXPECT_FALSE(m1.Matches(std::string("tofo")));
  
    const Matcher<const std::string&> m2 = HasSubstr("foo");
    EXPECT_TRUE(m2.Matches(std::string("I love food.")));
    EXPECT_FALSE(m2.Matches(std::string("tofo")));
  
    const Matcher<std::string> m_empty = HasSubstr("");
    EXPECT_TRUE(m_empty.Matches(std::string()));
    EXPECT_TRUE(m_empty.Matches(std::string("not empty")));
  }
  
  // Tests that HasSubstr() works for matching C-string-typed values.
  TEST(HasSubstrTest, WorksForCStrings) {
    const Matcher<char*> m1 = HasSubstr("foo");
    EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
    EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const char*> m2 = HasSubstr("foo");
    EXPECT_TRUE(m2.Matches("I love food."));
    EXPECT_FALSE(m2.Matches("tofo"));
    EXPECT_FALSE(m2.Matches(nullptr));
  
    const Matcher<const char*> m_empty = HasSubstr("");
    EXPECT_TRUE(m_empty.Matches("not empty"));
    EXPECT_TRUE(m_empty.Matches(""));
    EXPECT_FALSE(m_empty.Matches(nullptr));
  }
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
  // Tests that HasSubstr() works for matching StringView-typed values.
  TEST(HasSubstrTest, WorksForStringViewClasses) {
    const Matcher<internal::StringView> m1 =
        HasSubstr(internal::StringView("foo"));
    EXPECT_TRUE(m1.Matches(internal::StringView("I love food.")));
    EXPECT_FALSE(m1.Matches(internal::StringView("tofo")));
    EXPECT_FALSE(m1.Matches(internal::StringView()));
  
    const Matcher<const internal::StringView&> m2 = HasSubstr("foo");
    EXPECT_TRUE(m2.Matches(internal::StringView("I love food.")));
    EXPECT_FALSE(m2.Matches(internal::StringView("tofo")));
    EXPECT_FALSE(m2.Matches(internal::StringView()));
  
    const Matcher<const internal::StringView&> m3 = HasSubstr("");
    EXPECT_TRUE(m3.Matches(internal::StringView("foo")));
    EXPECT_TRUE(m3.Matches(internal::StringView("")));
    EXPECT_TRUE(m3.Matches(internal::StringView()));
  }
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  
  // Tests that HasSubstr(s) describes itself properly.
  TEST(HasSubstrTest, CanDescribeSelf) {
    Matcher<std::string> m = HasSubstr("foo\n\"");
    EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
  }
  
  TEST(KeyTest, CanDescribeSelf) {
    Matcher<const pair<std::string, int>&> m = Key("foo");
    EXPECT_EQ("has a key that is equal to \"foo\"", Describe(m));
    EXPECT_EQ("doesn't have a key that is equal to \"foo\"", DescribeNegation(m));
  }
  
  TEST(KeyTest, ExplainsResult) {
    Matcher<pair<int, bool>> m = Key(GreaterThan(10));
    EXPECT_EQ("whose first field is a value which is 5 less than 10",
              Explain(m, make_pair(5, true)));
    EXPECT_EQ("whose first field is a value which is 5 more than 10",
              Explain(m, make_pair(15, true)));
  }
  
  TEST(KeyTest, MatchesCorrectly) {
    pair<int, std::string> p(25, "foo");
    EXPECT_THAT(p, Key(25));
    EXPECT_THAT(p, Not(Key(42)));
    EXPECT_THAT(p, Key(Ge(20)));
    EXPECT_THAT(p, Not(Key(Lt(25))));
  }
  
  TEST(KeyTest, WorksWithMoveOnly) {
    pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
    EXPECT_THAT(p, Key(Eq(nullptr)));
  }
  
  template <size_t I>
  struct Tag {};
  
  struct PairWithGet {
    int member_1;
    std::string member_2;
    using first_type = int;
    using second_type = std::string;
  
    const int& GetImpl(Tag<0>) const { return member_1; }
    const std::string& GetImpl(Tag<1>) const { return member_2; }
  };
  template <size_t I>
  auto get(const PairWithGet& value) -> decltype(value.GetImpl(Tag<I>())) {
    return value.GetImpl(Tag<I>());
  }
  TEST(PairTest, MatchesPairWithGetCorrectly) {
    PairWithGet p{25, "foo"};
    EXPECT_THAT(p, Key(25));
    EXPECT_THAT(p, Not(Key(42)));
    EXPECT_THAT(p, Key(Ge(20)));
    EXPECT_THAT(p, Not(Key(Lt(25))));
  
    std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
    EXPECT_THAT(v, Contains(Key(29)));
  }
  
  TEST(KeyTest, SafelyCastsInnerMatcher) {
    Matcher<int> is_positive = Gt(0);
    Matcher<int> is_negative = Lt(0);
    pair<char, bool> p('a', true);
    EXPECT_THAT(p, Key(is_positive));
    EXPECT_THAT(p, Not(Key(is_negative)));
  }
  
  TEST(KeyTest, InsideContainsUsingMap) {
    map<int, char> container;
    container.insert(make_pair(1, 'a'));
    container.insert(make_pair(2, 'b'));
    container.insert(make_pair(4, 'c'));
    EXPECT_THAT(container, Contains(Key(1)));
    EXPECT_THAT(container, Not(Contains(Key(3))));
  }
  
  TEST(KeyTest, InsideContainsUsingMultimap) {
    multimap<int, char> container;
    container.insert(make_pair(1, 'a'));
    container.insert(make_pair(2, 'b'));
    container.insert(make_pair(4, 'c'));
  
    EXPECT_THAT(container, Not(Contains(Key(25))));
    container.insert(make_pair(25, 'd'));
    EXPECT_THAT(container, Contains(Key(25)));
    container.insert(make_pair(25, 'e'));
    EXPECT_THAT(container, Contains(Key(25)));
  
    EXPECT_THAT(container, Contains(Key(1)));
    EXPECT_THAT(container, Not(Contains(Key(3))));
  }
  
  TEST(PairTest, Typing) {
    // Test verifies the following type conversions can be compiled.
    Matcher<const pair<const char*, int>&> m1 = Pair("foo", 42);
    Matcher<const pair<const char*, int>> m2 = Pair("foo", 42);
    Matcher<pair<const char*, int>> m3 = Pair("foo", 42);
  
    Matcher<pair<int, const std::string>> m4 = Pair(25, "42");
    Matcher<pair<const std::string, int>> m5 = Pair("25", 42);
  }
  
  TEST(PairTest, CanDescribeSelf) {
    Matcher<const pair<std::string, int>&> m1 = Pair("foo", 42);
    EXPECT_EQ(
        "has a first field that is equal to \"foo\""
        ", and has a second field that is equal to 42",
        Describe(m1));
    EXPECT_EQ(
        "has a first field that isn't equal to \"foo\""
        ", or has a second field that isn't equal to 42",
        DescribeNegation(m1));
    // Double and triple negation (1 or 2 times not and description of negation).
    Matcher<const pair<int, int>&> m2 = Not(Pair(Not(13), 42));
    EXPECT_EQ(
        "has a first field that isn't equal to 13"
        ", and has a second field that is equal to 42",
        DescribeNegation(m2));
  }
  
  TEST(PairTest, CanExplainMatchResultTo) {
    // If neither field matches, Pair() should explain about the first
    // field.
    const Matcher<pair<int, int>> m = Pair(GreaterThan(0), GreaterThan(0));
    EXPECT_EQ("whose first field does not match, which is 1 less than 0",
              Explain(m, make_pair(-1, -2)));
  
    // If the first field matches but the second doesn't, Pair() should
    // explain about the second field.
    EXPECT_EQ("whose second field does not match, which is 2 less than 0",
              Explain(m, make_pair(1, -2)));
  
    // If the first field doesn't match but the second does, Pair()
    // should explain about the first field.
    EXPECT_EQ("whose first field does not match, which is 1 less than 0",
              Explain(m, make_pair(-1, 2)));
  
    // If both fields match, Pair() should explain about them both.
    EXPECT_EQ(
        "whose both fields match, where the first field is a value "
        "which is 1 more than 0, and the second field is a value "
        "which is 2 more than 0",
        Explain(m, make_pair(1, 2)));
  
    // If only the first match has an explanation, only this explanation should
    // be printed.
    const Matcher<pair<int, int>> explain_first = Pair(GreaterThan(0), 0);
    EXPECT_EQ(
        "whose both fields match, where the first field is a value "
        "which is 1 more than 0",
        Explain(explain_first, make_pair(1, 0)));
  
    // If only the second match has an explanation, only this explanation should
    // be printed.
    const Matcher<pair<int, int>> explain_second = Pair(0, GreaterThan(0));
    EXPECT_EQ(
        "whose both fields match, where the second field is a value "
        "which is 1 more than 0",
        Explain(explain_second, make_pair(0, 1)));
  }
  
  TEST(PairTest, MatchesCorrectly) {
    pair<int, std::string> p(25, "foo");
  
    // Both fields match.
    EXPECT_THAT(p, Pair(25, "foo"));
    EXPECT_THAT(p, Pair(Ge(20), HasSubstr("o")));
  
    // 'first' doesnt' match, but 'second' matches.
    EXPECT_THAT(p, Not(Pair(42, "foo")));
    EXPECT_THAT(p, Not(Pair(Lt(25), "foo")));
  
    // 'first' matches, but 'second' doesn't match.
    EXPECT_THAT(p, Not(Pair(25, "bar")));
    EXPECT_THAT(p, Not(Pair(25, Not("foo"))));
  
    // Neither field matches.
    EXPECT_THAT(p, Not(Pair(13, "bar")));
    EXPECT_THAT(p, Not(Pair(Lt(13), HasSubstr("a"))));
  }
  
  TEST(PairTest, WorksWithMoveOnly) {
    pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
    p.second.reset(new int(7));
    EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr)));
  }
  
  TEST(PairTest, SafelyCastsInnerMatchers) {
    Matcher<int> is_positive = Gt(0);
    Matcher<int> is_negative = Lt(0);
    pair<char, bool> p('a', true);
    EXPECT_THAT(p, Pair(is_positive, _));
    EXPECT_THAT(p, Not(Pair(is_negative, _)));
    EXPECT_THAT(p, Pair(_, is_positive));
    EXPECT_THAT(p, Not(Pair(_, is_negative)));
  }
  
  TEST(PairTest, InsideContainsUsingMap) {
    map<int, char> container;
    container.insert(make_pair(1, 'a'));
    container.insert(make_pair(2, 'b'));
    container.insert(make_pair(4, 'c'));
    EXPECT_THAT(container, Contains(Pair(1, 'a')));
    EXPECT_THAT(container, Contains(Pair(1, _)));
    EXPECT_THAT(container, Contains(Pair(_, 'a')));
    EXPECT_THAT(container, Not(Contains(Pair(3, _))));
  }
  
  TEST(FieldsAreTest, MatchesCorrectly) {
    std::tuple<int, std::string, double> p(25, "foo", .5);
  
    // All fields match.
    EXPECT_THAT(p, FieldsAre(25, "foo", .5));
    EXPECT_THAT(p, FieldsAre(Ge(20), HasSubstr("o"), DoubleEq(.5)));
  
    // Some don't match.
    EXPECT_THAT(p, Not(FieldsAre(26, "foo", .5)));
    EXPECT_THAT(p, Not(FieldsAre(25, "fo", .5)));
    EXPECT_THAT(p, Not(FieldsAre(25, "foo", .6)));
  }
  
  TEST(FieldsAreTest, CanDescribeSelf) {
    Matcher<const pair<std::string, int>&> m1 = FieldsAre("foo", 42);
    EXPECT_EQ(
        "has field #0 that is equal to \"foo\""
        ", and has field #1 that is equal to 42",
        Describe(m1));
    EXPECT_EQ(
        "has field #0 that isn't equal to \"foo\""
        ", or has field #1 that isn't equal to 42",
        DescribeNegation(m1));
  }
  
  TEST(FieldsAreTest, CanExplainMatchResultTo) {
    // The first one that fails is the one that gives the error.
    Matcher<std::tuple<int, int, int>> m =
        FieldsAre(GreaterThan(0), GreaterThan(0), GreaterThan(0));
  
    EXPECT_EQ("whose field #0 does not match, which is 1 less than 0",
              Explain(m, std::make_tuple(-1, -2, -3)));
    EXPECT_EQ("whose field #1 does not match, which is 2 less than 0",
              Explain(m, std::make_tuple(1, -2, -3)));
    EXPECT_EQ("whose field #2 does not match, which is 3 less than 0",
              Explain(m, std::make_tuple(1, 2, -3)));
  
    // If they all match, we get a long explanation of success.
    EXPECT_EQ(
        "whose all elements match, "
        "where field #0 is a value which is 1 more than 0"
        ", and field #1 is a value which is 2 more than 0"
        ", and field #2 is a value which is 3 more than 0",
        Explain(m, std::make_tuple(1, 2, 3)));
  
    // Only print those that have an explanation.
    m = FieldsAre(GreaterThan(0), 0, GreaterThan(0));
    EXPECT_EQ(
        "whose all elements match, "
        "where field #0 is a value which is 1 more than 0"
        ", and field #2 is a value which is 3 more than 0",
        Explain(m, std::make_tuple(1, 0, 3)));
  
    // If only one has an explanation, then print that one.
    m = FieldsAre(0, GreaterThan(0), 0);
    EXPECT_EQ(
        "whose all elements match, "
        "where field #1 is a value which is 1 more than 0",
        Explain(m, std::make_tuple(0, 1, 0)));
  }
  
  #if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
  TEST(FieldsAreTest, StructuredBindings) {
    // testing::FieldsAre can also match aggregates and such with C++17 and up.
    struct MyType {
      int i;
      std::string str;
    };
    EXPECT_THAT((MyType{17, "foo"}), FieldsAre(Eq(17), HasSubstr("oo")));
  
    // Test all the supported arities.
    struct MyVarType1 {
      int a;
    };
    EXPECT_THAT(MyVarType1{}, FieldsAre(0));
    struct MyVarType2 {
      int a, b;
    };
    EXPECT_THAT(MyVarType2{}, FieldsAre(0, 0));
    struct MyVarType3 {
      int a, b, c;
    };
    EXPECT_THAT(MyVarType3{}, FieldsAre(0, 0, 0));
    struct MyVarType4 {
      int a, b, c, d;
    };
    EXPECT_THAT(MyVarType4{}, FieldsAre(0, 0, 0, 0));
    struct MyVarType5 {
      int a, b, c, d, e;
    };
    EXPECT_THAT(MyVarType5{}, FieldsAre(0, 0, 0, 0, 0));
    struct MyVarType6 {
      int a, b, c, d, e, f;
    };
    EXPECT_THAT(MyVarType6{}, FieldsAre(0, 0, 0, 0, 0, 0));
    struct MyVarType7 {
      int a, b, c, d, e, f, g;
    };
    EXPECT_THAT(MyVarType7{}, FieldsAre(0, 0, 0, 0, 0, 0, 0));
    struct MyVarType8 {
      int a, b, c, d, e, f, g, h;
    };
    EXPECT_THAT(MyVarType8{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType9 {
      int a, b, c, d, e, f, g, h, i;
    };
    EXPECT_THAT(MyVarType9{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType10 {
      int a, b, c, d, e, f, g, h, i, j;
    };
    EXPECT_THAT(MyVarType10{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType11 {
      int a, b, c, d, e, f, g, h, i, j, k;
    };
    EXPECT_THAT(MyVarType11{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType12 {
      int a, b, c, d, e, f, g, h, i, j, k, l;
    };
    EXPECT_THAT(MyVarType12{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType13 {
      int a, b, c, d, e, f, g, h, i, j, k, l, m;
    };
    EXPECT_THAT(MyVarType13{}, FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType14 {
      int a, b, c, d, e, f, g, h, i, j, k, l, m, n;
    };
    EXPECT_THAT(MyVarType14{},
                FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType15 {
      int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o;
    };
    EXPECT_THAT(MyVarType15{},
                FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
    struct MyVarType16 {
      int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
    };
    EXPECT_THAT(MyVarType16{},
                FieldsAre(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
  }
  #endif
  
  TEST(PairTest, UseGetInsteadOfMembers) {
    PairWithGet pair{7, "ABC"};
    EXPECT_THAT(pair, Pair(7, "ABC"));
    EXPECT_THAT(pair, Pair(Ge(7), HasSubstr("AB")));
    EXPECT_THAT(pair, Not(Pair(Lt(7), "ABC")));
  
    std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
    EXPECT_THAT(v,
                ElementsAre(Pair(11, std::string("Foo")), Pair(Ge(10), Not(""))));
  }
  
  // Tests StartsWith(s).
  
  TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
    const Matcher<const char*> m1 = StartsWith(std::string(""));
    EXPECT_TRUE(m1.Matches("Hi"));
    EXPECT_TRUE(m1.Matches(""));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const std::string&> m2 = StartsWith("Hi");
    EXPECT_TRUE(m2.Matches("Hi"));
    EXPECT_TRUE(m2.Matches("Hi Hi!"));
    EXPECT_TRUE(m2.Matches("High"));
    EXPECT_FALSE(m2.Matches("H"));
    EXPECT_FALSE(m2.Matches(" Hi"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    const Matcher<internal::StringView> m_empty =
        StartsWith(internal::StringView(""));
    EXPECT_TRUE(m_empty.Matches(internal::StringView()));
    EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
    EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(StartsWithTest, CanDescribeSelf) {
    Matcher<const std::string> m = StartsWith("Hi");
    EXPECT_EQ("starts with \"Hi\"", Describe(m));
  }
  
  // Tests EndsWith(s).
  
  TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
    const Matcher<const char*> m1 = EndsWith("");
    EXPECT_TRUE(m1.Matches("Hi"));
    EXPECT_TRUE(m1.Matches(""));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const std::string&> m2 = EndsWith(std::string("Hi"));
    EXPECT_TRUE(m2.Matches("Hi"));
    EXPECT_TRUE(m2.Matches("Wow Hi Hi"));
    EXPECT_TRUE(m2.Matches("Super Hi"));
    EXPECT_FALSE(m2.Matches("i"));
    EXPECT_FALSE(m2.Matches("Hi "));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    const Matcher<const internal::StringView&> m4 =
        EndsWith(internal::StringView(""));
    EXPECT_TRUE(m4.Matches("Hi"));
    EXPECT_TRUE(m4.Matches(""));
    EXPECT_TRUE(m4.Matches(internal::StringView()));
    EXPECT_TRUE(m4.Matches(internal::StringView("")));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(EndsWithTest, CanDescribeSelf) {
    Matcher<const std::string> m = EndsWith("Hi");
    EXPECT_EQ("ends with \"Hi\"", Describe(m));
  }
  
  // Tests WhenBase64Unescaped.
  
  TEST(WhenBase64UnescapedTest, MatchesUnescapedBase64Strings) {
    const Matcher<const char*> m1 = WhenBase64Unescaped(EndsWith("!"));
    EXPECT_FALSE(m1.Matches("invalid base64"));
    EXPECT_FALSE(m1.Matches("aGVsbG8gd29ybGQ="));  // hello world
    EXPECT_TRUE(m1.Matches("aGVsbG8gd29ybGQh"));   // hello world!
  
    const Matcher<const std::string&> m2 = WhenBase64Unescaped(EndsWith("!"));
    EXPECT_FALSE(m2.Matches("invalid base64"));
    EXPECT_FALSE(m2.Matches("aGVsbG8gd29ybGQ="));  // hello world
    EXPECT_TRUE(m2.Matches("aGVsbG8gd29ybGQh"));   // hello world!
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    const Matcher<const internal::StringView&> m3 =
        WhenBase64Unescaped(EndsWith("!"));
    EXPECT_FALSE(m3.Matches("invalid base64"));
    EXPECT_FALSE(m3.Matches("aGVsbG8gd29ybGQ="));  // hello world
    EXPECT_TRUE(m3.Matches("aGVsbG8gd29ybGQh"));   // hello world!
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(WhenBase64UnescapedTest, CanDescribeSelf) {
    const Matcher<const char*> m = WhenBase64Unescaped(EndsWith("!"));
    EXPECT_EQ("matches after Base64Unescape ends with \"!\"", Describe(m));
  }
  
  // Tests MatchesRegex().
  
  TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
    const Matcher<const char*> m1 = MatchesRegex("a.*z");
    EXPECT_TRUE(m1.Matches("az"));
    EXPECT_TRUE(m1.Matches("abcz"));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z"));
    EXPECT_TRUE(m2.Matches("azbz"));
    EXPECT_FALSE(m2.Matches("az1"));
    EXPECT_FALSE(m2.Matches("1az"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    const Matcher<const internal::StringView&> m3 = MatchesRegex("a.*z");
    EXPECT_TRUE(m3.Matches(internal::StringView("az")));
    EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
    EXPECT_FALSE(m3.Matches(internal::StringView("1az")));
    EXPECT_FALSE(m3.Matches(internal::StringView()));
    const Matcher<const internal::StringView&> m4 =
        MatchesRegex(internal::StringView(""));
    EXPECT_TRUE(m4.Matches(internal::StringView("")));
    EXPECT_TRUE(m4.Matches(internal::StringView()));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(MatchesRegexTest, CanDescribeSelf) {
    Matcher<const std::string> m1 = MatchesRegex(std::string("Hi.*"));
    EXPECT_EQ("matches regular expression \"Hi.*\"", Describe(m1));
  
    Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
    EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView> m3 = MatchesRegex(new RE("0.*"));
    EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  // Tests ContainsRegex().
  
  TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
    const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z"));
    EXPECT_TRUE(m1.Matches("az"));
    EXPECT_TRUE(m1.Matches("0abcz1"));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z"));
    EXPECT_TRUE(m2.Matches("azbz"));
    EXPECT_TRUE(m2.Matches("az1"));
    EXPECT_FALSE(m2.Matches("1a"));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    const Matcher<const internal::StringView&> m3 = ContainsRegex(new RE("a.*z"));
    EXPECT_TRUE(m3.Matches(internal::StringView("azbz")));
    EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
    EXPECT_FALSE(m3.Matches(internal::StringView("1a")));
    EXPECT_FALSE(m3.Matches(internal::StringView()));
    const Matcher<const internal::StringView&> m4 =
        ContainsRegex(internal::StringView(""));
    EXPECT_TRUE(m4.Matches(internal::StringView("")));
    EXPECT_TRUE(m4.Matches(internal::StringView()));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  TEST(ContainsRegexTest, CanDescribeSelf) {
    Matcher<const std::string> m1 = ContainsRegex("Hi.*");
    EXPECT_EQ("contains regular expression \"Hi.*\"", Describe(m1));
  
    Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
    EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
  
  #if GTEST_INTERNAL_HAS_STRING_VIEW
    Matcher<const internal::StringView> m3 = ContainsRegex(new RE("0.*"));
    EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
  #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  }
  
  // Tests for wide strings.
  #if GTEST_HAS_STD_WSTRING
  TEST(StdWideStrEqTest, MatchesEqual) {
    Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
    EXPECT_TRUE(m.Matches(L"Hello"));
    EXPECT_FALSE(m.Matches(L"hello"));
    EXPECT_FALSE(m.Matches(nullptr));
  
    Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
    EXPECT_TRUE(m2.Matches(L"Hello"));
    EXPECT_FALSE(m2.Matches(L"Hi"));
  
    Matcher<const ::std::wstring&> m3 = StrEq(L"\xD3\x576\x8D3\xC74D");
    EXPECT_TRUE(m3.Matches(L"\xD3\x576\x8D3\xC74D"));
    EXPECT_FALSE(m3.Matches(L"\xD3\x576\x8D3\xC74E"));
  
    ::std::wstring str(L"01204500800");
    str[3] = L'\0';
    Matcher<const ::std::wstring&> m4 = StrEq(str);
    EXPECT_TRUE(m4.Matches(str));
    str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
    Matcher<const ::std::wstring&> m5 = StrEq(str);
    EXPECT_TRUE(m5.Matches(str));
  }
  
  TEST(StdWideStrEqTest, CanDescribeSelf) {
    Matcher<::std::wstring> m = StrEq(L"Hi-\'\"?\\\a\b\f\n\r\t\v");
    EXPECT_EQ("is equal to L\"Hi-\'\\\"?\\\\\\a\\b\\f\\n\\r\\t\\v\"",
              Describe(m));
  
    Matcher<::std::wstring> m2 = StrEq(L"\xD3\x576\x8D3\xC74D");
    EXPECT_EQ("is equal to L\"\\xD3\\x576\\x8D3\\xC74D\"", Describe(m2));
  
    ::std::wstring str(L"01204500800");
    str[3] = L'\0';
    Matcher<const ::std::wstring&> m4 = StrEq(str);
    EXPECT_EQ("is equal to L\"012\\04500800\"", Describe(m4));
    str[0] = str[6] = str[7] = str[9] = str[10] = L'\0';
    Matcher<const ::std::wstring&> m5 = StrEq(str);
    EXPECT_EQ("is equal to L\"\\012\\045\\0\\08\\0\\0\"", Describe(m5));
  }
  
  TEST(StdWideStrNeTest, MatchesUnequalString) {
    Matcher<const wchar_t*> m = StrNe(L"Hello");
    EXPECT_TRUE(m.Matches(L""));
    EXPECT_TRUE(m.Matches(nullptr));
    EXPECT_FALSE(m.Matches(L"Hello"));
  
    Matcher<::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
    EXPECT_TRUE(m2.Matches(L"hello"));
    EXPECT_FALSE(m2.Matches(L"Hello"));
  }
  
  TEST(StdWideStrNeTest, CanDescribeSelf) {
    Matcher<const wchar_t*> m = StrNe(L"Hi");
    EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
  }
  
  TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
    Matcher<const wchar_t*> m = StrCaseEq(::std::wstring(L"Hello"));
    EXPECT_TRUE(m.Matches(L"Hello"));
    EXPECT_TRUE(m.Matches(L"hello"));
    EXPECT_FALSE(m.Matches(L"Hi"));
    EXPECT_FALSE(m.Matches(nullptr));
  
    Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
    EXPECT_TRUE(m2.Matches(L"hello"));
    EXPECT_FALSE(m2.Matches(L"Hi"));
  }
  
  TEST(StdWideStrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
    ::std::wstring str1(L"oabocdooeoo");
    ::std::wstring str2(L"OABOCDOOEOO");
    Matcher<const ::std::wstring&> m0 = StrCaseEq(str1);
    EXPECT_FALSE(m0.Matches(str2 + ::std::wstring(1, L'\0')));
  
    str1[3] = str2[3] = L'\0';
    Matcher<const ::std::wstring&> m1 = StrCaseEq(str1);
    EXPECT_TRUE(m1.Matches(str2));
  
    str1[0] = str1[6] = str1[7] = str1[10] = L'\0';
    str2[0] = str2[6] = str2[7] = str2[10] = L'\0';
    Matcher<const ::std::wstring&> m2 = StrCaseEq(str1);
    str1[9] = str2[9] = L'\0';
    EXPECT_FALSE(m2.Matches(str2));
  
    Matcher<const ::std::wstring&> m3 = StrCaseEq(str1);
    EXPECT_TRUE(m3.Matches(str2));
  
    EXPECT_FALSE(m3.Matches(str2 + L"x"));
    str2.append(1, L'\0');
    EXPECT_FALSE(m3.Matches(str2));
    EXPECT_FALSE(m3.Matches(::std::wstring(str2, 0, 9)));
  }
  
  TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
    Matcher<::std::wstring> m = StrCaseEq(L"Hi");
    EXPECT_EQ("is equal to (ignoring case) L\"Hi\"", Describe(m));
  }
  
  TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
    Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
    EXPECT_TRUE(m.Matches(L"Hi"));
    EXPECT_TRUE(m.Matches(nullptr));
    EXPECT_FALSE(m.Matches(L"Hello"));
    EXPECT_FALSE(m.Matches(L"hello"));
  
    Matcher<::std::wstring> m2 = StrCaseNe(::std::wstring(L"Hello"));
    EXPECT_TRUE(m2.Matches(L""));
    EXPECT_FALSE(m2.Matches(L"Hello"));
  }
  
  TEST(StdWideStrCaseNeTest, CanDescribeSelf) {
    Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
    EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
  }
  
  // Tests that HasSubstr() works for matching wstring-typed values.
  TEST(StdWideHasSubstrTest, WorksForStringClasses) {
    const Matcher<::std::wstring> m1 = HasSubstr(L"foo");
    EXPECT_TRUE(m1.Matches(::std::wstring(L"I love food.")));
    EXPECT_FALSE(m1.Matches(::std::wstring(L"tofo")));
  
    const Matcher<const ::std::wstring&> m2 = HasSubstr(L"foo");
    EXPECT_TRUE(m2.Matches(::std::wstring(L"I love food.")));
    EXPECT_FALSE(m2.Matches(::std::wstring(L"tofo")));
  }
  
  // Tests that HasSubstr() works for matching C-wide-string-typed values.
  TEST(StdWideHasSubstrTest, WorksForCStrings) {
    const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
    EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
    EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
    EXPECT_TRUE(m2.Matches(L"I love food."));
    EXPECT_FALSE(m2.Matches(L"tofo"));
    EXPECT_FALSE(m2.Matches(nullptr));
  }
  
  // Tests that HasSubstr(s) describes itself properly.
  TEST(StdWideHasSubstrTest, CanDescribeSelf) {
    Matcher<::std::wstring> m = HasSubstr(L"foo\n\"");
    EXPECT_EQ("has substring L\"foo\\n\\\"\"", Describe(m));
  }
  
  // Tests StartsWith(s).
  
  TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
    const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
    EXPECT_TRUE(m1.Matches(L"Hi"));
    EXPECT_TRUE(m1.Matches(L""));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
    EXPECT_TRUE(m2.Matches(L"Hi"));
    EXPECT_TRUE(m2.Matches(L"Hi Hi!"));
    EXPECT_TRUE(m2.Matches(L"High"));
    EXPECT_FALSE(m2.Matches(L"H"));
    EXPECT_FALSE(m2.Matches(L" Hi"));
  }
  
  TEST(StdWideStartsWithTest, CanDescribeSelf) {
    Matcher<const ::std::wstring> m = StartsWith(L"Hi");
    EXPECT_EQ("starts with L\"Hi\"", Describe(m));
  }
  
  // Tests EndsWith(s).
  
  TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
    const Matcher<const wchar_t*> m1 = EndsWith(L"");
    EXPECT_TRUE(m1.Matches(L"Hi"));
    EXPECT_TRUE(m1.Matches(L""));
    EXPECT_FALSE(m1.Matches(nullptr));
  
    const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
    EXPECT_TRUE(m2.Matches(L"Hi"));
    EXPECT_TRUE(m2.Matches(L"Wow Hi Hi"));
    EXPECT_TRUE(m2.Matches(L"Super Hi"));
    EXPECT_FALSE(m2.Matches(L"i"));
    EXPECT_FALSE(m2.Matches(L"Hi "));
  }
  
  TEST(StdWideEndsWithTest, CanDescribeSelf) {
    Matcher<const ::std::wstring> m = EndsWith(L"Hi");
    EXPECT_EQ("ends with L\"Hi\"", Describe(m));
  }
  
  #endif  // GTEST_HAS_STD_WSTRING
  
  TEST(ExplainMatchResultTest, WorksWithPolymorphicMatcher) {
    StringMatchResultListener listener1;
    EXPECT_TRUE(ExplainMatchResult(PolymorphicIsEven(), 42, &listener1));
    EXPECT_EQ("% 2 == 0", listener1.str());
  
    StringMatchResultListener listener2;
    EXPECT_FALSE(ExplainMatchResult(Ge(42), 1.5, &listener2));
    EXPECT_EQ("", listener2.str());
  }
  
  TEST(ExplainMatchResultTest, WorksWithMonomorphicMatcher) {
    const Matcher<int> is_even = PolymorphicIsEven();
    StringMatchResultListener listener1;
    EXPECT_TRUE(ExplainMatchResult(is_even, 42, &listener1));
    EXPECT_EQ("% 2 == 0", listener1.str());
  
    const Matcher<const double&> is_zero = Eq(0);
    StringMatchResultListener listener2;
    EXPECT_FALSE(ExplainMatchResult(is_zero, 1.5, &listener2));
    EXPECT_EQ("", listener2.str());
  }
  
  MATCHER(ConstructNoArg, "") { return true; }
  MATCHER_P(Construct1Arg, arg1, "") { return true; }
  MATCHER_P2(Construct2Args, arg1, arg2, "") { return true; }
  
  TEST(MatcherConstruct, ExplicitVsImplicit) {
    {
      // No arg constructor can be constructed with empty brace.
      ConstructNoArgMatcher m = {};
      (void)m;
      // And with no args
      ConstructNoArgMatcher m2;
      (void)m2;
    }
    {
      // The one arg constructor has an explicit constructor.
      // This is to prevent the implicit conversion.
      using M = Construct1ArgMatcherP<int>;
      EXPECT_TRUE((std::is_constructible<M, int>::value));
      EXPECT_FALSE((std::is_convertible<int, M>::value));
    }
    {
      // Multiple arg matchers can be constructed with an implicit construction.
      Construct2ArgsMatcherP2<int, double> m = {1, 2.2};
      (void)m;
    }
  }
  
  MATCHER_P(Really, inner_matcher, "") {
    return ExplainMatchResult(inner_matcher, arg, result_listener);
  }
  
  TEST(ExplainMatchResultTest, WorksInsideMATCHER) {
    EXPECT_THAT(0, Really(Eq(0)));
  }
  
  TEST(DescribeMatcherTest, WorksWithValue) {
    EXPECT_EQ("is equal to 42", DescribeMatcher<int>(42));
    EXPECT_EQ("isn't equal to 42", DescribeMatcher<int>(42, true));
  }
  
  TEST(DescribeMatcherTest, WorksWithMonomorphicMatcher) {
    const Matcher<int> monomorphic = Le(0);
    EXPECT_EQ("is <= 0", DescribeMatcher<int>(monomorphic));
    EXPECT_EQ("isn't <= 0", DescribeMatcher<int>(monomorphic, true));
  }
  
  TEST(DescribeMatcherTest, WorksWithPolymorphicMatcher) {
    EXPECT_EQ("is even", DescribeMatcher<int>(PolymorphicIsEven()));
    EXPECT_EQ("is odd", DescribeMatcher<int>(PolymorphicIsEven(), true));
  }
  
  MATCHER_P(FieldIIs, inner_matcher, "") {
    return ExplainMatchResult(inner_matcher, arg.i, result_listener);
  }
  
  #if GTEST_HAS_RTTI
  TEST(WhenDynamicCastToTest, SameType) {
    Derived derived;
    derived.i = 4;
  
    // Right type. A pointer is passed down.
    Base* as_base_ptr = &derived;
    EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Not(IsNull())));
    EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(4))));
    EXPECT_THAT(as_base_ptr,
                Not(WhenDynamicCastTo<Derived*>(Pointee(FieldIIs(5)))));
  }
  
  TEST(WhenDynamicCastToTest, WrongTypes) {
    Base base;
    Derived derived;
    OtherDerived other_derived;
  
    // Wrong types. NULL is passed.
    EXPECT_THAT(&base, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
    EXPECT_THAT(&base, WhenDynamicCastTo<Derived*>(IsNull()));
    Base* as_base_ptr = &derived;
    EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<OtherDerived*>(Pointee(_))));
    EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<OtherDerived*>(IsNull()));
    as_base_ptr = &other_derived;
    EXPECT_THAT(as_base_ptr, Not(WhenDynamicCastTo<Derived*>(Pointee(_))));
    EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
  }
  
  TEST(WhenDynamicCastToTest, AlreadyNull) {
    // Already NULL.
    Base* as_base_ptr = nullptr;
    EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
  }
  
  struct AmbiguousCastTypes {
    class VirtualDerived : public virtual Base {};
    class DerivedSub1 : public VirtualDerived {};
    class DerivedSub2 : public VirtualDerived {};
    class ManyDerivedInHierarchy : public DerivedSub1, public DerivedSub2 {};
  };
  
  TEST(WhenDynamicCastToTest, AmbiguousCast) {
    AmbiguousCastTypes::DerivedSub1 sub1;
    AmbiguousCastTypes::ManyDerivedInHierarchy many_derived;
    // Multiply derived from Base. dynamic_cast<> returns NULL.
    Base* as_base_ptr =
        static_cast<AmbiguousCastTypes::DerivedSub1*>(&many_derived);
    EXPECT_THAT(as_base_ptr,
                WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(IsNull()));
    as_base_ptr = &sub1;
    EXPECT_THAT(
        as_base_ptr,
        WhenDynamicCastTo<AmbiguousCastTypes::VirtualDerived*>(Not(IsNull())));
  }
  
  TEST(WhenDynamicCastToTest, Describe) {
    Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
    const std::string prefix =
        "when dynamic_cast to " + internal::GetTypeName<Derived*>() + ", ";
    EXPECT_EQ(prefix + "points to a value that is anything", Describe(matcher));
    EXPECT_EQ(prefix + "does not point to a value that is anything",
              DescribeNegation(matcher));
  }
  
  TEST(WhenDynamicCastToTest, Explain) {
    Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
    Base* null = nullptr;
    EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
    Derived derived;
    EXPECT_TRUE(matcher.Matches(&derived));
    EXPECT_THAT(Explain(matcher, &derived), HasSubstr("which points to "));
  
    // With references, the matcher itself can fail. Test for that one.
    Matcher<const Base&> ref_matcher = WhenDynamicCastTo<const OtherDerived&>(_);
    EXPECT_THAT(Explain(ref_matcher, derived),
                HasSubstr("which cannot be dynamic_cast"));
  }
  
  TEST(WhenDynamicCastToTest, GoodReference) {
    Derived derived;
    derived.i = 4;
    Base& as_base_ref = derived;
    EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(FieldIIs(4)));
    EXPECT_THAT(as_base_ref, WhenDynamicCastTo<const Derived&>(Not(FieldIIs(5))));
  }
  
  TEST(WhenDynamicCastToTest, BadReference) {
    Derived derived;
    Base& as_base_ref = derived;
    EXPECT_THAT(as_base_ref, Not(WhenDynamicCastTo<const OtherDerived&>(_)));
  }
  #endif  // GTEST_HAS_RTTI
  
  class DivisibleByImpl {
   public:
    explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
  
    // For testing using ExplainMatchResultTo() with polymorphic matchers.
    template <typename T>
    bool MatchAndExplain(const T& n, MatchResultListener* listener) const {
      *listener << "which is " << (n % divider_) << " modulo " << divider_;
      return (n % divider_) == 0;
    }
  
    void DescribeTo(ostream* os) const { *os << "is divisible by " << divider_; }
  
    void DescribeNegationTo(ostream* os) const {
      *os << "is not divisible by " << divider_;
    }
  
    void set_divider(int a_divider) { divider_ = a_divider; }
    int divider() const { return divider_; }
  
   private:
    int divider_;
  };
  
  PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
    return MakePolymorphicMatcher(DivisibleByImpl(n));
  }
  
  // Tests that when AllOf() fails, only the first failing matcher is
  // asked to explain why.
  TEST(ExplainMatchResultTest, AllOf_False_False) {
    const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
    EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
  }
  
  // Tests that when AllOf() fails, only the first failing matcher is
  // asked to explain why.
  TEST(ExplainMatchResultTest, AllOf_False_True) {
    const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
    EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
  }
  
  // Tests that when AllOf() fails, only the first failing matcher is
  // asked to explain why.
  TEST(ExplainMatchResultTest, AllOf_True_False) {
    const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
    EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
  }
  
  // Tests that when AllOf() succeeds, all matchers are asked to explain
  // why.
  TEST(ExplainMatchResultTest, AllOf_True_True) {
    const Matcher<int> m = AllOf(DivisibleBy(2), DivisibleBy(3));
    EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
  }
  
  TEST(ExplainMatchResultTest, AllOf_True_True_2) {
    const Matcher<int> m = AllOf(Ge(2), Le(3));
    EXPECT_EQ("", Explain(m, 2));
  }
  
  TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
    const Matcher<int> m = GreaterThan(5);
    EXPECT_EQ("which is 1 more than 5", Explain(m, 6));
  }
  
  // Tests PolymorphicMatcher::mutable_impl().
  TEST(PolymorphicMatcherTest, CanAccessMutableImpl) {
    PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
    DivisibleByImpl& impl = m.mutable_impl();
    EXPECT_EQ(42, impl.divider());
  
    impl.set_divider(0);
    EXPECT_EQ(0, m.mutable_impl().divider());
  }
  
  // Tests PolymorphicMatcher::impl().
  TEST(PolymorphicMatcherTest, CanAccessImpl) {
    const PolymorphicMatcher<DivisibleByImpl> m(DivisibleByImpl(42));
    const DivisibleByImpl& impl = m.impl();
    EXPECT_EQ(42, impl.divider());
  }
  
  }  // namespace
  }  // namespace gmock_matchers_test
  }  // namespace testing
  
  #ifdef _MSC_VER
  #pragma warning(pop)
  #endif
  