Update gmock and gtest.

testing/gmock/test/gmock-generated-actions_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 45 matching lines @@
 using testing::ByRef;
 using testing::DoAll;
 using testing::Invoke;
 using testing::Return;
 using testing::ReturnNew;
 using testing::SetArgumentPointee;
 using testing::StaticAssertTypeEq;
 using testing::Unused;
 using testing::WithArgs;
 
+// For suppressing compiler warnings on conversion possibly losing precision.
+inline short Short(short n) { return n; }  // NOLINT
+inline char Char(char ch) { return ch; }
+
 // Sample functions and functors for testing various actions.
 int Nullary() { return 1; }
 
 class NullaryFunctor {
  public:
   int operator()() { return 2; }
 };
 
 bool g_done = false;
 
@@ skipping 159 matching lines @@
                           const char*, const char*, const char*,
                           const char*, const char*, const char*,
                           const char*))> a =
       InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9", "0");
   EXPECT_EQ("1234567890", a.Perform(make_tuple(&Concat10)));
 }
 
 // Tests using InvokeArgument with a function that takes a pointer argument.
 TEST(InvokeArgumentTest, ByPointerFunction) {
   Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>(static_cast<const char*>("Hi"), 1);
+      InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
   EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
 }
 
 // Tests using InvokeArgument with a function that takes a const char*
 // by passing it a C-string literal.
 TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
   Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>("Hi", 1);
+      InvokeArgument<0>("Hi", Short(1));
   EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
 }
 
 // Tests using InvokeArgument with a function that takes a const reference.
 TEST(InvokeArgumentTest, ByConstReferenceFunction) {
   Action<bool(bool(*function)(const string& s))> a =  // NOLINT
       InvokeArgument<0>(string("Hi"));
   // When action 'a' is constructed, it makes a copy of the temporary
   // string object passed to it, so it's OK to use 'a' later, when the
   // temporary object has already died.
@@ skipping 15 matching lines @@
 
 // Tests using WithArgs and with an action that takes 1 argument.
 TEST(WithArgsTest, OneArg) {
   Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
   EXPECT_TRUE(a.Perform(make_tuple(1.5, -1)));
   EXPECT_FALSE(a.Perform(make_tuple(1.5, 1)));
 }
 
 // Tests using WithArgs with an action that takes 2 arguments.
 TEST(WithArgsTest, TwoArgs) {
-  Action<const char*(const char* s, double x, int n)> a =
+  Action<const char*(const char* s, double x, short n)> a =
       WithArgs<0, 2>(Invoke(Binary));
   const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, 2)));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
 }
 
 // Tests using WithArgs with an action that takes 3 arguments.
 TEST(WithArgsTest, ThreeArgs) {
   Action<int(int, double, char, short)> a =  // NOLINT
       WithArgs<0, 2, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, 20, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
 }
 
 // Tests using WithArgs with an action that takes 4 arguments.
 TEST(WithArgsTest, FourArgs) {
   Action<string(const char*, const char*, double, const char*, const char*)> a =
       WithArgs<4, 3, 1, 0>(Invoke(Concat4));
   EXPECT_EQ("4310", a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), 2.5,
                                          CharPtr("3"), CharPtr("4"))));
 }
 
@@ skipping 62 matching lines @@
 TEST(WithArgsTest, NonInvokeAction) {
   Action<int(const string&, int, int)> a =  // NOLINT
       WithArgs<2, 1>(MakeAction(new SubstractAction));
   EXPECT_EQ(8, a.Perform(make_tuple(CharPtr("hi"), 2, 10)));
 }
 
 // Tests using WithArgs to pass all original arguments in the original order.
 TEST(WithArgsTest, Identity) {
   Action<int(int x, char y, short z)> a =  // NOLINT
       WithArgs<0, 1, 2>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
 }
 
 // Tests using WithArgs with repeated arguments.
 TEST(WithArgsTest, RepeatedArguments) {
   Action<int(bool, int m, int n)> a =  // NOLINT
       WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
   EXPECT_EQ(4, a.Perform(make_tuple(false, 1, 10)));
 }
 
 // Tests using WithArgs with reversed argument order.
 TEST(WithArgsTest, ReversedArgumentOrder) {
   Action<const char*(short n, const char* input)> a =  // NOLINT
       WithArgs<1, 0>(Invoke(Binary));
   const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(2, CharPtr(s))));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
 }
 
 // Tests using WithArgs with compatible, but not identical, argument types.
 TEST(WithArgsTest, ArgsOfCompatibleTypes) {
-  Action<long(short x, int y, double z, char c)> a =  // NOLINT
+  Action<long(short x, char y, double z, char c)> a =  // NOLINT
       WithArgs<0, 1, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 5.6, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
 }
 
 // Tests using WithArgs with an action that returns void.
 TEST(WithArgsTest, VoidAction) {
   Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
   g_done = false;
   a.Perform(make_tuple(1.5, 'a', 3));
   EXPECT_TRUE(g_done);
 }
 
