Roll gtest r395:408 and gmock r278:282 to pick up ThreadLocal leak fix.

testing/gmock/test/gmock-matchers_test.cc

 // 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
@@ skipping 43 matching lines @@
 namespace internal {
 string FormatMatcherDescriptionSyntaxError(const char* description,
                                            const char* error_pos);
 int GetParamIndex(const char* param_names[], const string& param_name);
 string JoinAsTuple(const Strings& fields);
 bool SkipPrefix(const char* prefix, const char** pstr);
 }  // namespace internal
 
 namespace gmock_matchers_test {
 
+using std::make_pair;
 using std::map;
 using std::multimap;
+using std::pair;
 using std::stringstream;
 using std::tr1::make_tuple;
 using testing::A;
 using testing::AllArgs;
 using testing::AllOf;
 using testing::An;
 using testing::AnyOf;
 using testing::ByRef;
+using testing::ContainsRegex;
 using testing::DoubleEq;
 using testing::EndsWith;
 using testing::Eq;
+using testing::ExplainMatchResult;
 using testing::Field;
 using testing::FloatEq;
 using testing::Ge;
 using testing::Gt;
 using testing::HasSubstr;
 using testing::IsNull;
 using testing::Key;
 using testing::Le;
 using testing::Lt;
 using testing::MakeMatcher;
 using testing::MakePolymorphicMatcher;
+using testing::MatchResultListener;
 using testing::Matcher;
 using testing::MatcherCast;
 using testing::MatcherInterface;
 using testing::Matches;
-using testing::ExplainMatchResult;
-using testing::MatchResultListener;
+using testing::MatchesRegex;
 using testing::NanSensitiveDoubleEq;
 using testing::NanSensitiveFloatEq;
 using testing::Ne;
 using testing::Not;
 using testing::NotNull;
 using testing::Pair;
 using testing::Pointee;
 using testing::PolymorphicMatcher;
 using testing::Property;
 using testing::Ref;
 using testing::ResultOf;
 using testing::StartsWith;
 using testing::StrCaseEq;
 using testing::StrCaseNe;
 using testing::StrEq;
 using testing::StrNe;
 using testing::Truly;
 using testing::TypedEq;
 using testing::Value;
 using testing::_;
 using testing::internal::DummyMatchResultListener;
+using testing::internal::ExplainMatchFailureTupleTo;
 using testing::internal::FloatingEqMatcher;
 using testing::internal::FormatMatcherDescriptionSyntaxError;
 using testing::internal::GetParamIndex;
 using testing::internal::Interpolation;
 using testing::internal::Interpolations;
 using testing::internal::JoinAsTuple;
+using testing::internal::RE;
 using testing::internal::SkipPrefix;
 using testing::internal::StreamMatchResultListener;
 using testing::internal::String;
+using testing::internal::StringMatchResultListener;
 using testing::internal::Strings;
-using testing::internal::StringMatchResultListener;
 using testing::internal::ValidateMatcherDescription;
 using testing::internal::kInvalidInterpolation;
 using testing::internal::kPercentInterpolation;
 using testing::internal::kTupleInterpolation;
 using testing::internal::linked_ptr;
 using testing::internal::scoped_ptr;
 using testing::internal::string;
 
-using testing::ContainsRegex;
-using testing::MatchesRegex;
-using testing::internal::RE;
-
 // For testing ExplainMatchResultTo().
 class GreaterThanMatcher : public MatcherInterface<int> {
  public:
   explicit GreaterThanMatcher(int rhs) : rhs_(rhs) {}
 
   virtual void DescribeTo(::std::ostream* os) const {
-    *os << "is greater than " << rhs_;
+    *os << "is > " << rhs_;
   }
 
   virtual bool MatchAndExplain(int lhs,
                                MatchResultListener* listener) const {
     const int diff = lhs - rhs_;
     if (diff > 0) {
       *listener << "which is " << diff << " more than " << rhs_;
     } else if (diff == 0) {
       *listener << "which is the same as " << rhs_;
     } else {
@@ skipping 595 matching lines @@
 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 greater than or equal to 5", Describe(m));
+  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 greater than 5", Describe(m));
+  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 less than or equal to 5", Describe(m));
+  EXPECT_EQ("is <= 5", Describe(m));
 }
 
 // Tests that Lt(v) matches anything < v.
 TEST(LtTest, ImplementsLessThan) {
   Matcher<const 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 less than 5", Describe(m));
+  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("is not equal to 5", Describe(m));
+  EXPECT_EQ("isn't equal to 5", Describe(m));
 }
 
 // Tests that IsNull() matches any NULL pointer of any type.
 TEST(IsNullTest, MatchesNullPointer) {
   Matcher<int*> m1 = IsNull();
   int* p1 = NULL;
   int n = 0;
   EXPECT_TRUE(m1.Matches(p1));
   EXPECT_FALSE(m1.Matches(&n));
 
@@ skipping 42 matching lines @@
   const scoped_ptr<double> non_null_p(new double);
 
   EXPECT_TRUE(m.Matches(null_p));
   EXPECT_FALSE(m.Matches(non_null_p));
 }
 
 // Tests that IsNull() describes itself properly.
 TEST(IsNullTest, CanDescribeSelf) {
   Matcher<int*> m = IsNull();
   EXPECT_EQ("is NULL", Describe(m));
-  EXPECT_EQ("is not NULL", DescribeNegation(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 = NULL;
   int n = 0;
   EXPECT_FALSE(m1.Matches(p1));
   EXPECT_TRUE(m1.Matches(&n));
 
@@ skipping 26 matching lines @@
   const scoped_ptr<double> null_p;
   const scoped_ptr<double> non_null_p(new double);
 
   EXPECT_FALSE(m.Matches(null_p));
   EXPECT_TRUE(m.Matches(non_null_p));
 }
 
 // Tests that NotNull() describes itself properly.
 TEST(NotNullTest, CanDescribeSelf) {
   Matcher<int*> m = NotNull();
-  EXPECT_EQ("is not NULL", Describe(m));
+  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));
@@ skipping 29 matching lines @@
   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.
 
 TEST(StrEqTest, MatchesEqualString) {
   Matcher<const char*> m = StrEq(string("Hello"));
   EXPECT_TRUE(m.Matches("Hello"));
   EXPECT_FALSE(m.Matches("hello"));
   EXPECT_FALSE(m.Matches(NULL));
 
   Matcher<const string&> m2 = StrEq("Hello");
   EXPECT_TRUE(m2.Matches("Hello"));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(m.Matches(NULL));
   EXPECT_FALSE(m.Matches("Hello"));
 
   Matcher<string> m2 = StrNe(string("Hello"));
   EXPECT_TRUE(m2.Matches("hello"));
   EXPECT_FALSE(m2.Matches("Hello"));
 }
 
 TEST(StrNeTest, CanDescribeSelf) {
   Matcher<const char*> m = StrNe("Hi");
-  EXPECT_EQ("is not equal to \"Hi\"", Describe(m));
+  EXPECT_EQ("isn't equal to \"Hi\"", Describe(m));
 }
 
 TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
   Matcher<const char*> m = StrCaseEq(string("Hello"));
   EXPECT_TRUE(m.Matches("Hello"));
   EXPECT_TRUE(m.Matches("hello"));
   EXPECT_FALSE(m.Matches("Hi"));
   EXPECT_FALSE(m.Matches(NULL));
 
   Matcher<const string&> m2 = StrCaseEq("Hello");
@@ skipping 38 matching lines @@
   EXPECT_FALSE(m.Matches("Hello"));
   EXPECT_FALSE(m.Matches("hello"));
 
   Matcher<string> m2 = StrCaseNe(string("Hello"));
   EXPECT_TRUE(m2.Matches(""));
   EXPECT_FALSE(m2.Matches("Hello"));
 }
 
 TEST(StrCaseNeTest, CanDescribeSelf) {
   Matcher<const char*> m = StrCaseNe("Hi");
-  EXPECT_EQ("is not equal to (ignoring case) \"Hi\"", Describe(m));
+  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<string> m1 = HasSubstr("foo");
   EXPECT_TRUE(m1.Matches(string("I love food.")));
   EXPECT_FALSE(m1.Matches(string("tofo")));
 
   const Matcher<const std::string&> m2 = HasSubstr("foo");
   EXPECT_TRUE(m2.Matches(std::string("I love food.")));
@@ skipping 13 matching lines @@
   EXPECT_FALSE(m2.Matches(NULL));
 }
 
 // Tests that HasSubstr(s) describes itself properly.
 TEST(HasSubstrTest, CanDescribeSelf) {
   Matcher<string> m = HasSubstr("foo\n\"");
   EXPECT_EQ("has substring \"foo\\n\\\"\"", Describe(m));
 }
 
 TEST(KeyTest, CanDescribeSelf) {
-  Matcher<const std::pair<std::string, int>&> m = Key("foo");
+  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) {
-  std::pair<int, std::string> p(25, "foo");
+  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, SafelyCastsInnerMatcher) {
   Matcher<int> is_positive = Gt(0);
   Matcher<int> is_negative = Lt(0);
-  std::pair<char, bool> p('a', true);
+  pair<char, bool> p('a', true);
   EXPECT_THAT(p, Key(is_positive));
   EXPECT_THAT(p, Not(Key(is_negative)));
 }
 
 TEST(KeyTest, InsideContainsUsingMap) {
   std::map<int, char> container;
-  container.insert(std::make_pair(1, 'a'));
-  container.insert(std::make_pair(2, 'b'));
-  container.insert(std::make_pair(4, 'c'));
+  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) {
   std::multimap<int, char> container;
-  container.insert(std::make_pair(1, 'a'));
-  container.insert(std::make_pair(2, 'b'));
-  container.insert(std::make_pair(4, 'c'));
+  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(std::make_pair(25, 'd'));
+  container.insert(make_pair(25, 'd'));
   EXPECT_THAT(container, Contains(Key(25)));
-  container.insert(std::make_pair(25, 'e'));
+  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 std::pair<const char*, int>&> m1 = Pair("foo", 42);
-  Matcher<const std::pair<const char*, int> > m2 = Pair("foo", 42);
-  Matcher<std::pair<const char*, int> > m3 = Pair("foo", 42);
+  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<std::pair<int, const std::string> > m4 = Pair(25, "42");
-  Matcher<std::pair<const std::string, int> > m5 = Pair("25", 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 std::pair<std::string, int>&> m1 = Pair("foo", 42);
+  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 is not equal to \"foo\""
-            ", or has a second field that is not equal to 42",
+  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 std::pair<int, int>&> m2 = Not(Pair(Not(13), 42));
-  EXPECT_EQ("has a first field that is not equal to 13"
+  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<std::pair<int, int> > m = Pair(GreaterThan(0), GreaterThan(0));
+  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, std::make_pair(-1, -2)));
+            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, std::make_pair(1, -2)));
+            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, std::make_pair(-1, 2)));
+            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, std::make_pair(1, 2)));
+            Explain(m, make_pair(1, 2)));
 
   // If only the first match has an explanation, only this explanation should
   // be printed.
