ceph/src/rapidjson/thirdparty/gtest/googlemock/test/gmock-more-actions_test.cc

   1 // Copyright 2007, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // Author: wan@google.com (Zhanyong Wan)
  31
  32 // Google Mock - a framework for writing C++ mock classes.
  33 //
  34 // This file tests the built-in actions in gmock-more-actions.h.
  35
  36 #include "gmock/gmock-more-actions.h"
  37
  38 #include <functional>
  39 #include <sstream>
  40 #include <string>
  41 #include "gmock/gmock.h"
  42 #include "gtest/gtest.h"
  43 #include "gtest/internal/gtest-linked_ptr.h"
  44
  45 namespace testing {
  46 namespace gmock_more_actions_test {
  47
  48 using ::std::plus;
  49 using ::std::string;
  50 using testing::get;
  51 using testing::make_tuple;
  52 using testing::tuple;
  53 using testing::tuple_element;
  54 using testing::_;
  55 using testing::Action;
  56 using testing::ActionInterface;
  57 using testing::DeleteArg;
  58 using testing::Invoke;
  59 using testing::Return;
  60 using testing::ReturnArg;
  61 using testing::ReturnPointee;
  62 using testing::SaveArg;
  63 using testing::SaveArgPointee;
  64 using testing::SetArgReferee;
  65 using testing::StaticAssertTypeEq;
  66 using testing::Unused;
  67 using testing::WithArg;
  68 using testing::WithoutArgs;
  69 using testing::internal::linked_ptr;
  70
  71 // For suppressing compiler warnings on conversion possibly losing precision.
  72 inline short Short(short n) { return n; }  // NOLINT
  73 inline char Char(char ch) { return ch; }
  74
  75 // Sample functions and functors for testing Invoke() and etc.
  76 int Nullary() { return 1; }
  77
  78 class NullaryFunctor {
  79  public:
  80   int operator()() { return 2; }
  81 };
  82
  83 bool g_done = false;
  84 void VoidNullary() { g_done = true; }
  85
  86 class VoidNullaryFunctor {
  87  public:
  88   void operator()() { g_done = true; }
  89 };
  90
  91 bool Unary(int x) { return x < 0; }
  92
  93 const char* Plus1(const char* s) { return s + 1; }
  94
  95 void VoidUnary(int /* n */) { g_done = true; }
  96
  97 bool ByConstRef(const string& s) { return s == "Hi"; }
  98
  99 const double g_double = 0;
 100 bool ReferencesGlobalDouble(const double& x) { return &x == &g_double; }
 101
 102 string ByNonConstRef(string& s) { return s += "+"; }  // NOLINT
 103
 104 struct UnaryFunctor {
 105   int operator()(bool x) { return x ? 1 : -1; }
 106 };
 107
 108 const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
 109
 110 void VoidBinary(int, char) { g_done = true; }
 111
 112 int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
 113
 114 void VoidTernary(int, char, bool) { g_done = true; }
 115
 116 int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
 117
 118 int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
 119
 120 void VoidFunctionWithFourArguments(char, int, float, double) { g_done = true; }
 121
 122 string Concat4(const char* s1, const char* s2, const char* s3,
 123                const char* s4) {
 124   return string(s1) + s2 + s3 + s4;
 125 }
 126
 127 int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
 128
 129 struct SumOf5Functor {
 130   int operator()(int a, int b, int c, int d, int e) {
 131     return a + b + c + d + e;
 132   }
 133 };
 134
 135 string Concat5(const char* s1, const char* s2, const char* s3,
 136                const char* s4, const char* s5) {
 137   return string(s1) + s2 + s3 + s4 + s5;
 138 }
 139
 140 int SumOf6(int a, int b, int c, int d, int e, int f) {
 141   return a + b + c + d + e + f;
 142 }
 143
 144 struct SumOf6Functor {
 145   int operator()(int a, int b, int c, int d, int e, int f) {
 146     return a + b + c + d + e + f;
 147   }
 148 };
 149
 150 string Concat6(const char* s1, const char* s2, const char* s3,
 151                const char* s4, const char* s5, const char* s6) {
 152   return string(s1) + s2 + s3 + s4 + s5 + s6;
 153 }
 154
 155 string Concat7(const char* s1, const char* s2, const char* s3,
 156                const char* s4, const char* s5, const char* s6,
 157                const char* s7) {
 158   return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
 159 }
 160
 161 string Concat8(const char* s1, const char* s2, const char* s3,
 162                const char* s4, const char* s5, const char* s6,
 163                const char* s7, const char* s8) {
 164   return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
 165 }
 166
 167 string Concat9(const char* s1, const char* s2, const char* s3,
 168                const char* s4, const char* s5, const char* s6,
 169                const char* s7, const char* s8, const char* s9) {
 170   return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
 171 }
 172
 173 string Concat10(const char* s1, const char* s2, const char* s3,
 174                 const char* s4, const char* s5, const char* s6,
 175                 const char* s7, const char* s8, const char* s9,
 176                 const char* s10) {
 177   return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
 178 }
 179
 180 class Foo {
 181  public:
 182   Foo() : value_(123) {}
 183
 184   int Nullary() const { return value_; }
 185
 186   short Unary(long x) { return static_cast<short>(value_ + x); }  // NOLINT
 187
 188   string Binary(const string& str, char c) const { return str + c; }
 189
 190   int Ternary(int x, bool y, char z) { return value_ + x + y*z; }
 191
 192   int SumOf4(int a, int b, int c, int d) const {
 193     return a + b + c + d + value_;
 194   }
 195
 196   int SumOfLast2(Unused, Unused, int a, int b) const { return a + b; }
 197
 198   int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d + e; }
 199
 200   int SumOf6(int a, int b, int c, int d, int e, int f) {
 201     return a + b + c + d + e + f;
 202   }
 203
 204   string Concat7(const char* s1, const char* s2, const char* s3,
 205                  const char* s4, const char* s5, const char* s6,
 206                  const char* s7) {
 207     return string(s1) + s2 + s3 + s4 + s5 + s6 + s7;
 208   }
 209
 210   string Concat8(const char* s1, const char* s2, const char* s3,
 211                  const char* s4, const char* s5, const char* s6,
 212                  const char* s7, const char* s8) {
 213     return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8;
 214   }
 215
 216   string Concat9(const char* s1, const char* s2, const char* s3,
 217                  const char* s4, const char* s5, const char* s6,
 218                  const char* s7, const char* s8, const char* s9) {
 219     return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9;
 220   }
 221
 222   string Concat10(const char* s1, const char* s2, const char* s3,
 223                   const char* s4, const char* s5, const char* s6,
 224                   const char* s7, const char* s8, const char* s9,
 225                   const char* s10) {
 226     return string(s1) + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10;
 227   }
 228
 229  private:
 230   int value_;
 231 };
 232
 233 // Tests using Invoke() with a nullary function.
 234 TEST(InvokeTest, Nullary) {
 235   Action<int()> a = Invoke(Nullary);  // NOLINT
 236   EXPECT_EQ(1, a.Perform(make_tuple()));
 237 }
 238
 239 // Tests using Invoke() with a unary function.
 240 TEST(InvokeTest, Unary) {
 241   Action<bool(int)> a = Invoke(Unary);  // NOLINT
 242   EXPECT_FALSE(a.Perform(make_tuple(1)));
 243   EXPECT_TRUE(a.Perform(make_tuple(-1)));
 244 }
 245
 246 // Tests using Invoke() with a binary function.
 247 TEST(InvokeTest, Binary) {
 248   Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
 249   const char* p = "Hello";
 250   EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
 251 }
 252
 253 // Tests using Invoke() with a ternary function.
 254 TEST(InvokeTest, Ternary) {
 255   Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
 256   EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
 257 }
 258
 259 // Tests using Invoke() with a 4-argument function.
 260 TEST(InvokeTest, FunctionThatTakes4Arguments) {
 261   Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
 262   EXPECT_EQ(1234, a.Perform(make_tuple(1000, 200, 30, 4)));
 263 }
 264
 265 // Tests using Invoke() with a 5-argument function.
 266 TEST(InvokeTest, FunctionThatTakes5Arguments) {
 267   Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
 268   EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
 269 }
 270
 271 // Tests using Invoke() with a 6-argument function.
 272 TEST(InvokeTest, FunctionThatTakes6Arguments) {
 273   Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
 274   EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
 275 }
 276
 277 // A helper that turns the type of a C-string literal from const
 278 // char[N] to const char*.
 279 inline const char* CharPtr(const char* s) { return s; }
 280
 281 // Tests using Invoke() with a 7-argument function.
 282 TEST(InvokeTest, FunctionThatTakes7Arguments) {
 283   Action<string(const char*, const char*, const char*, const char*,
 284                 const char*, const char*, const char*)> a =
 285       Invoke(Concat7);
 286   EXPECT_EQ("1234567",
 287             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 288                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 289                                  CharPtr("7"))));
 290 }
 291
 292 // Tests using Invoke() with a 8-argument function.
 293 TEST(InvokeTest, FunctionThatTakes8Arguments) {
 294   Action<string(const char*, const char*, const char*, const char*,
 295                 const char*, const char*, const char*, const char*)> a =
 296       Invoke(Concat8);
 297   EXPECT_EQ("12345678",
 298             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 299                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 300                                  CharPtr("7"), CharPtr("8"))));
 301 }
 302
 303 // Tests using Invoke() with a 9-argument function.
 304 TEST(InvokeTest, FunctionThatTakes9Arguments) {
 305   Action<string(const char*, const char*, const char*, const char*,
 306                 const char*, const char*, const char*, const char*,
 307                 const char*)> a = Invoke(Concat9);
 308   EXPECT_EQ("123456789",
 309             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 310                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 311                                  CharPtr("7"), CharPtr("8"), CharPtr("9"))));
 312 }
 313
 314 // Tests using Invoke() with a 10-argument function.
 315 TEST(InvokeTest, FunctionThatTakes10Arguments) {
 316   Action<string(const char*, const char*, const char*, const char*,
 317                 const char*, const char*, const char*, const char*,
 318                 const char*, const char*)> a = Invoke(Concat10);
 319   EXPECT_EQ("1234567890",
 320             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 321                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 322                                  CharPtr("7"), CharPtr("8"), CharPtr("9"),
 323                                  CharPtr("0"))));
 324 }
 325
 326 // Tests using Invoke() with functions with parameters declared as Unused.
 327 TEST(InvokeTest, FunctionWithUnusedParameters) {
 328   Action<int(int, int, double, const string&)> a1 =
 329       Invoke(SumOfFirst2);
 330   string s("hi");
 331   EXPECT_EQ(12, a1.Perform(
 332     tuple<int, int, double, const string&>(10, 2, 5.6, s)));
 333
 334   Action<int(int, int, bool, int*)> a2 =
 335       Invoke(SumOfFirst2);
 336   EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL))));
 337 }
 338
 339 // Tests using Invoke() with methods with parameters declared as Unused.
 340 TEST(InvokeTest, MethodWithUnusedParameters) {
 341   Foo foo;
 342   Action<int(string, bool, int, int)> a1 =
 343       Invoke(&foo, &Foo::SumOfLast2);
 344   EXPECT_EQ(12, a1.Perform(make_tuple(CharPtr("hi"), true, 10, 2)));
 345
 346   Action<int(char, double, int, int)> a2 =
 347       Invoke(&foo, &Foo::SumOfLast2);
 348   EXPECT_EQ(23, a2.Perform(make_tuple('a', 2.5, 20, 3)));
 349 }
 350
 351 // Tests using Invoke() with a functor.
 352 TEST(InvokeTest, Functor) {
 353   Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
 354   EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
 355 }
 356
 357 // Tests using Invoke(f) as an action of a compatible type.
 358 TEST(InvokeTest, FunctionWithCompatibleType) {
 359   Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
 360   EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
 361 }
 362
 363 // Tests using Invoke() with an object pointer and a method pointer.
 364
 365 // Tests using Invoke() with a nullary method.
 366 TEST(InvokeMethodTest, Nullary) {
 367   Foo foo;
 368   Action<int()> a = Invoke(&foo, &Foo::Nullary);  // NOLINT
 369   EXPECT_EQ(123, a.Perform(make_tuple()));
 370 }
 371
 372 // Tests using Invoke() with a unary method.
 373 TEST(InvokeMethodTest, Unary) {
 374   Foo foo;
 375   Action<short(long)> a = Invoke(&foo, &Foo::Unary);  // NOLINT
 376   EXPECT_EQ(4123, a.Perform(make_tuple(4000)));
 377 }
 378
 379 // Tests using Invoke() with a binary method.
 380 TEST(InvokeMethodTest, Binary) {
 381   Foo foo;
 382   Action<string(const string&, char)> a = Invoke(&foo, &Foo::Binary);
 383   string s("Hell");
 384   EXPECT_EQ("Hello", a.Perform(
 385       tuple<const string&, char>(s, 'o')));
 386 }
 387
 388 // Tests using Invoke() with a ternary method.
 389 TEST(InvokeMethodTest, Ternary) {
 390   Foo foo;
 391   Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary);  // NOLINT
 392   EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
 393 }
 394
 395 // Tests using Invoke() with a 4-argument method.
 396 TEST(InvokeMethodTest, MethodThatTakes4Arguments) {
 397   Foo foo;
 398   Action<int(int, int, int, int)> a = Invoke(&foo, &Foo::SumOf4);  // NOLINT
 399   EXPECT_EQ(1357, a.Perform(make_tuple(1000, 200, 30, 4)));
 400 }
 401
 402 // Tests using Invoke() with a 5-argument method.
 403 TEST(InvokeMethodTest, MethodThatTakes5Arguments) {
 404   Foo foo;
 405   Action<int(int, int, int, int, int)> a = Invoke(&foo, &Foo::SumOf5);  // NOLINT
 406   EXPECT_EQ(12345, a.Perform(make_tuple(10000, 2000, 300, 40, 5)));
 407 }
 408
 409 // Tests using Invoke() with a 6-argument method.
 410 TEST(InvokeMethodTest, MethodThatTakes6Arguments) {
 411   Foo foo;
 412   Action<int(int, int, int, int, int, int)> a =  // NOLINT
 413       Invoke(&foo, &Foo::SumOf6);
 414   EXPECT_EQ(123456, a.Perform(make_tuple(100000, 20000, 3000, 400, 50, 6)));
 415 }
 416
 417 // Tests using Invoke() with a 7-argument method.
 418 TEST(InvokeMethodTest, MethodThatTakes7Arguments) {
 419   Foo foo;
 420   Action<string(const char*, const char*, const char*, const char*,
 421                 const char*, const char*, const char*)> a =
 422       Invoke(&foo, &Foo::Concat7);
 423   EXPECT_EQ("1234567",
 424             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 425                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 426                                  CharPtr("7"))));
 427 }
 428
 429 // Tests using Invoke() with a 8-argument method.
 430 TEST(InvokeMethodTest, MethodThatTakes8Arguments) {
 431   Foo foo;
 432   Action<string(const char*, const char*, const char*, const char*,
 433                 const char*, const char*, const char*, const char*)> a =
 434       Invoke(&foo, &Foo::Concat8);
 435   EXPECT_EQ("12345678",
 436             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 437                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 438                                  CharPtr("7"), CharPtr("8"))));
 439 }
 440
 441 // Tests using Invoke() with a 9-argument method.
 442 TEST(InvokeMethodTest, MethodThatTakes9Arguments) {
 443   Foo foo;
 444   Action<string(const char*, const char*, const char*, const char*,
 445                 const char*, const char*, const char*, const char*,
 446                 const char*)> a = Invoke(&foo, &Foo::Concat9);
 447   EXPECT_EQ("123456789",
 448             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 449                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 450                                  CharPtr("7"), CharPtr("8"), CharPtr("9"))));
 451 }
 452
 453 // Tests using Invoke() with a 10-argument method.
 454 TEST(InvokeMethodTest, MethodThatTakes10Arguments) {
 455   Foo foo;
 456   Action<string(const char*, const char*, const char*, const char*,
 457                 const char*, const char*, const char*, const char*,
 458                 const char*, const char*)> a = Invoke(&foo, &Foo::Concat10);
 459   EXPECT_EQ("1234567890",
 460             a.Perform(make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
 461                                  CharPtr("4"), CharPtr("5"), CharPtr("6"),
 462                                  CharPtr("7"), CharPtr("8"), CharPtr("9"),
 463                                  CharPtr("0"))));
 464 }
 465
 466 // Tests using Invoke(f) as an action of a compatible type.
 467 TEST(InvokeMethodTest, MethodWithCompatibleType) {
 468   Foo foo;
 469   Action<long(int, short, char, bool)> a =  // NOLINT
 470       Invoke(&foo, &Foo::SumOf4);
 471   EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
 472 }
 473
 474 // Tests using WithoutArgs with an action that takes no argument.
 475 TEST(WithoutArgsTest, NoArg) {
 476   Action<int(int n)> a = WithoutArgs(Invoke(Nullary));  // NOLINT
 477   EXPECT_EQ(1, a.Perform(make_tuple(2)));
 478 }
 479
 480 // Tests using WithArg with an action that takes 1 argument.
 481 TEST(WithArgTest, OneArg) {
 482   Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
 483   EXPECT_TRUE(b.Perform(make_tuple(1.5, -1)));
 484   EXPECT_FALSE(b.Perform(make_tuple(1.5, 1)));
 485 }
 486
 487 TEST(ReturnArgActionTest, WorksForOneArgIntArg0) {
 488   const Action<int(int)> a = ReturnArg<0>();
 489   EXPECT_EQ(5, a.Perform(make_tuple(5)));
 490 }
 491
 492 TEST(ReturnArgActionTest, WorksForMultiArgBoolArg0) {
 493   const Action<bool(bool, bool, bool)> a = ReturnArg<0>();
 494   EXPECT_TRUE(a.Perform(make_tuple(true, false, false)));
 495 }
 496
 497 TEST(ReturnArgActionTest, WorksForMultiArgStringArg2) {
 498   const Action<string(int, int, string, int)> a = ReturnArg<2>();
 499   EXPECT_EQ("seven", a.Perform(make_tuple(5, 6, string("seven"), 8)));
 500 }
 501
 502 TEST(SaveArgActionTest, WorksForSameType) {
 503   int result = 0;
 504   const Action<void(int n)> a1 = SaveArg<0>(&result);
 505   a1.Perform(make_tuple(5));
 506   EXPECT_EQ(5, result);
 507 }
 508
 509 TEST(SaveArgActionTest, WorksForCompatibleType) {
 510   int result = 0;
 511   const Action<void(bool, char)> a1 = SaveArg<1>(&result);
 512   a1.Perform(make_tuple(true, 'a'));
 513   EXPECT_EQ('a', result);
 514 }
 515
 516 TEST(SaveArgPointeeActionTest, WorksForSameType) {
 517   int result = 0;
 518   const int value = 5;
 519   const Action<void(const int*)> a1 = SaveArgPointee<0>(&result);
 520   a1.Perform(make_tuple(&value));
 521   EXPECT_EQ(5, result);
 522 }
 523
 524 TEST(SaveArgPointeeActionTest, WorksForCompatibleType) {
 525   int result = 0;
 526   char value = 'a';
 527   const Action<void(bool, char*)> a1 = SaveArgPointee<1>(&result);
 528   a1.Perform(make_tuple(true, &value));
 529   EXPECT_EQ('a', result);
 530 }
 531
 532 TEST(SaveArgPointeeActionTest, WorksForLinkedPtr) {
 533   int result = 0;
 534   linked_ptr<int> value(new int(5));
 535   const Action<void(linked_ptr<int>)> a1 = SaveArgPointee<0>(&result);
 536   a1.Perform(make_tuple(value));
 537   EXPECT_EQ(5, result);
 538 }
 539
 540 TEST(SetArgRefereeActionTest, WorksForSameType) {
 541   int value = 0;
 542   const Action<void(int&)> a1 = SetArgReferee<0>(1);
 543   a1.Perform(tuple<int&>(value));
 544   EXPECT_EQ(1, value);
 545 }
 546
 547 TEST(SetArgRefereeActionTest, WorksForCompatibleType) {
 548   int value = 0;
 549   const Action<void(int, int&)> a1 = SetArgReferee<1>('a');
 550   a1.Perform(tuple<int, int&>(0, value));
 551   EXPECT_EQ('a', value);
 552 }
 553
 554 TEST(SetArgRefereeActionTest, WorksWithExtraArguments) {
 555   int value = 0;
 556   const Action<void(bool, int, int&, const char*)> a1 = SetArgReferee<2>('a');
 557   a1.Perform(tuple<bool, int, int&, const char*>(true, 0, value, "hi"));
 558   EXPECT_EQ('a', value);
 559 }
 560
 561 // A class that can be used to verify that its destructor is called: it will set
 562 // the bool provided to the constructor to true when destroyed.
 563 class DeletionTester {
 564  public:
 565   explicit DeletionTester(bool* is_deleted)
 566     : is_deleted_(is_deleted) {
 567     // Make sure the bit is set to false.
 568     *is_deleted_ = false;
 569   }
 570
 571   ~DeletionTester() {
 572     *is_deleted_ = true;
 573   }
 574
 575  private:
 576   bool* is_deleted_;
 577 };
 578
 579 TEST(DeleteArgActionTest, OneArg) {
 580   bool is_deleted = false;
 581   DeletionTester* t = new DeletionTester(&is_deleted);
 582   const Action<void(DeletionTester*)> a1 = DeleteArg<0>();      // NOLINT
 583   EXPECT_FALSE(is_deleted);
 584   a1.Perform(make_tuple(t));
 585   EXPECT_TRUE(is_deleted);
 586 }
 587
 588 TEST(DeleteArgActionTest, TenArgs) {
 589   bool is_deleted = false;
 590   DeletionTester* t = new DeletionTester(&is_deleted);
 591   const Action<void(bool, int, int, const char*, bool,
 592                     int, int, int, int, DeletionTester*)> a1 = DeleteArg<9>();
 593   EXPECT_FALSE(is_deleted);
 594   a1.Perform(make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t));
 595   EXPECT_TRUE(is_deleted);
 596 }
 597
 598 #if GTEST_HAS_EXCEPTIONS
 599
 600 TEST(ThrowActionTest, ThrowsGivenExceptionInVoidFunction) {
 601   const Action<void(int n)> a = Throw('a');
 602   EXPECT_THROW(a.Perform(make_tuple(0)), char);
 603 }
 604
 605 class MyException {};
 606
 607 TEST(ThrowActionTest, ThrowsGivenExceptionInNonVoidFunction) {
 608   const Action<double(char ch)> a = Throw(MyException());
 609   EXPECT_THROW(a.Perform(make_tuple('0')), MyException);
 610 }
 611
 612 TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
 613   const Action<double()> a = Throw(MyException());
 614   EXPECT_THROW(a.Perform(make_tuple()), MyException);
 615 }
 616
 617 #endif  // GTEST_HAS_EXCEPTIONS
 618
 619 // Tests that SetArrayArgument<N>(first, last) sets the elements of the array
 620 // pointed to by the N-th (0-based) argument to values in range [first, last).
 621 TEST(SetArrayArgumentTest, SetsTheNthArray) {
 622   typedef void MyFunction(bool, int*, char*);
 623   int numbers[] = { 1, 2, 3 };
 624   Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers + 3);
 625
 626   int n[4] = {};
 627   int* pn = n;
 628   char ch[4] = {};
 629   char* pch = ch;
 630   a.Perform(make_tuple(true, pn, pch));
 631   EXPECT_EQ(1, n[0]);
 632   EXPECT_EQ(2, n[1]);
 633   EXPECT_EQ(3, n[2]);
 634   EXPECT_EQ(0, n[3]);
 635   EXPECT_EQ('\0', ch[0]);
 636   EXPECT_EQ('\0', ch[1]);
 637   EXPECT_EQ('\0', ch[2]);
 638   EXPECT_EQ('\0', ch[3]);
 639
 640   // Tests first and last are iterators.
 641   std::string letters = "abc";
 642   a = SetArrayArgument<2>(letters.begin(), letters.end());
 643   std::fill_n(n, 4, 0);
 644   std::fill_n(ch, 4, '\0');
 645   a.Perform(make_tuple(true, pn, pch));
 646   EXPECT_EQ(0, n[0]);
 647   EXPECT_EQ(0, n[1]);
 648   EXPECT_EQ(0, n[2]);
 649   EXPECT_EQ(0, n[3]);
 650   EXPECT_EQ('a', ch[0]);
 651   EXPECT_EQ('b', ch[1]);
 652   EXPECT_EQ('c', ch[2]);
 653   EXPECT_EQ('\0', ch[3]);
 654 }
 655
 656 // Tests SetArrayArgument<N>(first, last) where first == last.
 657 TEST(SetArrayArgumentTest, SetsTheNthArrayWithEmptyRange) {
 658   typedef void MyFunction(bool, int*);
 659   int numbers[] = { 1, 2, 3 };
 660   Action<MyFunction> a = SetArrayArgument<1>(numbers, numbers);
 661
 662   int n[4] = {};
 663   int* pn = n;
 664   a.Perform(make_tuple(true, pn));
 665   EXPECT_EQ(0, n[0]);
 666   EXPECT_EQ(0, n[1]);
 667   EXPECT_EQ(0, n[2]);
 668   EXPECT_EQ(0, n[3]);
 669 }
 670
 671 // Tests SetArrayArgument<N>(first, last) where *first is convertible
 672 // (but not equal) to the argument type.
 673 TEST(SetArrayArgumentTest, SetsTheNthArrayWithConvertibleType) {
 674   typedef void MyFunction(bool, int*);
 675   char chars[] = { 97, 98, 99 };
 676   Action<MyFunction> a = SetArrayArgument<1>(chars, chars + 3);
 677
 678   int codes[4] = { 111, 222, 333, 444 };
 679   int* pcodes = codes;
 680   a.Perform(make_tuple(true, pcodes));
 681   EXPECT_EQ(97, codes[0]);
 682   EXPECT_EQ(98, codes[1]);
 683   EXPECT_EQ(99, codes[2]);
 684   EXPECT_EQ(444, codes[3]);
 685 }
 686
 687 // Test SetArrayArgument<N>(first, last) with iterator as argument.
 688 TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
 689   typedef void MyFunction(bool, std::back_insert_iterator<std::string>);
 690   std::string letters = "abc";
 691   Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
 692
 693   std::string s;
 694   a.Perform(make_tuple(true, back_inserter(s)));
 695   EXPECT_EQ(letters, s);
 696 }
 697
 698 TEST(ReturnPointeeTest, Works) {
 699   int n = 42;
 700   const Action<int()> a = ReturnPointee(&n);
 701   EXPECT_EQ(42, a.Perform(make_tuple()));
 702
 703   n = 43;
 704   EXPECT_EQ(43, a.Perform(make_tuple()));
 705 }
 706
 707 }  // namespace gmock_generated_actions_test
 708 }  // namespace testing