@@ skipping 161 matching lines @@
   EXPECT_EQ(2, n);
   EXPECT_EQ('a', a);
   EXPECT_EQ('b', b);
   EXPECT_EQ('c', c);
   EXPECT_EQ('d', d);
   EXPECT_EQ('e', e);
   EXPECT_EQ('f', f);
   EXPECT_EQ('g', g);
 }
 
+// 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 ACTION*() macro family.
 
 // Tests that ACTION() can define an action that doesn't reference the
 // mock function arguments.
 ACTION(Return5) { return 5; }
 
 TEST(ActionMacroTest, WorksWhenNotReferencingArguments) {
   Action<double()> a1 = Return5();
   EXPECT_DOUBLE_EQ(5, a1.Perform(make_tuple()));
 
@@ skipping 30 matching lines @@
 // via args_type and args.
 ACTION(Sum2) {
   StaticAssertTypeEq< ::std::tr1::tuple<int, char, int*>, args_type>();
   args_type args_copy = args;
   return get<0>(args_copy) + get<1>(args_copy);
 }
 
 TEST(ActionMacroTest, CanReferenceArgumentTuple) {
   Action<int(int, char, int*)> a1 = Sum2();
   int dummy = 0;
-  EXPECT_EQ(11, a1.Perform(make_tuple(5, static_cast<char>(6), &dummy)));
+  EXPECT_EQ(11, a1.Perform(make_tuple(5, Char(6), &dummy)));
 }
 
 // Tests that the body of ACTION() can reference the mock function
 // type.
 int Dummy(bool flag) { return flag? 1 : 0; }
 
 ACTION(InvokeDummy) {
   StaticAssertTypeEq<int(bool), function_type>();
   function_type* fp = &Dummy;
   return (*fp)(true);
@@ skipping 77 matching lines @@
 // Tests that the body of ACTION_P can reference the argument types
 // and the parameter type.
 ACTION_P(TypedPlus, n) {
   arg0_type t1 = arg0;
   n_type t2 = n;
   return t1 + t2;
 }
 
 TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
   Action<int(char m, bool t)> a1 = TypedPlus(9);
-  EXPECT_EQ(10, a1.Perform(make_tuple(static_cast<char>(1), true)));
+  EXPECT_EQ(10, a1.Perform(make_tuple(Char(1), true)));
 }
 
 // Tests that a parameterized action can be used in any mock function
 // whose type is compatible.
 TEST(ActionPMacroTest, WorksInCompatibleMockFunction) {
   Action<std::string(const std::string& s)> a1 = Plus("tail");
   const std::string re = "re";
   EXPECT_EQ("retail", a1.Perform(make_tuple(re)));
 }
 
@@ skipping 99 matching lines @@
   Action<int(int)> a1 = Plus(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   EXPECT_EQ(10 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10,
             a1.Perform(make_tuple(10)));
 }
 
 // Tests that the action body can promote the parameter types.
 
 ACTION_P2(PadArgument, 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 prefix_str + arg0 + suffix_char;
 }
 
 TEST(ActionPnMacroTest, SimpleTypePromotion) {
   Action<std::string(const char*)> no_promo =
       PadArgument(std::string("foo"), 'r');
   Action<std::string(const char*)> promo =
       PadArgument("foo", static_cast<int>('r'));
   EXPECT_EQ("foobar", no_promo.Perform(make_tuple(CharPtr("ba"))));
   EXPECT_EQ("foobar", promo.Perform(make_tuple(CharPtr("ba"))));
@@ skipping 206 matching lines @@
                 AND_0_VALUE_PARAMS()) {
   delete std::tr1::get<k>(args);
 }
 
 // Resets a bool variable in the destructor.
 class BoolResetter {
  public:
   explicit BoolResetter(bool* value) : value_(value) {}
   ~BoolResetter() { *value_ = false; }
  private:
-  bool* const value_;
+  bool* value_;
 };
 
 TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
   const Action<void(int*, BoolResetter*)> a = MyDeleteArg<1>();
   int n = 0;
   bool b = true;
   BoolResetter* resetter = new BoolResetter(&b);
   a.Perform(make_tuple(&n, resetter));
   EXPECT_FALSE(b);  // Verifies that resetter is deleted.
 }
@@ skipping 91 matching lines @@
   const Action<int()> a2 = ReturnSum<int>(1, 2);
   const Action<int()> a3 = ReturnSum<int>(1, 2, 3);
   const Action<int()> a4 = ReturnSum<int, 10000>(2000, 300, 40, 5);
   EXPECT_EQ(0, a0.Perform(make_tuple()));
   EXPECT_EQ(1, a1.Perform(make_tuple()));
   EXPECT_EQ(3, a2.Perform(make_tuple()));
   EXPECT_EQ(6, a3.Perform(make_tuple()));
   EXPECT_EQ(12345, a4.Perform(make_tuple()));
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 }  // namespace gmock_generated_actions_test
 }  // namespace testing