-  const Matcher<std::pair<int, int> > explain_first = Pair(GreaterThan(0), 0);
+  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, std::make_pair(1, 0)));
+            Explain(explain_first, make_pair(1, 0)));
 
   // If only the second match has an explanation, only this explanation should
   // be printed.
-  const Matcher<std::pair<int, int> > explain_second = Pair(0, GreaterThan(0));
+  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, std::make_pair(0, 1)));
+            Explain(explain_second, make_pair(0, 1)));
 }
 
 TEST(PairTest, MatchesCorrectly) {
-  std::pair<int, std::string> p(25, "foo");
+  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, SafelyCastsInnerMatchers) {
   Matcher<int> is_positive = Gt(0);
   Matcher<int> is_negative = Lt(0);
-  std::pair<char, bool> p('a', true);
+  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) {
   std::map<int, char> container;
-  container.insert(std::make_pair(1, 'a'));
-  container.insert(std::make_pair(2, 'b'));
-  container.insert(std::make_pair(4, 'c'));
+  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, _))));
 }
 
 // Tests StartsWith(s).
 
 TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
   const Matcher<const char*> m1 = StartsWith(string(""));
@@ skipping 128 matching lines @@
   EXPECT_TRUE(m.Matches(NULL));
   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("is not equal to L\"Hi\"", Describe(m));
