Update gmock and gtest.

testing/gmock/test/gmock-printers_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 59 matching lines @@
  private:
   T value_;
 };
 
 // A user-defined streamable type in the global namespace.
 class StreamableInGlobal {
  public:
   virtual ~StreamableInGlobal() {}
 };
 
-inline void operator<<(::std::ostream& os, const StreamableInGlobal& x) {
+inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
   os << "StreamableInGlobal";
 }
 
 namespace foo {
 
 // A user-defined unprintable type in a user namespace.
 class UnprintableInFoo {
  public:
   UnprintableInFoo() : x_(0x12EF), y_(0xAB34), z_(0) {}
  private:
   testing::internal::Int32 x_;
   testing::internal::Int32 y_;
   double z_;
 };
 
 // A user-defined printable type in a user-chosen namespace.
 struct PrintableViaPrintTo {
   PrintableViaPrintTo() : value() {}
   int value;
 };
 
 void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
   *os << "PrintableViaPrintTo: " << x.value;
 }
 
 // A user-defined printable class template in a user-chosen namespace.
 template <typename T>
 class PrintableViaPrintToTemplate {
  public:
-  explicit PrintableViaPrintToTemplate(const T& value) : value_(value) {}
+  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
 
   const T& value() const { return value_; }
  private:
   T value_;
 };
 
 template <typename T>
 void PrintTo(const PrintableViaPrintToTemplate<T>& x, ::std::ostream* os) {
   *os << "PrintableViaPrintToTemplate: " << x.value();
 }
@@ skipping 312 matching lines @@
 // Tests printing pointers to pointers.
 TEST(PrintPointerToPointerTest, IntPointerPointer) {
   int** p = reinterpret_cast<int**>(0xABCD);
   EXPECT_EQ(PrintPointer(p), Print(p));
   p = NULL;
   EXPECT_EQ("NULL", Print(p));
 }
 
 // Tests printing (non-member) function pointers.
 
