?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

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