+  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(NULL));
 
   Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
@@ skipping 38 matching lines @@
   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("is not equal to (ignoring case) L\"Hi\"", Describe(m));
+  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.")));
@@ skipping 111 matching lines @@
   EXPECT_TRUE(m.Matches(NULL));
   EXPECT_FALSE(m.Matches(L"Hello"));
 
   Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
   EXPECT_TRUE(m2.Matches(L"hello"));
   EXPECT_FALSE(m2.Matches(L"Hello"));
 }
 
 TEST(GlobalWideStrNeTest, CanDescribeSelf) {
   Matcher<const wchar_t*> m = StrNe(L"Hi");
-  EXPECT_EQ("is not equal to L\"Hi\"", Describe(m));
+  EXPECT_EQ("isn't equal to L\"Hi\"", Describe(m));
 }
 
 TEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
   Matcher<const wchar_t*> m = StrCaseEq(::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(NULL));
 
   Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
@@ skipping 38 matching lines @@
   EXPECT_FALSE(m.Matches(L"Hello"));
   EXPECT_FALSE(m.Matches(L"hello"));
 
   Matcher< ::wstring> m2 = StrCaseNe(::wstring(L"Hello"));
   EXPECT_TRUE(m2.Matches(L""));
   EXPECT_FALSE(m2.Matches(L"Hello"));
 }
 
 TEST(GlobalWideStrCaseNeTest, CanDescribeSelf) {
   Matcher<const wchar_t*> m = StrCaseNe(L"Hi");
-  EXPECT_EQ("is not equal to (ignoring case) L\"Hi\"", Describe(m));
+  EXPECT_EQ("isn't equal to (ignoring case) L\"Hi\"", Describe(m));
 }
 
 // Tests that HasSubstr() works for matching wstring-typed values.
 TEST(GlobalWideHasSubstrTest, WorksForStringClasses) {
   const Matcher< ::wstring> m1 = HasSubstr(L"foo");
   EXPECT_TRUE(m1.Matches(::wstring(L"I love food.")));
   EXPECT_FALSE(m1.Matches(::wstring(L"tofo")));
 
   const Matcher<const ::wstring&> m2 = HasSubstr(L"foo");
   EXPECT_TRUE(m2.Matches(::wstring(L"I love food.")));
@@ skipping 159 matching lines @@
 TEST(NotTest, NegatesMatcher) {
   Matcher<int> m;
   m = Not(Eq(2));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
 }
 
 // Tests that Not(m) describes itself properly.
 TEST(NotTest, CanDescribeSelf) {
   Matcher<int> m = Not(Eq(5));
-  EXPECT_EQ("is not equal to 5", Describe(m));
+  EXPECT_EQ("isn't equal to 5", Describe(m));
 }
 
 // Tests that monomorphic matchers are safely cast by the Not matcher.
 TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
   // greater_than_5 is a monomorphic matcher.
   Matcher<int> greater_than_5 = Gt(5);
 
   Matcher<const int&> m = Not(greater_than_5);
   Matcher<int&> m2 = Not(greater_than_5);
   Matcher<int&> m3 = Not(m);
@@ skipping 25 matching lines @@
   m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
   EXPECT_TRUE(m.Matches(0));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_FALSE(m.Matches(3));
 }
 
 // Tests that AllOf(m1, ..., mn) describes itself properly.
 TEST(AllOfTest, CanDescribeSelf) {
   Matcher<int> m;
   m = AllOf(Le(2), Ge(1));
-  EXPECT_EQ("(is less than or equal to 2) and "
-            "(is greater than or equal to 1)",
-            Describe(m));
+  EXPECT_EQ("(is <= 2) and (is >= 1)", Describe(m));
 
   m = AllOf(Gt(0), Ne(1), Ne(2));
-  EXPECT_EQ("(is greater than 0) and "
-            "((is not equal to 1) and "
-            "(is not equal to 2))",
+  EXPECT_EQ("(is > 0) and "
+            "((isn't equal to 1) and "
+            "(isn't equal to 2))",
             Describe(m));
 
 
   m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
-  EXPECT_EQ("(is greater than 0) and "
-            "((is not equal to 1) and "
-            "((is not equal to 2) and "
-            "(is not equal to 3)))",
+  EXPECT_EQ("(is > 0) and "
+            "((isn't equal to 1) and "
+            "((isn't equal to 2) and "
+            "(isn't equal to 3)))",
             Describe(m));
 
 
   m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
-  EXPECT_EQ("(is greater than or equal to 0) and "
-            "((is less than 10) and "
-            "((is not equal to 3) and "
-            "((is not equal to 5) and "
-            "(is not equal to 7))))", Describe(m));
+  EXPECT_EQ("(is >= 0) and "
+            "((is < 10) and "
+            "((isn't equal to 3) and "
+            "((isn't equal to 5) and "
+            "(isn't equal to 7))))",
+            Describe(m));
+}
+
+// Tests that AllOf(m1, ..., mn) describes its negation properly.
+TEST(AllOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AllOf(Le(2), Ge(1));
+  EXPECT_EQ("(isn't <= 2) or "
+            "(isn't >= 1)",
+            DescribeNegation(m));
+
+  m = AllOf(Gt(0), Ne(1), Ne(2));
+  EXPECT_EQ("(isn't > 0) or "
+            "((is equal to 1) or "
+            "(is equal to 2))",
+            DescribeNegation(m));
+
+
+  m = AllOf(Gt(0), Ne(1), Ne(2), Ne(3));
+  EXPECT_EQ("(isn't > 0) or "
+            "((is equal to 1) or "
+            "((is equal to 2) or "
+            "(is equal to 3)))",
+            DescribeNegation(m));
+
+
+  m = AllOf(Ge(0), Lt(10), Ne(3), Ne(5), Ne(7));
+  EXPECT_EQ("(isn't >= 0) or "
+            "((isn't < 10) or "
+            "((is equal to 3) or "
+            "((is equal to 5) or "
+            "(is equal to 7))))",
+            DescribeNegation(m));
 }
 
 // Tests that monomorphic matchers are safely cast by the AllOf matcher.
 TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
   // greater_than_5 and less_than_10 are monomorphic matchers.
   Matcher<int> greater_than_5 = Gt(5);
   Matcher<int> less_than_10 = Lt(10);
 
   Matcher<const int&> m = AllOf(greater_than_5, less_than_10);
   Matcher<int&> m2 = AllOf(greater_than_5, less_than_10);
   Matcher<int&> m3 = AllOf(greater_than_5, m2);
 
   // Tests that BothOf works when composing itself.
   Matcher<const int&> m4 = AllOf(greater_than_5, less_than_10, less_than_10);
   Matcher<int&> m5 = AllOf(greater_than_5, less_than_10, less_than_10);
 }
 
+TEST(AllOfTest, ExplainsResult) {
+  Matcher<int> m;
+
+  // Successful match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
+
+  // Successful match.  Both matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 20 more than 10, and which is 10 more than 20",
+            Explain(m, 30));
+
+  // Successful match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
+  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
+            Explain(m, 25));
+
+  // Successful match.  All matchers need to explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ("which is 30 more than 10, and which is 20 more than 20, "
+            "and which is 10 more than 30",
+            Explain(m, 40));
+
+  // Failed match.  The first matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AllOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 40));
+
+  // Failed match.  The second matcher, which failed, needs to
+  // explain.
+  m = AllOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 20", Explain(m, 15));
+}
+
 // Tests that AnyOf(m1, ..., mn) matches any value that matches at
 // least one of the given matchers.
 TEST(AnyOfTest, MatchesWhenAnyMatches) {
   Matcher<int> m;
   m = AnyOf(Le(1), Ge(3));
   EXPECT_TRUE(m.Matches(1));
   EXPECT_TRUE(m.Matches(4));
   EXPECT_FALSE(m.Matches(2));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2));
