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

testing/gmock/test/gmock-generated-matchers_test.cc

 // Copyright 2008, 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 193 matching lines @@
             Describe(m));
 }
 
 TEST(ArgsTest, DescribesNegationCorrectly) {
   const Matcher<tuple<int, char> > m = Args<1, 0>(Gt());
   EXPECT_EQ("are a tuple whose fields (#1, #0) are a pair (x, y) "
             "where x > y is false",
             DescribeNegation(m));
 }
 
+TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
+  const Matcher<tuple<bool, int, int> > m = Args<1, 2>(Eq());
+  EXPECT_EQ("whose fields (#1, #2) are (42, 42)",
+            Explain(m, make_tuple(false, 42, 42)));
+  EXPECT_EQ("whose fields (#1, #2) are (42, 43)",
+            Explain(m, make_tuple(false, 42, 43)));
+}
+
+// For testing Args<>'s explanation.
+class LessThanMatcher : public MatcherInterface<tuple<char, int> > {
+ public:
+  virtual void DescribeTo(::std::ostream* os) const {}
+
+  virtual bool MatchAndExplain(tuple<char, int> value,
+                               MatchResultListener* listener) const {
+    const int diff = get<0>(value) - get<1>(value);
+    if (diff > 0) {
+      *listener << "where the first value is " << diff
+                << " more than the second";
+    }
+    return diff < 0;
+  }
+};
+
+Matcher<tuple<char, int> > LessThan() {
+  return MakeMatcher(new LessThanMatcher);
+}
+
+TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
+  const Matcher<tuple<char, int, int> > m = Args<0, 2>(LessThan());
+  EXPECT_EQ("whose fields (#0, #2) are ('a' (97), 42), "
+            "where the first value is 55 more than the second",
+            Explain(m, make_tuple('a', 42, 42)));
+  EXPECT_EQ("whose fields (#0, #2) are ('\\0', 43)",
+            Explain(m, make_tuple('\0', 42, 43)));
+}
+
 // 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_;
   }
 
   virtual bool MatchAndExplain(int lhs,
                                MatchResultListener* listener) const {
     const int diff = lhs - rhs_;
     if (diff > 0) {
-      *listener << "is " << diff << " more than " << rhs_;
+      *listener << "which is " << diff << " more than " << rhs_;
     } else if (diff == 0) {
-      *listener << "is the same as " << rhs_;
+      *listener << "which is the same as " << rhs_;
     } else {
-      *listener << "is " << -diff << " less than " << rhs_;
+      *listener << "which is " << -diff << " less than " << rhs_;
     }
 
     return lhs > rhs_;
   }
 
  private:
   int rhs_;
 };
 
 Matcher<int> GreaterThan(int n) {
   return MakeMatcher(new GreaterThanMatcher(n));
 }
 
 // Tests for ElementsAre().
 
 // Evaluates to the number of elements in 'array'.
 #define GMOCK_ARRAY_SIZE_(array) (sizeof(array)/sizeof(array[0]))
 
 TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
   Matcher<const vector<int>&> m = ElementsAre();
   EXPECT_EQ("is empty", Describe(m));
 }
 
 TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
   Matcher<vector<int> > m = ElementsAre(Gt(5));
-  EXPECT_EQ("has 1 element that is greater than 5", Describe(m));
+  EXPECT_EQ("has 1 element that is > 5", Describe(m));
 }
 
 TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
   Matcher<list<string> > m = ElementsAre(StrEq("one"), "two");
   EXPECT_EQ("has 2 elements where\n"
-            "element 0 is equal to \"one\",\n"
-            "element 1 is equal to \"two\"", Describe(m));
+            "element #0 is equal to \"one\",\n"
+            "element #1 is equal to \"two\"", Describe(m));
 }
 
 TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
   Matcher<vector<int> > m = ElementsAre();
-  EXPECT_EQ("is not empty", DescribeNegation(m));
+  EXPECT_EQ("isn't empty", DescribeNegation(m));
 }
 
 TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElment) {
   Matcher<const list<int>& > m = ElementsAre(Gt(5));
-  EXPECT_EQ("does not have 1 element, or\n"
-            "element 0 is not greater than 5", DescribeNegation(m));
+  EXPECT_EQ("doesn't have 1 element, or\n"
+            "element #0 isn't > 5", DescribeNegation(m));
 }
 
 TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
   Matcher<const list<string>& > m = ElementsAre("one", "two");
