Makes EXPECT_THAT typesafe; updates CHANGES for 1.7.0; pulls in gtest r653

3 files changed, 34 insertions, 3 deletions

diff --git a/CHANGES b/CHANGES
index 4ccabf6d..d20b50b7 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,6 +1,26 @@
 Changes for 1.7.0:
 
-TO BE WRITTEN.
+* All new improvements in Google Test 1.7.0.
+* New feature: matchers WhenSorted(), WhenSortedBy(), IsEmpty(), and
+  SizeIs().
+* Improvement: Google Mock can now be built as a DLL.
+* Improvement: when exceptions are enabled, a mock method with no
+  default action now throws instead crashing the test.
+* Improvement: function return types used in MOCK_METHOD*() macros can
+  now contain unprotected commas.
+* Improvement (potentially breaking): EXPECT_THAT() and ASSERT_THAT()
+  are now more strict in ensuring that the value type and the matcher
+  type are compatible, catching potential bugs in tests.
+* Improvement: Pointee() now works on an optional<T>.
+* Improvement: the ElementsAreArray() matcher can now take a vector or
+  iterator range as input, and makes a copy of its input elements
+  before the conversion to a Matcher.
+* Bug fix: mock object destruction triggerred by another mock object's
+  destruction no longer hangs.
+* Improvement: Google Mock Doctor works better with newer Clang and
+  GCC now.
+* Compatibility fixes.
+* Bug/warning fixes.
 
 Changes for 1.6.0:
 
diff --git a/include/gmock/gmock-matchers.h b/include/gmock/gmock-matchers.h
index 962cfde9..d4977273 100644
--- a/include/gmock/gmock-matchers.h
+++ b/include/gmock/gmock-matchers.h
@@ -1613,10 +1613,12 @@ class PredicateFormatterFromMatcher {
     // know which type to instantiate it to until we actually see the
     // type of x here.
     //
-    // We write MatcherCast<const T&>(matcher_) instead of
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
     // Matcher<const T&>(matcher_), as the latter won't compile when
     // matcher_ has type Matcher<T> (e.g. An<int>()).
-    const Matcher<const T&> matcher = MatcherCast<const T&>(matcher_);
+    // We don't write MatcherCast<const T&> either, as that allows
+    // potentially unsafe downcasting of the matcher argument.
+    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
     StringMatchResultListener listener;
     if (MatchPrintAndExplain(x, matcher, &listener))
       return AssertionSuccess();
diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc
index 66459464..3ec2989e 100644
--- a/test/gmock-matchers_test.cc
+++ b/test/gmock-matchers_test.cc
@@ -721,6 +721,15 @@ TEST(ATest, MatchesAnyValue) {
   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>()));