@@ skipping 13 matching lines @@
   EXPECT_TRUE(m.Matches(0));
   EXPECT_TRUE(m.Matches(11));
   EXPECT_TRUE(m.Matches(3));
   EXPECT_FALSE(m.Matches(2));
 }
 
 // Tests that AnyOf(m1, ..., mn) describes itself properly.
 TEST(AnyOfTest, CanDescribeSelf) {
   Matcher<int> m;
   m = AnyOf(Le(1), Ge(3));
-  EXPECT_EQ("(is less than or equal to 1) or "
-            "(is greater than or equal to 3)",
+  EXPECT_EQ("(is <= 1) or (is >= 3)",
             Describe(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2));
-  EXPECT_EQ("(is less than 0) or "
+  EXPECT_EQ("(is < 0) or "
             "((is equal to 1) or (is equal to 2))",
             Describe(m));
 
   m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
-  EXPECT_EQ("(is less than 0) or "
+  EXPECT_EQ("(is < 0) or "
             "((is equal to 1) or "
             "((is equal to 2) or "
             "(is equal to 3)))",
             Describe(m));
 
   m = AnyOf(Le(0), Gt(10), 3, 5, 7);
-  EXPECT_EQ("(is less than or equal to 0) or "
-            "((is greater than 10) or "
+  EXPECT_EQ("(is <= 0) or "
+            "((is > 10) or "
             "((is equal to 3) or "
             "((is equal to 5) or "
             "(is equal to 7))))",
             Describe(m));
 }
 
+// Tests that AnyOf(m1, ..., mn) describes its negation properly.
+TEST(AnyOfTest, CanDescribeNegation) {
+  Matcher<int> m;
+  m = AnyOf(Le(1), Ge(3));
+  EXPECT_EQ("(isn't <= 1) and (isn't >= 3)",
+            DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2));
+  EXPECT_EQ("(isn't < 0) and "
+            "((isn't equal to 1) and (isn't equal to 2))",
+            DescribeNegation(m));
+
+  m = AnyOf(Lt(0), Eq(1), Eq(2), Eq(3));
+  EXPECT_EQ("(isn't < 0) and "
+            "((isn't equal to 1) and "
+            "((isn't equal to 2) and "
+            "(isn't equal to 3)))",
+            DescribeNegation(m));
+
+  m = AnyOf(Le(0), Gt(10), 3, 5, 7);
+  EXPECT_EQ("(isn't <= 0) and "
+            "((isn't > 10) and "
+            "((isn't equal to 3) and "
+            "((isn't equal to 5) and "
+            "(isn't equal to 7))))",
+            DescribeNegation(m));
+}
+
 // Tests that monomorphic matchers are safely cast by the AnyOf matcher.
 TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
   // greater_than_5 and less_than_10 are monomorphic matchers.
   Matcher<int> greater_than_5 = Gt(5);
   Matcher<int> less_than_10 = Lt(10);
 
   Matcher<const int&> m = AnyOf(greater_than_5, less_than_10);
   Matcher<int&> m2 = AnyOf(greater_than_5, less_than_10);
   Matcher<int&> m3 = AnyOf(greater_than_5, m2);
 
   // Tests that EitherOf works when composing itself.
   Matcher<const int&> m4 = AnyOf(greater_than_5, less_than_10, less_than_10);
   Matcher<int&> m5 = AnyOf(greater_than_5, less_than_10, less_than_10);
 }
 
+TEST(AnyOfTest, ExplainsResult) {
+  Matcher<int> m;
+
+  // Failed match.  Both matchers need to explain.  The second
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
+  m = AnyOf(GreaterThan(10), Lt(0));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+
+  // Failed match.  Both matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
+  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
+  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
+            Explain(m, 5));
+
+  // Failed match.  All matchers need to explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20, "
+            "and which is 25 less than 30",
+            Explain(m, 5));
+
+  // Successful match.  The first matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(10), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.  Since it doesn't given an explanation, nothing is
+  // printed.
+  m = AnyOf(GreaterThan(10), Lt(30));
+  EXPECT_EQ("", Explain(m, 0));
+
+  // Successful match.  The second matcher, which succeeded, needs to
+  // explain.
+  m = AnyOf(GreaterThan(30), GreaterThan(20));
+  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
+}
+
 // The following predicate function and predicate functor are for
 // testing the Truly(predicate) matcher.
 
 // Returns non-zero if the input is positive.  Note that the return
 // type of this function is not bool.  It's OK as Truly() accepts any
 // unary function or functor whose return type can be implicitly
 // converted to bool.
 int IsPositive(double x) {
   return x > 0 ? 1 : 0;
 }
