Upgrade gtest to r267 and gmock to r173.

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 251 matching lines @@
   Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
   EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
 }
 
 // Tests using Invoke() with a 6-argument function.
 TEST(InvokeTest, FunctionThatTakes6Arguments) {
   Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
   EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
 }
 
+// A helper that turns the type of a C-string literal from const
+// char[N] to const char*.
+inline const char* CharPtr(const char* s) { return s; }
+
 // Tests using Invoke() with a 7-argument function.
 TEST(InvokeTest, FunctionThatTakes7Arguments) {
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*)> a =
       Invoke(Concat7);
   EXPECT_EQ("1234567",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"))));
 }
 
 // Tests using Invoke() with a 8-argument function.
 TEST(InvokeTest, FunctionThatTakes8Arguments) {
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*)> a =
       Invoke(Concat8);
   EXPECT_EQ("12345678",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7", "8")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"))));
 }
 
 // Tests using Invoke() with a 9-argument function.
 TEST(InvokeTest, FunctionThatTakes9Arguments) {
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*,
                 const char*)> a = Invoke(Concat9);
   EXPECT_EQ("123456789",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7", "8", "9")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
 }
 
 // Tests using Invoke() with a 10-argument function.
 TEST(InvokeTest, FunctionThatTakes10Arguments) {
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*,
                 const char*, const char*)> a = Invoke(Concat10);
-  EXPECT_EQ("1234567890", a.Perform(make_tuple("1", "2", "3", "4", "5", "6",
-                                               "7", "8", "9", "0")));
+  EXPECT_EQ("1234567890",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
+                                 CharPtr("0"))));
 }
 
 // Tests using Invoke() with functions with parameters declared as Unused.
 TEST(InvokeTest, FunctionWithUnusedParameters) {
   Action<int(int, int, double, const string&)> a1 =
       Invoke(SumOfFirst2);
-  EXPECT_EQ(12, a1.Perform(make_tuple(10, 2, 5.6, "hi")));
+  EXPECT_EQ(12, a1.Perform(make_tuple(10, 2, 5.6, CharPtr("hi"))));
 
   Action<int(int, int, bool, int*)> a2 =
       Invoke(SumOfFirst2);
   EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
 }
 
 // Tests using Invoke() with methods with parameters declared as Unused.
 TEST(InvokeTest, MethodWithUnusedParameters) {
   Foo foo;
   Action<int(string, bool, int, int)> a1 =
       Invoke(&foo, &Foo::SumOfLast2);
-  EXPECT_EQ(12, a1.Perform(make_tuple("hi", true, 10, 2)));
+  EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));
 
   Action<int(char, double, int, int)> a2 =
       Invoke(&foo, &Foo::SumOfLast2);
   EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
 }
 
 // Tests using Invoke() with a functor.
 TEST(InvokeTest, Functor) {
   Action<int(short, char)> a = Invoke(plus<short>());  // NOLINT
   EXPECT_EQ(3, a.Perform(make_tuple(1, 2)));
@@ skipping 58 matching lines @@
   EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
 }
 
 // Tests using Invoke() with a 7-argument method.
 TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
   Foo foo;
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*)> a =
       Invoke(&foo, &Foo::Concat7);
   EXPECT_EQ("1234567",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"))));
 }
 
 // Tests using Invoke() with a 8-argument method.
 TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
   Foo foo;
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*)> a =
       Invoke(&foo, &Foo::Concat8);
   EXPECT_EQ("12345678",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7", "8")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"))));
 }
 
 // Tests using Invoke() with a 9-argument method.
 TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
   Foo foo;
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*,
                 const char*)> a = Invoke(&foo, &Foo::Concat9);
   EXPECT_EQ("123456789",
-            a.Perform(make_tuple("1", "2", "3", "4", "5", "6", "7", "8", "9")));
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
 }
 
 // Tests using Invoke() with a 10-argument method.
 TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
   Foo foo;
   Action<string(const char*, const char*, const char*, const char*,
                 const char*, const char*, const char*, const char*,
                 const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
-  EXPECT_EQ("1234567890", a.Perform(make_tuple("1", "2", "3", "4", "5", "6",
-                                               "7", "8", "9", "0")));
+  EXPECT_EQ("1234567890",
+            a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
+                                 CharPtr("4"), CharPtr("5"), CharPtr("6"),
+                                 CharPtr("7"), CharPtr("8"), CharPtr("9"),
+                                 CharPtr("0"))));
 }
 
 // Tests using Invoke(f) as an action of a compatible type.
 TEST(InvokeMethodTest, MethodWithCompatibleType) {
   Foo foo;
   Action<long(int, short, char, bool)> a =  // NOLINT
       Invoke(&foo, &Foo::SumOf4);
   EXPECT_EQ(4444, a.Perform(make_tuple(4000, 300, 20, true)));
 }
 