-  EXPECT_EQ("does not have 2 elements, or\n"
-            "element 0 is not equal to \"one\", or\n"
-            "element 1 is not equal to \"two\"", DescribeNegation(m));
+  EXPECT_EQ("doesn't have 2 elements, or\n"
+            "element #0 isn't equal to \"one\", or\n"
+            "element #1 isn't equal to \"two\"", DescribeNegation(m));
 }
 
 TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
   Matcher<const list<int>& > m = ElementsAre(1, Ne(2));
 
   list<int> test_list;
   test_list.push_back(1);
   test_list.push_back(3);
   EXPECT_EQ("", Explain(m, test_list));  // No need to explain anything.
 }
 
 TEST(ElementsAreTest, ExplainsNonTrivialMatch) {
   Matcher<const vector<int>& > m =
       ElementsAre(GreaterThan(1), 0, GreaterThan(2));
 
   const int a[] = { 10, 0, 100 };
   vector<int> test_vector(a, a + GMOCK_ARRAY_SIZE_(a));
-  EXPECT_EQ("element 0 is 9 more than 1,\n"
-            "element 2 is 98 more than 2", Explain(m, test_vector));
+  EXPECT_EQ("whose element #0 matches, which is 9 more than 1,\n"
+            "and whose element #2 matches, which is 98 more than 2",
+            Explain(m, test_vector));
 }
 
 TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
   Matcher<const list<int>& > m = ElementsAre(1, 3);
 
   list<int> test_list;
   // No need to explain when the container is empty.
   EXPECT_EQ("", Explain(m, test_list));
 
   test_list.push_back(1);
-  EXPECT_EQ("has 1 element", Explain(m, test_list));
+  EXPECT_EQ("which has 1 element", Explain(m, test_list));
 }
 
 TEST(ElementsAreTest, CanExplainMismatchRightSize) {
   Matcher<const vector<int>& > m = ElementsAre(1, GreaterThan(5));
 
   vector<int> v;
   v.push_back(2);
   v.push_back(1);
-  EXPECT_EQ("element 0 doesn't match", Explain(m, v));
+  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));
 
   v[0] = 1;
-  EXPECT_EQ("element 1 doesn't match (is 4 less than 5)", Explain(m, v));
+  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
+            Explain(m, v));
 }
 
 TEST(ElementsAreTest, MatchesOneElementVector) {
   vector<string> test_vector;
   test_vector.push_back("test string");
 
   EXPECT_THAT(test_vector, ElementsAre(StrEq("test string")));
 }
 
 TEST(ElementsAreTest, MatchesOneElementList) {
@@ skipping 688 matching lines @@
   set<int> some_set;
   some_set.insert(3);
   some_set.insert(1);
   EXPECT_THAT(some_set, Not(Contains(4)));
 
   set<const char*> c_string_set;
   c_string_set.insert("hello");
   EXPECT_THAT(c_string_set, Not(Contains(string("hello").c_str())));
 }
 
-TEST(ContainsTest, DescribesItselfCorrectly) {
+TEST(ContainsTest, ExplainsMatchResultCorrectly) {
   const int a[2] = { 1, 2 };
   Matcher<const int(&)[2]> m = Contains(2);
-  EXPECT_EQ("element 1 matches", Explain(m, a));
+  EXPECT_EQ("whose element #1 matches", Explain(m, a));
 
   m = Contains(3);
   EXPECT_EQ("", Explain(m, a));
+
+  m = Contains(GreaterThan(0));
+  EXPECT_EQ("whose element #0 matches, which is 1 more than 0", Explain(m, a));
+
+  m = Contains(GreaterThan(10));
+  EXPECT_EQ("", Explain(m, a));
 }
 
-TEST(ContainsTest, ExplainsMatchResultCorrectly) {
+TEST(ContainsTest, DescribesItselfCorrectly) {
   Matcher<vector<int> > m = Contains(1);
   EXPECT_EQ("contains at least one element that is equal to 1", Describe(m));
 
   Matcher<vector<int> > m2 = Not(m);
   EXPECT_EQ("doesn't contain any element that is equal to 1", Describe(m2));
 }
 
 TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
   map<const char*, int> my_map;
   const char* bar = "a string";
@@ skipping 45 matching lines @@
   EXPECT_THAT(a, Contains(Contains(5)));
   EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5))));
   EXPECT_THAT(a, Contains(Not(Contains(5))));
 }
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 }  // namespace