@@ skipping 173 matching lines @@
   static int n;
   n = 5;
 
   // VC++ prior to version 8.0 SP1 has a bug where it will not see any
   // functions declared in the namespace scope from within nested classes.
   // EXPECT/ASSERT_(NON)FATAL_FAILURE macros use nested classes so that all
   // namespace-level functions invoked inside them need to be explicitly
   // resolved.
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Gt(10)),
                        "Value of: n\n"
-                       "Expected: is greater than 10\n"
+                       "Expected: is > 10\n"
                        "  Actual: 5");
   n = 0;
   EXPECT_NONFATAL_FAILURE(
       EXPECT_THAT(n, ::testing::AllOf(::testing::Le(7), ::testing::Ge(5))),
       "Value of: n\n"
-      "Expected: (is less than or equal to 7) and "
-      "(is greater than or equal to 5)\n"
+      "Expected: (is <= 7) and (is >= 5)\n"
       "  Actual: 0");
 }
 
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the argument
 // has a reference type.
 TEST(MatcherAssertionTest, WorksForByRefArguments) {
   // We use a static variable here as EXPECT_FATAL_FAILURE() cannot
   // reference auto variables.
   static int n;
   n = 0;
   EXPECT_THAT(n, AllOf(Le(7), Ref(n)));
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
                        "Value of: n\n"
                        "Expected: does not reference the variable @");
   // Tests the "Actual" part.
   EXPECT_FATAL_FAILURE(ASSERT_THAT(n, ::testing::Not(::testing::Ref(n))),
-                       "Actual: 0 (is located @");
+                       "Actual: 0, which is located @");
 }
 
 #if !GTEST_OS_SYMBIAN
 // Tests that ASSERT_THAT() and EXPECT_THAT() work when the matcher is
 // monomorphic.
 
 // ASSERT_THAT("hello", starts_with_he) fails to compile with Nokia's
 // Symbian compiler: it tries to compile
 // template<T, U> class MatcherCastImpl { ...
 //   virtual bool MatchAndExplain(T x, ...) const {
 //     return source_matcher_.MatchAndExplain(static_cast<U>(x), ...);
 // with U == string and T == const char*
 // With ASSERT_THAT("hello"...) changed to ASSERT_THAT(string("hello") ... )
 // the compiler silently crashes with no output.
 // If MatcherCastImpl is changed to use U(x) instead of static_cast<U>(x)
 // the code compiles but the converted string is bogus.
 TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
   Matcher<const char*> starts_with_he = StartsWith("he");
   ASSERT_THAT("hello", starts_with_he);
 
   Matcher<const string&> ends_with_ok = EndsWith("ok");
   ASSERT_THAT("book", ends_with_ok);
 
   Matcher<int> is_greater_than_5 = Gt(5);
   EXPECT_NONFATAL_FAILURE(EXPECT_THAT(5, is_greater_than_5),
                           "Value of: 5\n"
-                          "Expected: is greater than 5\n"
+                          "Expected: is > 5\n"
                           "  Actual: 5");
 }
 #endif  // !GTEST_OS_SYMBIAN
 
 // Tests floating-point matchers.
 template <typename RawType>
 class FloatingPointTest : public testing::Test {
  protected:
   typedef typename testing::internal::FloatingPoint<RawType> Floating;
   typedef typename Floating::Bits Bits;
@@ skipping 154 matching lines @@
   // NanSensitiveFloatEq will match NaN.
   Matcher<float> m = NanSensitiveFloatEq(nan1_);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }
 
 TEST_F(FloatTest, FloatEqCanDescribeSelf) {
   Matcher<float> m1 = FloatEq(2.0f);
   EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("is not approximately 2", DescribeNegation(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<float> m2 = FloatEq(0.5f);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("is not approximately 0.5", DescribeNegation(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<float> m3 = FloatEq(nan1_);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }
 
 TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
   Matcher<float> m1 = NanSensitiveFloatEq(2.0f);
   EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("is not approximately 2", DescribeNegation(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<float> m2 = NanSensitiveFloatEq(0.5f);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("is not approximately 0.5", DescribeNegation(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<float> m3 = NanSensitiveFloatEq(nan1_);
   EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("is not NaN", DescribeNegation(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }
 
 // Instantiate FloatingPointTest for testing doubles.
 typedef FloatingPointTest<double> DoubleTest;
 
 TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
   TestMatches(&DoubleEq);
 }
 
 TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
@@ skipping 12 matching lines @@
   // NanSensitiveDoubleEq will match NaN.
   Matcher<double> m = NanSensitiveDoubleEq(nan1_);
   EXPECT_TRUE(m.Matches(nan1_));
   EXPECT_TRUE(m.Matches(nan2_));
   EXPECT_FALSE(m.Matches(1.0));
 }
 
 TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
   Matcher<double> m1 = DoubleEq(2.0);
   EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("is not approximately 2", DescribeNegation(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<double> m2 = DoubleEq(0.5);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("is not approximately 0.5", DescribeNegation(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<double> m3 = DoubleEq(nan1_);
   EXPECT_EQ("never matches", Describe(m3));
   EXPECT_EQ("is anything", DescribeNegation(m3));
 }
 
 TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
   Matcher<double> m1 = NanSensitiveDoubleEq(2.0);
   EXPECT_EQ("is approximately 2", Describe(m1));
-  EXPECT_EQ("is not approximately 2", DescribeNegation(m1));
+  EXPECT_EQ("isn't approximately 2", DescribeNegation(m1));
 
   Matcher<double> m2 = NanSensitiveDoubleEq(0.5);
   EXPECT_EQ("is approximately 0.5", Describe(m2));
-  EXPECT_EQ("is not approximately 0.5", DescribeNegation(m2));
+  EXPECT_EQ("isn't approximately 0.5", DescribeNegation(m2));
 
   Matcher<double> m3 = NanSensitiveDoubleEq(nan1_);
   EXPECT_EQ("is NaN", Describe(m3));
-  EXPECT_EQ("is not NaN", DescribeNegation(m3));
+  EXPECT_EQ("isn't NaN", DescribeNegation(m3));
 }
 
 TEST(PointeeTest, RawPointer) {
   const Matcher<int*> m = Pointee(Ge(0));
 
   int n = 1;
   EXPECT_TRUE(m.Matches(&n));
   n = -1;
   EXPECT_FALSE(m.Matches(&n));
   EXPECT_FALSE(m.Matches(NULL));
@@ skipping 42 matching lines @@
 
   int n = 5;
   EXPECT_TRUE(m.Matches(&n));
   n = -1;
   EXPECT_FALSE(m.Matches(&n));
   EXPECT_FALSE(m.Matches(NULL));
 }
 
 TEST(PointeeTest, CanDescribeSelf) {
   const Matcher<int*> m = Pointee(Gt(3));
-  EXPECT_EQ("points to a value that is greater than 3", Describe(m));
-  EXPECT_EQ("does not point to a value that is greater than 3",
+  EXPECT_EQ("points to a value that is > 3", Describe(m));
+  EXPECT_EQ("does not point to a value that is > 3",
             DescribeNegation(m));
 }
 
 TEST(PointeeTest, CanExplainMatchResult) {
   const Matcher<const string*> m = Pointee(StartsWith("Hi"));
 
   EXPECT_EQ("", Explain(m, static_cast<const string*>(NULL)));
 
   const Matcher<int*> m2 = Pointee(GreaterThan(1));
   int n = 3;
@@ skipping 124 matching lines @@
   AStruct a;
   EXPECT_TRUE(m.Matches(a));
   a.x = -1;
   EXPECT_FALSE(m.Matches(a));
 }
 
 // Tests that Field() can describe itself.
 TEST(FieldTest, CanDescribeSelf) {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
-  EXPECT_EQ("is an object whose given field is greater than or equal to 0",
-            Describe(m));
-  EXPECT_EQ("is an object whose given field is not greater than or equal to 0",
-            DescribeNegation(m));
+  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
 }
 
 // Tests that Field() can explain the match result.
 TEST(FieldTest, CanExplainMatchResult) {
   Matcher<const AStruct&> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   a.x = 1;
   EXPECT_EQ("whose given field is 1", Explain(m, a));
 
@@ skipping 47 matching lines @@
   DerivedStruct d;
   EXPECT_TRUE(m.Matches(&d));
   d.x = -1;
   EXPECT_FALSE(m.Matches(&d));
 }
 
 // Tests that Field() can describe itself when used to match a pointer.
 TEST(FieldForPointerTest, CanDescribeSelf) {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
-  EXPECT_EQ("is an object whose given field is greater than or equal to 0",
-            Describe(m));
-  EXPECT_EQ("is an object whose given field is not greater than or equal to 0",
-            DescribeNegation(m));
+  EXPECT_EQ("is an object whose given field is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given field isn't >= 0", DescribeNegation(m));
 }
 
 // Tests that Field() can explain the result of matching a pointer.
 TEST(FieldForPointerTest, CanExplainMatchResult) {
   Matcher<const AStruct*> m = Field(&AStruct::x, Ge(0));
 
   AStruct a;
   a.x = 1;
   EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL)));
   EXPECT_EQ("which points to an object whose given field is 1", Explain(m, &a));
@@ skipping 112 matching lines @@
   AClass a;
   EXPECT_TRUE(m.Matches(a));
   a.set_n(-1);
   EXPECT_FALSE(m.Matches(a));
 }
 
 // Tests that Property() can describe itself.
 TEST(PropertyTest, CanDescribeSelf) {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
-  EXPECT_EQ("is an object whose given property is greater than or equal to 0",
-            Describe(m));
-  EXPECT_EQ("is an object whose given property "
-            "is not greater than or equal to 0", DescribeNegation(m));
+  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given property isn't >= 0",
+            DescribeNegation(m));
 }
 
 // Tests that Property() can explain the match result.
 TEST(PropertyTest, CanExplainMatchResult) {
   Matcher<const AClass&> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_EQ("whose given property is 1", Explain(m, a));
 
@@ skipping 56 matching lines @@
   EXPECT_TRUE(m.Matches(&d));
 
   d.set_n(-1);
   EXPECT_FALSE(m.Matches(&d));
 }
 
 // Tests that Property() can describe itself when used to match a pointer.
 TEST(PropertyForPointerTest, CanDescribeSelf) {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
-  EXPECT_EQ("is an object whose given property is greater than or equal to 0",
-            Describe(m));
-  EXPECT_EQ("is an object whose given property "
-            "is not greater than or equal to 0", DescribeNegation(m));
+  EXPECT_EQ("is an object whose given property is >= 0", Describe(m));
+  EXPECT_EQ("is an object whose given property isn't >= 0",
+            DescribeNegation(m));
 }
 
 // Tests that Property() can explain the result of matching a pointer.
 TEST(PropertyForPointerTest, CanExplainMatchResult) {
   Matcher<const AClass*> m = Property(&AClass::n, Ge(0));
 
   AClass a;
   a.set_n(1);
   EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL)));
   EXPECT_EQ("which points to an object whose given property is 1",
@@ skipping 17 matching lines @@
   EXPECT_FALSE(matcher.Matches(2));
 }
 
 // Tests that ResultOf() can describe itself.
 TEST(ResultOfTest, CanDescribeItself) {
   Matcher<int> matcher = ResultOf(&IntToStringFunction, StrEq("foo"));
 
   EXPECT_EQ("is mapped by the given callable to a value that "
             "is equal to \"foo\"", Describe(matcher));
   EXPECT_EQ("is mapped by the given callable to a value that "
-            "is not equal to \"foo\"", DescribeNegation(matcher));
+            "isn't equal to \"foo\"", DescribeNegation(matcher));
 }
 
 // Tests that ResultOf() can explain the match result.
 int IntFunction(int input) { return input == 42 ? 80 : 90; }
 
 TEST(ResultOfTest, CanExplainMatchResult) {
   Matcher<int> matcher = ResultOf(&IntFunction, Ge(85));
   EXPECT_EQ("which is mapped by the given callable to 90",
             Explain(matcher, 36));
 
@@ skipping 131 matching lines @@
   EXPECT_FALSE(matcher3.Matches(n2));
 }
 
 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 << "is " << (n % divider_) << " modulo "
+    *listener << "which is " << (n % divider_) << " modulo "
               << divider_;
     return (n % divider_) == 0;
   }
 
   void DescribeTo(::std::ostream* os) const {
     *os << "is divisible by " << divider_;
   }
 
   void DescribeNegationTo(::std::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("is 1 modulo 4", Explain(m, 5));
+  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("is 2 modulo 4", Explain(m, 6));
+  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("is 2 modulo 3", Explain(m, 5));
+  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("is 0 modulo 2; is 0 modulo 3", Explain(m, 6));
+  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));
@@ skipping 66 matching lines @@
 }
 
 // Tests that missing values are reported.
 TYPED_TEST(ContainerEqTest, ValueMissing) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {2, 1, 8, 5};
   TypeParam my_set(vals, vals + 6);
   TypeParam test_set(test_vals, test_vals + 4);
   const Matcher<TypeParam> m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Not in actual: 3", Explain(m, test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3",