@@ skipping 214 matching lines @@
   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 =
       WithArgs<0, 2>(Invoke(Binary));
   const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(s, 0.5, 2)));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, 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)));
 }
 
 // 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("0", "1", 2.5, "3", "4")));
+  EXPECT_EQ("4310", a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), 2.5,
+                                         CharPtr("3"), CharPtr("4"))));
 }
 
 // Tests using WithArgs with an action that takes 5 arguments.
 TEST(WithArgsTest, FiveArgs) {
   Action<string(const char*, const char*, const char*,
                 const char*, const char*)> a =
       WithArgs<4, 3, 2, 1, 0>(Invoke(Concat5));
-  EXPECT_EQ("43210", a.Perform(make_tuple("0", "1", "2", "3", "4")));
+  EXPECT_EQ("43210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"), CharPtr("4"))));
 }
 
 // Tests using WithArgs with an action that takes 6 arguments.
 TEST(WithArgsTest, SixArgs) {
   Action<string(const char*, const char*, const char*)> a =
       WithArgs<0, 1, 2, 2, 1, 0>(Invoke(Concat6));
-  EXPECT_EQ("012210", a.Perform(make_tuple("0", "1", "2")));
+  EXPECT_EQ("012210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"))));
 }
 
 // Tests using WithArgs with an action that takes 7 arguments.
 TEST(WithArgsTest, SevenArgs) {
   Action<string(const char*, const char*, const char*, const char*)> a =
       WithArgs<0, 1, 2, 3, 2, 1, 0>(Invoke(Concat7));
-  EXPECT_EQ("0123210", a.Perform(make_tuple("0", "1", "2", "3")));
+  EXPECT_EQ("0123210",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
 }
 
 // Tests using WithArgs with an action that takes 8 arguments.
 TEST(WithArgsTest, EightArgs) {
   Action<string(const char*, const char*, const char*, const char*)> a =
       WithArgs<0, 1, 2, 3, 0, 1, 2, 3>(Invoke(Concat8));
-  EXPECT_EQ("01230123", a.Perform(make_tuple("0", "1", "2", "3")));
+  EXPECT_EQ("01230123",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
 }
 
 // Tests using WithArgs with an action that takes 9 arguments.
 TEST(WithArgsTest, NineArgs) {
   Action<string(const char*, const char*, const char*, const char*)> a =
       WithArgs<0, 1, 2, 3, 1, 2, 3, 2, 3>(Invoke(Concat9));
-  EXPECT_EQ("012312323", a.Perform(make_tuple("0", "1", "2", "3")));
+  EXPECT_EQ("012312323",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
 }
 
 // Tests using WithArgs with an action that takes 10 arguments.
 TEST(WithArgsTest, TenArgs) {
   Action<string(const char*, const char*, const char*, const char*)> a =
       WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(Concat10));
-  EXPECT_EQ("0123210123", a.Perform(make_tuple("0", "1", "2", "3")));
+  EXPECT_EQ("0123210123",
+            a.Perform(make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
+                                 CharPtr("3"))));
 }
 
 // Tests using WithArgs with an action that is not Invoke().
 class SubstractAction : public ActionInterface<int(int, int)> {  // NOLINT
  public:
   virtual int Perform(const tuple<int, int>& args) {
     return get<0>(args) - get<1>(args);
   }
 };
 
 TEST(WithArgsTest, NonInvokeAction) {
   Action<int(const string&, int, int)> a =  // NOLINT
       WithArgs<2, 1>(MakeAction(new SubstractAction));
-  EXPECT_EQ(8, a.Perform(make_tuple("hi", 2, 10)));
+  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)));
 }
 
 // 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, s)));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(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
       WithArgs<0, 1, 3>(Invoke(Ternary));
   EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 5.6, 3)));
 }
 
 // Tests using WithArgs with an action that returns void.
