Update gmock and gtest.

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 205 matching lines @@
   virtual void ExplainMatchResultTo(int lhs, ::std::ostream* os) const {
     const int diff = lhs - rhs_;
     if (diff > 0) {
       *os << "is " << diff << " more than " << rhs_;
     } else if (diff == 0) {
       *os << "is the same as " << rhs_;
     } else {
       *os << "is " << -diff << " less than " << rhs_;
     }
   }
+
  private:
-  const int rhs_;
+  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]))
@@ skipping 166 matching lines @@
   EXPECT_FALSE(m.Matches(test_vector));
 }
 
 TEST(ElementsAreTest, WorksForNestedContainer) {
   const char* strings[] = {
     "Hi",
     "world"
   };
 
   vector<list<char> > nested;
-  for (int i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
+  for (size_t i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
     nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
   }
 
   EXPECT_THAT(nested, ElementsAre(ElementsAre('H', Ne('e')),
                                   ElementsAre('w', 'o', _, _, 'd')));
   EXPECT_THAT(nested, Not(ElementsAre(ElementsAre('H', 'e'),
                                       ElementsAre('w', 'o', _, _, 'd'))));
 }
 
 TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
@@ skipping 14 matching lines @@
 
 TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
   int array[] = { 0, 1, 2 };
   EXPECT_THAT(array, ElementsAre(0, 1, _));
   EXPECT_THAT(array, Not(ElementsAre(1, _, _)));
   EXPECT_THAT(array, Not(ElementsAre(0, _)));
 }
 
 class NativeArrayPassedAsPointerAndSize {
  public:
+  NativeArrayPassedAsPointerAndSize() {}
+
   MOCK_METHOD2(Helper, void(int* array, int size));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
 };
 
 TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
   int array[] = { 0, 1 };
   ::std::tr1::tuple<int*, size_t> array_as_tuple(array, 2);
   EXPECT_THAT(array_as_tuple, ElementsAre(0, 1));
   EXPECT_THAT(array_as_tuple, Not(ElementsAre(0)));
 
   NativeArrayPassedAsPointerAndSize helper;
   EXPECT_CALL(helper, Helper(_, _))
@@ skipping 83 matching lines @@
 
   EXPECT_EQ("is even", Describe(m));
   EXPECT_EQ("not (is even)", DescribeNegation(m));
   EXPECT_EQ("", Explain(m, 6));
   EXPECT_EQ("", Explain(m, 7));
 }
 
 // Tests that the description string supplied to MATCHER() must be
 // valid.
 
-MATCHER(HasBadDescription, "Invalid%") { return true; }
+MATCHER(HasBadDescription, "Invalid%") {
+  // Uses arg to suppress "unused parameter" warning.
+  return arg==arg;
+}
 
 TEST(MatcherMacroTest,
      CreatingMatcherWithBadDescriptionGeneratesNonfatalFailure) {
   EXPECT_NONFATAL_FAILURE(
       HasBadDescription(),
       "Syntax error at index 7 in matcher description \"Invalid%\": "
       "use \"%%\" instead of \"%\" to print \"%\".");
 }
 
-MATCHER(HasGoodDescription, "good") { return true; }
+MATCHER(HasGoodDescription, "good") { return arg==arg; }
 
 TEST(MatcherMacroTest, AcceptsValidDescription) {
   const Matcher<int> m = HasGoodDescription();
   EXPECT_EQ("good", Describe(m));
 }
 
 // Tests that the body of MATCHER() can reference the type of the
 // value being matched.
 
 MATCHER(IsEmptyString, "") {
@@ skipping 61 matching lines @@
 
 TEST(MatcherPMacroTest,
      CreatingMatcherWithBadDescriptionGeneratesNonfatalFailure) {
   EXPECT_NONFATAL_FAILURE(
       HasBadDescription1(2),
       "Syntax error at index 6 in matcher description \"not %(m)s good\": "
       "\"m\" is an invalid parameter name.");
 }
 
 
-MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return true; }
+MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return arg==arg; }
 
 TEST(MatcherPMacroTest, AcceptsValidDescription) {
   const Matcher<int> m = HasGoodDescription1(5);
   EXPECT_EQ("good 5", Describe(m));
 }
 
 // Tests that the description is calculated correctly from the matcher name.
 MATCHER_P(_is_Greater_Than32and_, n, "") { return arg > 32 && arg > n; }
 
 TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
@@ skipping 46 matching lines @@
 TEST(MatcherPnMacroTest,
      CreatingMatcherWithBadDescriptionGeneratesNonfatalFailure) {
   EXPECT_NONFATAL_FAILURE(
       HasBadDescription2(3, 4),
       "Syntax error at index 4 in matcher description \"not %(good\": "
       "an interpolation must end with \")s\", but \"%(good\" does not.");
 }
 
 MATCHER_P2(HasComplexDescription, foo, bar,
            "is as complex as %(foo)s %(bar)s (i.e. %(*)s or %%%(foo)s!)") {
-  return true;
+  return arg==arg;
 }
 
 TEST(MatcherPnMacroTest, AcceptsValidDescription) {
   Matcher<int> m = HasComplexDescription(100, "ducks");
   EXPECT_EQ("is as complex as 100 \"ducks\" (i.e. (100, \"ducks\") or %100!)",
             Describe(m));
 }
 
 // Tests that the body of MATCHER_Pn() can reference the parameter
 // types.
@@ skipping 131 matching lines @@
 
   EXPECT_THAT(124, Not(EqualsSumOf(100L, 20, static_cast<char>(3))));
   EXPECT_THAT("abcde", Not(EqualsSumOf(::std::string("a"), "b", 'c', "d")));
 }
 
 // Tests that the matcher body can promote the parameter types.
 
 MATCHER_P2(EqConcat, prefix, suffix, "") {
   // The following lines promote the two parameters to desired types.
   std::string prefix_str(prefix);
-  char suffix_char(suffix);
+  char suffix_char = static_cast<char>(suffix);
   return arg == prefix_str + suffix_char;
 }
 
 TEST(MatcherPnMacroTest, SimpleTypePromotion) {
   Matcher<std::string> no_promo =
       EqConcat(std::string("foo"), 't');
   Matcher<const std::string&> promo =
       EqConcat("foo", static_cast<int>('t'));
   EXPECT_FALSE(no_promo.Matches("fool"));
   EXPECT_FALSE(promo.Matches("fool"));
@@ skipping 162 matching lines @@
 
 TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
   int a[][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
   EXPECT_THAT(a, Contains(ElementsAre(4, 5, 6)));
   EXPECT_THAT(a, Contains(Contains(5)));
   EXPECT_THAT(a, Not(Contains(ElementsAre(3, 4, 5))));
   EXPECT_THAT(a, Contains(Not(Contains(5))));
 }
 
 }  // namespace