+            Explain(m, test_set));
 }
 
 // Tests that added values are reported.
 TYPED_TEST(ContainerEqTest, ValueAdded) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 5, 8, 46};
   TypeParam my_set(vals, vals + 6);
   TypeParam test_set(test_vals, test_vals + 6);
   const Matcher<const TypeParam&> m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Only in actual: 46", Explain(m, test_set));
+  EXPECT_EQ("which has these unexpected elements: 46", Explain(m, test_set));
 }
 
 // Tests that added and missing values are reported together.
 TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 8, 46};
   TypeParam my_set(vals, vals + 6);
   TypeParam test_set(test_vals, test_vals + 5);
   const Matcher<TypeParam> m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Only in actual: 46; not in actual: 5", Explain(m, test_set));
+  EXPECT_EQ("which has these unexpected elements: 46,\n"
+            "and doesn't have these expected elements: 5",
+            Explain(m, test_set));
 }
 
 // Tests duplicated value -- expect no explanation.
 TYPED_TEST(ContainerEqTest, DuplicateDifference) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 5, 8};
   TypeParam my_set(vals, vals + 6);
   TypeParam test_set(test_vals, test_vals + 5);
   const Matcher<const TypeParam&> m = ContainerEq(my_set);
   // Depending on the container, match may be true or false
   // But in any case there should be no explanation.
   EXPECT_EQ("", Explain(m, test_set));
 }
 #endif  // GTEST_HAS_TYPED_TEST
 
 // Tests that mutliple missing values are reported.
 // Using just vector here, so order is predicatble.
 TEST(ContainerEqExtraTest, MultipleValuesMissing) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {2, 1, 5};
   std::vector<int> my_set(vals, vals + 6);
   std::vector<int> test_set(test_vals, test_vals + 3);
   const Matcher<std::vector<int> > m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Not in actual: 3, 8", Explain(m, test_set));
