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