Update gmock and gtest.

testing/gmock/test/gmock_link_test.h

 // Copyright 2009, 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 188 matching lines @@
   virtual int& IntRefFromString(char* str) = 0;
   virtual void VoidFromFunc(void(*)(char*)) = 0;
   virtual void VoidFromIntRef(int& n) = 0;
   virtual void VoidFromFloat(float n) = 0;
   virtual void VoidFromDouble(double n) = 0;
   virtual void VoidFromVector(const std::vector<int>& v) = 0;
 };
 
 class Mock: public Interface {
  public:
+  Mock() {}
+
   MOCK_METHOD1(VoidFromString, void(char* str));
   MOCK_METHOD1(StringFromString, char*(char* str));
   MOCK_METHOD1(IntFromString, int(char* str));
   MOCK_METHOD1(IntRefFromString, int&(char* str));
   MOCK_METHOD1(VoidFromFunc, void(void(*func)(char* str)));
   MOCK_METHOD1(VoidFromIntRef, void(int& n));
   MOCK_METHOD1(VoidFromFloat, void(float n));
   MOCK_METHOD1(VoidFromDouble, void(double n));
   MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
 };
 
 class InvokeHelper {
  public:
   static void StaticVoidFromVoid() {}
   void VoidFromVoid() {}
   static void StaticVoidFromString(char*) {}
   void VoidFromString(char*) {}
   static int StaticIntFromString(char*) { return 1; }
   static bool StaticBoolFromString(const char*) { return true; }
 };
 
 class FieldHelper {
  public:
-  FieldHelper(int field) : field_(field) {}
+  FieldHelper(int a_field) : field_(a_field) {}
   int field() const { return field_; }
   int field_;  // NOLINT -- need external access to field_ to test
                //           the Field matcher.
 };
 
 // Tests the linkage of the ReturnVoid action.
 TEST(LinkTest, TestReturnVoid) {
   Mock mock;
 
   EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
@@ skipping 160 matching lines @@
 #if GTEST_HAS_EXCEPTIONS
 // Tests the linkage of the Throw action.
 TEST(LinkTest, TestThrow) {
   Mock mock;
 
   EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
   EXPECT_THROW(mock.VoidFromString(NULL), int);
 }
 #endif  // GTEST_HAS_EXCEPTIONS
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Tests the linkage of actions created using ACTION macro.
 namespace {
 ACTION(Return1) { return 1; }
 }
 
 TEST(LinkTest, TestActionMacro) {
   Mock mock;
 
   EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
   mock.IntFromString(NULL);
@@ skipping 11 matching lines @@
   mock.IntFromString(NULL);
 }
 
 // Tests the linkage of actions created using ACTION_P2 macro.
 namespace {
 ACTION_P2(ReturnEqualsEitherOf, first, second) {
   return arg0 == first || arg0 == second;
 }
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 TEST(LinkTest, TestActionP2Macro) {
   Mock mock;
   char ch = 'x';
 
   EXPECT_CALL(mock, IntFromString(_))
       .WillOnce(ReturnEqualsEitherOf("one", "two"));
   mock.IntFromString(&ch);
 }
 
 // Tests the linkage of the "_" matcher.
@@ skipping 191 matching lines @@
   EXPECT_FALSE(m.Matches(1));
 }
 
 // Tests the linkage of the MatcherCast<T>() function.
 TEST(LinkTest, TestMatcherCast) {
   Matcher<const char*> m = MatcherCast<const char*>(_);
   EXPECT_TRUE(m.Matches(NULL));
 }
 
 #endif  // GMOCK_TEST_GMOCK_LINK_TEST_H_