+  EXPECT_EQ("which doesn't have these expected elements: 3, 8",
+            Explain(m, test_set));
 }
 
 // Tests that added values are reported.
 // Using just vector here, so order is predicatble.
 TEST(ContainerEqExtraTest, MultipleValuesAdded) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 92, 3, 5, 8, 46};
   std::list<size_t> my_set(vals, vals + 6);
   std::list<size_t> test_set(test_vals, test_vals + 7);
   const Matcher<const std::list<size_t>&> m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Only in actual: 92, 46", Explain(m, test_set));
+  EXPECT_EQ("which has these unexpected elements: 92, 46",
+            Explain(m, test_set));
 }
 
 // Tests that added and missing values are reported together.
 TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 92, 46};
   std::list<size_t> my_set(vals, vals + 6);
   std::list<size_t> test_set(test_vals, test_vals + 5);
   const Matcher<const std::list<size_t> > m = ContainerEq(my_set);
   EXPECT_FALSE(m.Matches(test_set));
-  EXPECT_EQ("Only in actual: 92, 46; not in actual: 5, 8",
+  EXPECT_EQ("which has these unexpected elements: 92, 46,\n"
+            "and doesn't have these expected elements: 5, 8",
             Explain(m, test_set));
 }
 
 // Tests to see that duplicate elements are detected,
 // but (as above) not reported in the explanation.
 TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
   static const int vals[] = {1, 1, 2, 3, 5, 8};
   static const int test_vals[] = {1, 2, 3, 5, 8};
   std::vector<int> my_set(vals, vals + 6);
   std::vector<int> test_set(test_vals, test_vals + 5);