-void MyFunction(int n) {}
+void MyFunction(int /* n */) {}
 
 TEST(PrintPointerTest, NonMemberFunctionPointer) {
-  EXPECT_EQ(PrintPointer(reinterpret_cast<const void*>(&MyFunction)),
-            Print(&MyFunction));
+  // We cannot directly cast &MyFunction to const void* because the
+  // standard disallows casting between pointers to functions and
+  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
+  // this limitation.
+  EXPECT_EQ(
+      PrintPointer(reinterpret_cast<const void*>(
+          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
+      Print(&MyFunction));
   int (*p)(bool) = NULL;  // NOLINT
   EXPECT_EQ("NULL", Print(p));
 }
 
 // Tests printing member variable pointers.  Although they are called
 // pointers, they don't point to a location in the address space.
 // Their representation is implementation-defined.  Thus they will be
 // printed as raw bytes.
 
 struct Foo {
  public:
   virtual ~Foo() {}
   int MyMethod(char x) { return x + 1; }
-  virtual char MyVirtualMethod(int n) { return 'a'; }
+  virtual char MyVirtualMethod(int /* n */) { return 'a'; }
 
   int value;
 };
 
 TEST(PrintPointerTest, MemberVariablePointer) {
   EXPECT_THAT(Print(&Foo::value),
               StartsWith(Print(sizeof(&Foo::value)) + "-byte object "));
   int (Foo::*p) = NULL;  // NOLINT
   EXPECT_THAT(Print(p),
               StartsWith(Print(sizeof(p)) + "-byte object "));
@@ skipping 75 matching lines @@
 #if GTEST_HAS_GLOBAL_STRING
 // ::string.
 TEST(PrintStringTest, StringInGlobalNamespace) {
   const char s[] = "'\"\?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
   const ::string str(s, sizeof(s));
   EXPECT_EQ("\"'\\\"\\?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
             Print(str));
 }
 #endif  // GTEST_HAS_GLOBAL_STRING
 
-#if GTEST_HAS_STD_STRING
 // ::std::string.
 TEST(PrintStringTest, StringInStdNamespace) {
   const char s[] = "'\"\?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
   const ::std::string str(s, sizeof(s));
   EXPECT_EQ("\"'\\\"\\?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
             Print(str));
 }
-#endif  // GTEST_HAS_STD_STRING
 
 // Tests printing ::wstring and ::std::wstring.
 
 #if GTEST_HAS_GLOBAL_WSTRING
 // ::wstring.
 TEST(PrintWideStringTest, StringInGlobalNamespace) {
   const wchar_t s[] = L"'\"\?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
   const ::wstring str(s, sizeof(s)/sizeof(wchar_t));
   EXPECT_EQ("L\"'\\\"\\?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
             "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
@@ skipping 16 matching lines @@
 // to std::basic_ostream<Char, CharTraits> for any valid Char and
 // CharTraits types).
 
 // Tests printing a non-template type that supports generic streaming.
 
 class AllowsGenericStreaming {};
 
 template <typename Char, typename CharTraits>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreaming& a) {
+    const AllowsGenericStreaming& /* a */) {
   return os << "AllowsGenericStreaming";
 }
 
 TEST(PrintTypeWithGenericStreamingTest, NonTemplateType) {
   AllowsGenericStreaming a;
   EXPECT_EQ("AllowsGenericStreaming", Print(a));
 }
 
 // Tests printing a template type that supports generic streaming.
 
 template <typename T>
 class AllowsGenericStreamingTemplate {};
 
 template <typename Char, typename CharTraits, typename T>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingTemplate<T>& a) {
+    const AllowsGenericStreamingTemplate<T>& /* a */) {
   return os << "AllowsGenericStreamingTemplate";
 }
 
 TEST(PrintTypeWithGenericStreamingTest, TemplateType) {
   AllowsGenericStreamingTemplate<int> a;
   EXPECT_EQ("AllowsGenericStreamingTemplate", Print(a));
 }
 
 // Tests printing a type that supports generic streaming and can be
 // implicitly converted to another printable type.
 
 template <typename T>
 class AllowsGenericStreamingAndImplicitConversionTemplate {
  public:
   operator bool() const { return false; }
 };
 
 template <typename Char, typename CharTraits, typename T>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& a) {
+    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
   return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
 }
 
 TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
   AllowsGenericStreamingAndImplicitConversionTemplate<int> a;
   EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
 }
 
 // Tests printing STL containers.
 
@@ skipping 315 matching lines @@
             "<EF12 0000 34AB 0000 0000 0000 0000 0000>",
             PrintByRef(x));
 }
 
 // Tests that the universal printer prints a function pointer passed by
 // reference.
 TEST(PrintReferenceTest, HandlesFunctionPointer) {
   void (*fp)(int n) = &MyFunction;
   const string fp_pointer_string =
       PrintPointer(reinterpret_cast<const void*>(&fp));
-  const string fp_string = PrintPointer(reinterpret_cast<const void*>(fp));
+  // We cannot directly cast &MyFunction to const void* because the
+  // standard disallows casting between pointers to functions and
+  // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
+  // this limitation.
+  const string fp_string = PrintPointer(reinterpret_cast<const void*>(
+      reinterpret_cast<internal::BiggestInt>(fp)));
   EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
             PrintByRef(fp));
 }
 
 // Tests that the universal printer prints a member function pointer
 // passed by reference.
 TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
   int (Foo::*p)(char ch) = &Foo::MyMethod;
   EXPECT_THAT(PrintByRef(p),
               StartsWith("@" + PrintPointer(reinterpret_cast<const void*>(&p))
@@ skipping 107 matching lines @@
 
 TEST(UniversalTersePrintTupleFieldsToStringsTest, PrintsTersely) {
   const int n = 1;
   EXPECT_THAT(UniversalTersePrintTupleFieldsToStrings(
                   tuple<const int&, const char*>(n, "a")),
               ElementsAre("1", "\"a\""));
 }
 
 }  // namespace gmock_printers_test
 }  // namespace testing