@@ skipping 344 matching lines @@
 }
 
 ACTION_P2(OverloadedAction, true_value, false_value) {
   return arg0 ? true_value : false_value;
 }
 
 TEST(ActionMacroTest, CanDefineOverloadedActions) {
   typedef Action<const char*(bool, const char*)> MyAction;
 
   const MyAction a1 = OverloadedAction();
-  EXPECT_STREQ("hello", a1.Perform(make_tuple(false, "world")));
-  EXPECT_STREQ("world", a1.Perform(make_tuple(true, "world")));
+  EXPECT_STREQ("hello", a1.Perform(make_tuple(false, CharPtr("world"))));
+  EXPECT_STREQ("world", a1.Perform(make_tuple(true, CharPtr("world"))));
 
   const MyAction a2 = OverloadedAction("hi");
-  EXPECT_STREQ("hi", a2.Perform(make_tuple(false, "world")));
-  EXPECT_STREQ("world", a2.Perform(make_tuple(true, "world")));
+  EXPECT_STREQ("hi", a2.Perform(make_tuple(false, CharPtr("world"))));
+  EXPECT_STREQ("world", a2.Perform(make_tuple(true, CharPtr("world"))));
 
   const MyAction a3 = OverloadedAction("hi", "you");
-  EXPECT_STREQ("hi", a3.Perform(make_tuple(true, "world")));
-  EXPECT_STREQ("you", a3.Perform(make_tuple(false, "world")));
+  EXPECT_STREQ("hi", a3.Perform(make_tuple(true, CharPtr("world"))));
+  EXPECT_STREQ("you", a3.Perform(make_tuple(false, CharPtr("world"))));
 }
 
 // Tests ACTION_Pn where n >= 3.
 
 ACTION_P3(Plus, m, n, k) { return arg0 + m + n + k; }
 
 TEST(ActionPnMacroTest, WorksFor3Parameters) {
   Action<double(int m, bool t)> a1 = Plus(100, 20, 3.4);
   EXPECT_DOUBLE_EQ(3123.4, a1.Perform(make_tuple(3000, true)));
 
@@ skipping 71 matching lines @@
   std::string prefix_str(prefix);
   char suffix_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("ba")));
-  EXPECT_EQ("foobar", promo.Perform(make_tuple("ba")));
+  EXPECT_EQ("foobar", no_promo.Perform(make_tuple(CharPtr("ba"))));
+  EXPECT_EQ("foobar", promo.Perform(make_tuple(CharPtr("ba"))));
 }
 
 // Tests that we can partially restrict parameter types using a
 // straight-forward pattern.
 
 // Defines a generic action that doesn't restrict the types of its
 // parameters.
 ACTION_P3(ConcatImpl, a, b, c) {
   std::stringstream ss;
   ss << a << b << c;
@@ skipping 224 matching lines @@
   a1.Perform(make_tuple(t));
   EXPECT_TRUE(is_deleted);
 }
 
 TEST(DeleteArgActionTest, TenArgs) {
   bool is_deleted = false;
   DeletionTester* t = new DeletionTester(&is_deleted);
   const Action<void(bool, int, int, const char*, bool,
                     int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
   EXPECT_FALSE(is_deleted);
-  a1.Perform(make_tuple(true, 5, 6, "hi", false, 7, 8, 9, 10, t));
+  a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
   EXPECT_TRUE(is_deleted);
 }
 
 #if GTEST_HAS_EXCEPTIONS
 
 TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
   const Action<void(int n)> a = Throw('a');
   EXPECT_THROW(a.Perform(make_tuple(0)), char);
 }
 
@@ skipping 158 matching lines @@
   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()));
 }
 
 }  // namespace gmock_generated_actions_test
 }  // namespace testing