@@ skipping 12 matching lines @@
   my_map[1] = "b";
 
   std::map<int, std::string> test_map;
   test_map[0] = "aa";
   test_map[1] = "b";
 
   const Matcher<const std::map<int, std::string>&> m = ContainerEq(my_map);
   EXPECT_TRUE(m.Matches(my_map));
   EXPECT_FALSE(m.Matches(test_map));
 
-  EXPECT_EQ("Only in actual: (0, \"aa\"); not in actual: (0, \"a\")",
+  EXPECT_EQ("which has these unexpected elements: (0, \"aa\"),\n"
+            "and doesn't have these expected elements: (0, \"a\")",
             Explain(m, test_map));
 }
 
 TEST(ContainerEqExtraTest, WorksForNativeArray) {
   int a1[] = { 1, 2, 3 };
   int a2[] = { 1, 2, 3 };
   int b[] = { 1, 2, 4 };
 
   EXPECT_THAT(a1, ContainerEq(a2));
   EXPECT_THAT(a1, Not(ContainerEq(b)));
@@ skipping 362 matching lines @@
   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());
 }
 
+TEST(MatcherTupleTest, ExplainsMatchFailure) {
+  stringstream ss1;
+  ExplainMatchFailureTupleTo(make_tuple(Matcher<char>(Eq('a')), GreaterThan(5)),
+                             make_tuple('a', 10), &ss1);
+  EXPECT_EQ("", ss1.str());  // Successful match.
+
+  stringstream ss2;
+  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+                             make_tuple(2, 'b'), &ss2);
+  EXPECT_EQ("  Expected arg #0: is > 5\n"
+            "           Actual: 2, which is 3 less than 5\n"
+            "  Expected arg #1: is equal to 'a' (97)\n"
+            "           Actual: 'b' (98)\n",
+            ss2.str());  // Failed match where both arguments need explanation.
+
+  stringstream ss3;
+  ExplainMatchFailureTupleTo(make_tuple(GreaterThan(5), Matcher<char>(Eq('a'))),
+                             make_tuple(2, 'a'), &ss3);
+  EXPECT_EQ("  Expected arg #0: is > 5\n"
+            "           Actual: 2, which is 3 less than 5\n",
+            ss3.str());  // Failed match where only one argument needs
+                         // explanation.
+}
+
 }  // namespace gmock_matchers_test
 }  // namespace testing