Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. // Copyright 2006, 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. // This file is AUTOMATICALLY GENERATED on 01/02/2018 by command
  31. // 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
  32.  
  33. // Regression test for gtest_pred_impl.h
  34. //
  35. // This file is generated by a script and quite long.  If you intend to
  36. // learn how Google Test works by reading its unit tests, read
  37. // gtest_unittest.cc instead.
  38. //
  39. // This is intended as a regression test for the Google Test predicate
  40. // assertions.  We compile it as part of the gtest_unittest target
  41. // only to keep the implementation tidy and compact, as it is quite
  42. // involved to set up the stage for testing Google Test using Google
  43. // Test itself.
  44. //
  45. // Currently, gtest_unittest takes ~11 seconds to run in the testing
  46. // daemon.  In the future, if it grows too large and needs much more
  47. // time to finish, we should consider separating this file into a
  48. // stand-alone regression test.
  49.  
  50. #include <iostream>
  51.  
  52. #include "gtest/gtest.h"
  53. #include "gtest/gtest-spi.h"
  54.  
  55. // A user-defined data type.
  56. struct Bool {
  57.   explicit Bool(int val) : value(val != 0) {}
  58.  
  59.   bool operator>(int n) const { return value > Bool(n).value; }
  60.  
  61.   Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
  62.  
  63.   bool operator==(const Bool& rhs) const { return value == rhs.value; }
  64.  
  65.   bool value;
  66. };
  67.  
  68. // Enables Bool to be used in assertions.
  69. std::ostream& operator<<(std::ostream& os, const Bool& x) {
  70.   return os << (x.value ? "true" : "false");
  71. }
  72.  
  73. // Sample functions/functors for testing unary predicate assertions.
  74.  
  75. // A unary predicate function.
  76. template <typename T1>
  77. bool PredFunction1(T1 v1) {
  78.   return v1 > 0;
  79. }
  80.  
  81. // The following two functions are needed to circumvent a bug in
  82. // gcc 2.95.3, which sometimes has problem with the above template
  83. // function.
  84. bool PredFunction1Int(int v1) {
  85.   return v1 > 0;
  86. }
  87. bool PredFunction1Bool(Bool v1) {
  88.   return v1 > 0;
  89. }
  90.  
  91. // A unary predicate functor.
  92. struct PredFunctor1 {
  93.   template <typename T1>
  94.   bool operator()(const T1& v1) {
  95.     return v1 > 0;
  96.   }
  97. };
  98.  
  99. // A unary predicate-formatter function.
  100. template <typename T1>
  101. testing::AssertionResult PredFormatFunction1(const char* e1,
  102.                                              const T1& v1) {
  103.   if (PredFunction1(v1))
  104.     return testing::AssertionSuccess();
  105.  
  106.   return testing::AssertionFailure()
  107.       << e1
  108.       << " is expected to be positive, but evaluates to "
  109.       << v1 << ".";
  110. }
  111.  
  112. // A unary predicate-formatter functor.
  113. struct PredFormatFunctor1 {
  114.   template <typename T1>
  115.   testing::AssertionResult operator()(const char* e1,
  116.                                       const T1& v1) const {
  117.     return PredFormatFunction1(e1, v1);
  118.   }
  119. };
  120.  
  121. // Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
  122.  
  123. class Predicate1Test : public testing::Test {
  124.  protected:
  125.   virtual void SetUp() {
  126.     expected_to_finish_ = true;
  127.     finished_ = false;
  128.     n1_ = 0;
  129.   }
  130.  
  131.   virtual void TearDown() {
  132.     // Verifies that each of the predicate's arguments was evaluated
  133.     // exactly once.
  134.     EXPECT_EQ(1, n1_) <<
  135.         "The predicate assertion didn't evaluate argument 2 "
  136.         "exactly once.";
  137.  
  138.     // Verifies that the control flow in the test function is expected.
  139.     if (expected_to_finish_ && !finished_) {
  140.       FAIL() << "The predicate assertion unexpactedly aborted the test.";
  141.     } else if (!expected_to_finish_ && finished_) {
  142.       FAIL() << "The failed predicate assertion didn't abort the test "
  143.                 "as expected.";
  144.     }
  145.   }
  146.  
  147.   // true iff the test function is expected to run to finish.
  148.   static bool expected_to_finish_;
  149.  
  150.   // true iff the test function did run to finish.
  151.   static bool finished_;
  152.  
  153.   static int n1_;
  154. };
  155.  
  156. bool Predicate1Test::expected_to_finish_;
  157. bool Predicate1Test::finished_;
  158. int Predicate1Test::n1_;
  159.  
  160. typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
  161. typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
  162. typedef Predicate1Test EXPECT_PRED1Test;
  163. typedef Predicate1Test ASSERT_PRED1Test;
  164.  
  165. // Tests a successful EXPECT_PRED1 where the
  166. // predicate-formatter is a function on a built-in type (int).
  167. TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
  168.   EXPECT_PRED1(PredFunction1Int,
  169.                ++n1_);
  170.   finished_ = true;
  171. }
  172.  
  173. // Tests a successful EXPECT_PRED1 where the
  174. // predicate-formatter is a function on a user-defined type (Bool).
  175. TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
  176.   EXPECT_PRED1(PredFunction1Bool,
  177.                Bool(++n1_));
  178.   finished_ = true;
  179. }
  180.  
  181. // Tests a successful EXPECT_PRED1 where the
  182. // predicate-formatter is a functor on a built-in type (int).
  183. TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
  184.   EXPECT_PRED1(PredFunctor1(),
  185.                ++n1_);
  186.   finished_ = true;
  187. }
  188.  
  189. // Tests a successful EXPECT_PRED1 where the
  190. // predicate-formatter is a functor on a user-defined type (Bool).
  191. TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
  192.   EXPECT_PRED1(PredFunctor1(),
  193.                Bool(++n1_));
  194.   finished_ = true;
  195. }
  196.  
  197. // Tests a failed EXPECT_PRED1 where the
  198. // predicate-formatter is a function on a built-in type (int).
  199. TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
  200.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  201.     EXPECT_PRED1(PredFunction1Int,
  202.                  n1_++);
  203.     finished_ = true;
  204.   }, "");
  205. }
  206.  
  207. // Tests a failed EXPECT_PRED1 where the
  208. // predicate-formatter is a function on a user-defined type (Bool).
  209. TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
  210.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  211.     EXPECT_PRED1(PredFunction1Bool,
  212.                  Bool(n1_++));
  213.     finished_ = true;
  214.   }, "");
  215. }
  216.  
  217. // Tests a failed EXPECT_PRED1 where the
  218. // predicate-formatter is a functor on a built-in type (int).
  219. TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
  220.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  221.     EXPECT_PRED1(PredFunctor1(),
  222.                  n1_++);
  223.     finished_ = true;
  224.   }, "");
  225. }
  226.  
  227. // Tests a failed EXPECT_PRED1 where the
  228. // predicate-formatter is a functor on a user-defined type (Bool).
  229. TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
  230.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  231.     EXPECT_PRED1(PredFunctor1(),
  232.                  Bool(n1_++));
  233.     finished_ = true;
  234.   }, "");
  235. }
  236.  
  237. // Tests a successful ASSERT_PRED1 where the
  238. // predicate-formatter is a function on a built-in type (int).
  239. TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
  240.   ASSERT_PRED1(PredFunction1Int,
  241.                ++n1_);
  242.   finished_ = true;
  243. }
  244.  
  245. // Tests a successful ASSERT_PRED1 where the
  246. // predicate-formatter is a function on a user-defined type (Bool).
  247. TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
  248.   ASSERT_PRED1(PredFunction1Bool,
  249.                Bool(++n1_));
  250.   finished_ = true;
  251. }
  252.  
  253. // Tests a successful ASSERT_PRED1 where the
  254. // predicate-formatter is a functor on a built-in type (int).
  255. TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
  256.   ASSERT_PRED1(PredFunctor1(),
  257.                ++n1_);
  258.   finished_ = true;
  259. }
  260.  
  261. // Tests a successful ASSERT_PRED1 where the
  262. // predicate-formatter is a functor on a user-defined type (Bool).
  263. TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
  264.   ASSERT_PRED1(PredFunctor1(),
  265.                Bool(++n1_));
  266.   finished_ = true;
  267. }
  268.  
  269. // Tests a failed ASSERT_PRED1 where the
  270. // predicate-formatter is a function on a built-in type (int).
  271. TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
  272.   expected_to_finish_ = false;
  273.   EXPECT_FATAL_FAILURE({  // NOLINT
  274.     ASSERT_PRED1(PredFunction1Int,
  275.                  n1_++);
  276.     finished_ = true;
  277.   }, "");
  278. }
  279.  
  280. // Tests a failed ASSERT_PRED1 where the
  281. // predicate-formatter is a function on a user-defined type (Bool).
  282. TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
  283.   expected_to_finish_ = false;
  284.   EXPECT_FATAL_FAILURE({  // NOLINT
  285.     ASSERT_PRED1(PredFunction1Bool,
  286.                  Bool(n1_++));
  287.     finished_ = true;
  288.   }, "");
  289. }
  290.  
  291. // Tests a failed ASSERT_PRED1 where the
  292. // predicate-formatter is a functor on a built-in type (int).
  293. TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
  294.   expected_to_finish_ = false;
  295.   EXPECT_FATAL_FAILURE({  // NOLINT
  296.     ASSERT_PRED1(PredFunctor1(),
  297.                  n1_++);
  298.     finished_ = true;
  299.   }, "");
  300. }
  301.  
  302. // Tests a failed ASSERT_PRED1 where the
  303. // predicate-formatter is a functor on a user-defined type (Bool).
  304. TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
  305.   expected_to_finish_ = false;
  306.   EXPECT_FATAL_FAILURE({  // NOLINT
  307.     ASSERT_PRED1(PredFunctor1(),
  308.                  Bool(n1_++));
  309.     finished_ = true;
  310.   }, "");
  311. }
  312.  
  313. // Tests a successful EXPECT_PRED_FORMAT1 where the
  314. // predicate-formatter is a function on a built-in type (int).
  315. TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
  316.   EXPECT_PRED_FORMAT1(PredFormatFunction1,
  317.                       ++n1_);
  318.   finished_ = true;
  319. }
  320.  
  321. // Tests a successful EXPECT_PRED_FORMAT1 where the
  322. // predicate-formatter is a function on a user-defined type (Bool).
  323. TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
  324.   EXPECT_PRED_FORMAT1(PredFormatFunction1,
  325.                       Bool(++n1_));
  326.   finished_ = true;
  327. }
  328.  
  329. // Tests a successful EXPECT_PRED_FORMAT1 where the
  330. // predicate-formatter is a functor on a built-in type (int).
  331. TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
  332.   EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
  333.                       ++n1_);
  334.   finished_ = true;
  335. }
  336.  
  337. // Tests a successful EXPECT_PRED_FORMAT1 where the
  338. // predicate-formatter is a functor on a user-defined type (Bool).
  339. TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
  340.   EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
  341.                       Bool(++n1_));
  342.   finished_ = true;
  343. }
  344.  
  345. // Tests a failed EXPECT_PRED_FORMAT1 where the
  346. // predicate-formatter is a function on a built-in type (int).
  347. TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
  348.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  349.     EXPECT_PRED_FORMAT1(PredFormatFunction1,
  350.                         n1_++);
  351.     finished_ = true;
  352.   }, "");
  353. }
  354.  
  355. // Tests a failed EXPECT_PRED_FORMAT1 where the
  356. // predicate-formatter is a function on a user-defined type (Bool).
  357. TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
  358.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  359.     EXPECT_PRED_FORMAT1(PredFormatFunction1,
  360.                         Bool(n1_++));
  361.     finished_ = true;
  362.   }, "");
  363. }
  364.  
  365. // Tests a failed EXPECT_PRED_FORMAT1 where the
  366. // predicate-formatter is a functor on a built-in type (int).
  367. TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
  368.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  369.     EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
  370.                         n1_++);
  371.     finished_ = true;
  372.   }, "");
  373. }
  374.  
  375. // Tests a failed EXPECT_PRED_FORMAT1 where the
  376. // predicate-formatter is a functor on a user-defined type (Bool).
  377. TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
  378.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  379.     EXPECT_PRED_FORMAT1(PredFormatFunctor1(),
  380.                         Bool(n1_++));
  381.     finished_ = true;
  382.   }, "");
  383. }
  384.  
  385. // Tests a successful ASSERT_PRED_FORMAT1 where the
  386. // predicate-formatter is a function on a built-in type (int).
  387. TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
  388.   ASSERT_PRED_FORMAT1(PredFormatFunction1,
  389.                       ++n1_);
  390.   finished_ = true;
  391. }
  392.  
  393. // Tests a successful ASSERT_PRED_FORMAT1 where the
  394. // predicate-formatter is a function on a user-defined type (Bool).
  395. TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
  396.   ASSERT_PRED_FORMAT1(PredFormatFunction1,
  397.                       Bool(++n1_));
  398.   finished_ = true;
  399. }
  400.  
  401. // Tests a successful ASSERT_PRED_FORMAT1 where the
  402. // predicate-formatter is a functor on a built-in type (int).
  403. TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
  404.   ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
  405.                       ++n1_);
  406.   finished_ = true;
  407. }
  408.  
  409. // Tests a successful ASSERT_PRED_FORMAT1 where the
  410. // predicate-formatter is a functor on a user-defined type (Bool).
  411. TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
  412.   ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
  413.                       Bool(++n1_));
  414.   finished_ = true;
  415. }
  416.  
  417. // Tests a failed ASSERT_PRED_FORMAT1 where the
  418. // predicate-formatter is a function on a built-in type (int).
  419. TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
  420.   expected_to_finish_ = false;
  421.   EXPECT_FATAL_FAILURE({  // NOLINT
  422.     ASSERT_PRED_FORMAT1(PredFormatFunction1,
  423.                         n1_++);
  424.     finished_ = true;
  425.   }, "");
  426. }
  427.  
  428. // Tests a failed ASSERT_PRED_FORMAT1 where the
  429. // predicate-formatter is a function on a user-defined type (Bool).
  430. TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
  431.   expected_to_finish_ = false;
  432.   EXPECT_FATAL_FAILURE({  // NOLINT
  433.     ASSERT_PRED_FORMAT1(PredFormatFunction1,
  434.                         Bool(n1_++));
  435.     finished_ = true;
  436.   }, "");
  437. }
  438.  
  439. // Tests a failed ASSERT_PRED_FORMAT1 where the
  440. // predicate-formatter is a functor on a built-in type (int).
  441. TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
  442.   expected_to_finish_ = false;
  443.   EXPECT_FATAL_FAILURE({  // NOLINT
  444.     ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
  445.                         n1_++);
  446.     finished_ = true;
  447.   }, "");
  448. }
  449.  
  450. // Tests a failed ASSERT_PRED_FORMAT1 where the
  451. // predicate-formatter is a functor on a user-defined type (Bool).
  452. TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
  453.   expected_to_finish_ = false;
  454.   EXPECT_FATAL_FAILURE({  // NOLINT
  455.     ASSERT_PRED_FORMAT1(PredFormatFunctor1(),
  456.                         Bool(n1_++));
  457.     finished_ = true;
  458.   }, "");
  459. }
  460. // Sample functions/functors for testing binary predicate assertions.
  461.  
  462. // A binary predicate function.
  463. template <typename T1, typename T2>
  464. bool PredFunction2(T1 v1, T2 v2) {
  465.   return v1 + v2 > 0;
  466. }
  467.  
  468. // The following two functions are needed to circumvent a bug in
  469. // gcc 2.95.3, which sometimes has problem with the above template
  470. // function.
  471. bool PredFunction2Int(int v1, int v2) {
  472.   return v1 + v2 > 0;
  473. }
  474. bool PredFunction2Bool(Bool v1, Bool v2) {
  475.   return v1 + v2 > 0;
  476. }
  477.  
  478. // A binary predicate functor.
  479. struct PredFunctor2 {
  480.   template <typename T1, typename T2>
  481.   bool operator()(const T1& v1,
  482.                   const T2& v2) {
  483.     return v1 + v2 > 0;
  484.   }
  485. };
  486.  
  487. // A binary predicate-formatter function.
  488. template <typename T1, typename T2>
  489. testing::AssertionResult PredFormatFunction2(const char* e1,
  490.                                              const char* e2,
  491.                                              const T1& v1,
  492.                                              const T2& v2) {
  493.   if (PredFunction2(v1, v2))
  494.     return testing::AssertionSuccess();
  495.  
  496.   return testing::AssertionFailure()
  497.       << e1 << " + " << e2
  498.       << " is expected to be positive, but evaluates to "
  499.       << v1 + v2 << ".";
  500. }
  501.  
  502. // A binary predicate-formatter functor.
  503. struct PredFormatFunctor2 {
  504.   template <typename T1, typename T2>
  505.   testing::AssertionResult operator()(const char* e1,
  506.                                       const char* e2,
  507.                                       const T1& v1,
  508.                                       const T2& v2) const {
  509.     return PredFormatFunction2(e1, e2, v1, v2);
  510.   }
  511. };
  512.  
  513. // Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
  514.  
  515. class Predicate2Test : public testing::Test {
  516.  protected:
  517.   virtual void SetUp() {
  518.     expected_to_finish_ = true;
  519.     finished_ = false;
  520.     n1_ = n2_ = 0;
  521.   }
  522.  
  523.   virtual void TearDown() {
  524.     // Verifies that each of the predicate's arguments was evaluated
  525.     // exactly once.
  526.     EXPECT_EQ(1, n1_) <<
  527.         "The predicate assertion didn't evaluate argument 2 "
  528.         "exactly once.";
  529.     EXPECT_EQ(1, n2_) <<
  530.         "The predicate assertion didn't evaluate argument 3 "
  531.         "exactly once.";
  532.  
  533.     // Verifies that the control flow in the test function is expected.
  534.     if (expected_to_finish_ && !finished_) {
  535.       FAIL() << "The predicate assertion unexpactedly aborted the test.";
  536.     } else if (!expected_to_finish_ && finished_) {
  537.       FAIL() << "The failed predicate assertion didn't abort the test "
  538.                 "as expected.";
  539.     }
  540.   }
  541.  
  542.   // true iff the test function is expected to run to finish.
  543.   static bool expected_to_finish_;
  544.  
  545.   // true iff the test function did run to finish.
  546.   static bool finished_;
  547.  
  548.   static int n1_;
  549.   static int n2_;
  550. };
  551.  
  552. bool Predicate2Test::expected_to_finish_;
  553. bool Predicate2Test::finished_;
  554. int Predicate2Test::n1_;
  555. int Predicate2Test::n2_;
  556.  
  557. typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
  558. typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
  559. typedef Predicate2Test EXPECT_PRED2Test;
  560. typedef Predicate2Test ASSERT_PRED2Test;
  561.  
  562. // Tests a successful EXPECT_PRED2 where the
  563. // predicate-formatter is a function on a built-in type (int).
  564. TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
  565.   EXPECT_PRED2(PredFunction2Int,
  566.                ++n1_,
  567.                ++n2_);
  568.   finished_ = true;
  569. }
  570.  
  571. // Tests a successful EXPECT_PRED2 where the
  572. // predicate-formatter is a function on a user-defined type (Bool).
  573. TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
  574.   EXPECT_PRED2(PredFunction2Bool,
  575.                Bool(++n1_),
  576.                Bool(++n2_));
  577.   finished_ = true;
  578. }
  579.  
  580. // Tests a successful EXPECT_PRED2 where the
  581. // predicate-formatter is a functor on a built-in type (int).
  582. TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
  583.   EXPECT_PRED2(PredFunctor2(),
  584.                ++n1_,
  585.                ++n2_);
  586.   finished_ = true;
  587. }
  588.  
  589. // Tests a successful EXPECT_PRED2 where the
  590. // predicate-formatter is a functor on a user-defined type (Bool).
  591. TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
  592.   EXPECT_PRED2(PredFunctor2(),
  593.                Bool(++n1_),
  594.                Bool(++n2_));
  595.   finished_ = true;
  596. }
  597.  
  598. // Tests a failed EXPECT_PRED2 where the
  599. // predicate-formatter is a function on a built-in type (int).
  600. TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
  601.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  602.     EXPECT_PRED2(PredFunction2Int,
  603.                  n1_++,
  604.                  n2_++);
  605.     finished_ = true;
  606.   }, "");
  607. }
  608.  
  609. // Tests a failed EXPECT_PRED2 where the
  610. // predicate-formatter is a function on a user-defined type (Bool).
  611. TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
  612.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  613.     EXPECT_PRED2(PredFunction2Bool,
  614.                  Bool(n1_++),
  615.                  Bool(n2_++));
  616.     finished_ = true;
  617.   }, "");
  618. }
  619.  
  620. // Tests a failed EXPECT_PRED2 where the
  621. // predicate-formatter is a functor on a built-in type (int).
  622. TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
  623.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  624.     EXPECT_PRED2(PredFunctor2(),
  625.                  n1_++,
  626.                  n2_++);
  627.     finished_ = true;
  628.   }, "");
  629. }
  630.  
  631. // Tests a failed EXPECT_PRED2 where the
  632. // predicate-formatter is a functor on a user-defined type (Bool).
  633. TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
  634.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  635.     EXPECT_PRED2(PredFunctor2(),
  636.                  Bool(n1_++),
  637.                  Bool(n2_++));
  638.     finished_ = true;
  639.   }, "");
  640. }
  641.  
  642. // Tests a successful ASSERT_PRED2 where the
  643. // predicate-formatter is a function on a built-in type (int).
  644. TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
  645.   ASSERT_PRED2(PredFunction2Int,
  646.                ++n1_,
  647.                ++n2_);
  648.   finished_ = true;
  649. }
  650.  
  651. // Tests a successful ASSERT_PRED2 where the
  652. // predicate-formatter is a function on a user-defined type (Bool).
  653. TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
  654.   ASSERT_PRED2(PredFunction2Bool,
  655.                Bool(++n1_),
  656.                Bool(++n2_));
  657.   finished_ = true;
  658. }
  659.  
  660. // Tests a successful ASSERT_PRED2 where the
  661. // predicate-formatter is a functor on a built-in type (int).
  662. TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
  663.   ASSERT_PRED2(PredFunctor2(),
  664.                ++n1_,
  665.                ++n2_);
  666.   finished_ = true;
  667. }
  668.  
  669. // Tests a successful ASSERT_PRED2 where the
  670. // predicate-formatter is a functor on a user-defined type (Bool).
  671. TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
  672.   ASSERT_PRED2(PredFunctor2(),
  673.                Bool(++n1_),
  674.                Bool(++n2_));
  675.   finished_ = true;
  676. }
  677.  
  678. // Tests a failed ASSERT_PRED2 where the
  679. // predicate-formatter is a function on a built-in type (int).
  680. TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
  681.   expected_to_finish_ = false;
  682.   EXPECT_FATAL_FAILURE({  // NOLINT
  683.     ASSERT_PRED2(PredFunction2Int,
  684.                  n1_++,
  685.                  n2_++);
  686.     finished_ = true;
  687.   }, "");
  688. }
  689.  
  690. // Tests a failed ASSERT_PRED2 where the
  691. // predicate-formatter is a function on a user-defined type (Bool).
  692. TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
  693.   expected_to_finish_ = false;
  694.   EXPECT_FATAL_FAILURE({  // NOLINT
  695.     ASSERT_PRED2(PredFunction2Bool,
  696.                  Bool(n1_++),
  697.                  Bool(n2_++));
  698.     finished_ = true;
  699.   }, "");
  700. }
  701.  
  702. // Tests a failed ASSERT_PRED2 where the
  703. // predicate-formatter is a functor on a built-in type (int).
  704. TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
  705.   expected_to_finish_ = false;
  706.   EXPECT_FATAL_FAILURE({  // NOLINT
  707.     ASSERT_PRED2(PredFunctor2(),
  708.                  n1_++,
  709.                  n2_++);
  710.     finished_ = true;
  711.   }, "");
  712. }
  713.  
  714. // Tests a failed ASSERT_PRED2 where the
  715. // predicate-formatter is a functor on a user-defined type (Bool).
  716. TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
  717.   expected_to_finish_ = false;
  718.   EXPECT_FATAL_FAILURE({  // NOLINT
  719.     ASSERT_PRED2(PredFunctor2(),
  720.                  Bool(n1_++),
  721.                  Bool(n2_++));
  722.     finished_ = true;
  723.   }, "");
  724. }
  725.  
  726. // Tests a successful EXPECT_PRED_FORMAT2 where the
  727. // predicate-formatter is a function on a built-in type (int).
  728. TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
  729.   EXPECT_PRED_FORMAT2(PredFormatFunction2,
  730.                       ++n1_,
  731.                       ++n2_);
  732.   finished_ = true;
  733. }
  734.  
  735. // Tests a successful EXPECT_PRED_FORMAT2 where the
  736. // predicate-formatter is a function on a user-defined type (Bool).
  737. TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
  738.   EXPECT_PRED_FORMAT2(PredFormatFunction2,
  739.                       Bool(++n1_),
  740.                       Bool(++n2_));
  741.   finished_ = true;
  742. }
  743.  
  744. // Tests a successful EXPECT_PRED_FORMAT2 where the
  745. // predicate-formatter is a functor on a built-in type (int).
  746. TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
  747.   EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
  748.                       ++n1_,
  749.                       ++n2_);
  750.   finished_ = true;
  751. }
  752.  
  753. // Tests a successful EXPECT_PRED_FORMAT2 where the
  754. // predicate-formatter is a functor on a user-defined type (Bool).
  755. TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
  756.   EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
  757.                       Bool(++n1_),
  758.                       Bool(++n2_));
  759.   finished_ = true;
  760. }
  761.  
  762. // Tests a failed EXPECT_PRED_FORMAT2 where the
  763. // predicate-formatter is a function on a built-in type (int).
  764. TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
  765.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  766.     EXPECT_PRED_FORMAT2(PredFormatFunction2,
  767.                         n1_++,
  768.                         n2_++);
  769.     finished_ = true;
  770.   }, "");
  771. }
  772.  
  773. // Tests a failed EXPECT_PRED_FORMAT2 where the
  774. // predicate-formatter is a function on a user-defined type (Bool).
  775. TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
  776.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  777.     EXPECT_PRED_FORMAT2(PredFormatFunction2,
  778.                         Bool(n1_++),
  779.                         Bool(n2_++));
  780.     finished_ = true;
  781.   }, "");
  782. }
  783.  
  784. // Tests a failed EXPECT_PRED_FORMAT2 where the
  785. // predicate-formatter is a functor on a built-in type (int).
  786. TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
  787.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  788.     EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
  789.                         n1_++,
  790.                         n2_++);
  791.     finished_ = true;
  792.   }, "");
  793. }
  794.  
  795. // Tests a failed EXPECT_PRED_FORMAT2 where the
  796. // predicate-formatter is a functor on a user-defined type (Bool).
  797. TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
  798.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  799.     EXPECT_PRED_FORMAT2(PredFormatFunctor2(),
  800.                         Bool(n1_++),
  801.                         Bool(n2_++));
  802.     finished_ = true;
  803.   }, "");
  804. }
  805.  
  806. // Tests a successful ASSERT_PRED_FORMAT2 where the
  807. // predicate-formatter is a function on a built-in type (int).
  808. TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
  809.   ASSERT_PRED_FORMAT2(PredFormatFunction2,
  810.                       ++n1_,
  811.                       ++n2_);
  812.   finished_ = true;
  813. }
  814.  
  815. // Tests a successful ASSERT_PRED_FORMAT2 where the
  816. // predicate-formatter is a function on a user-defined type (Bool).
  817. TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
  818.   ASSERT_PRED_FORMAT2(PredFormatFunction2,
  819.                       Bool(++n1_),
  820.                       Bool(++n2_));
  821.   finished_ = true;
  822. }
  823.  
  824. // Tests a successful ASSERT_PRED_FORMAT2 where the
  825. // predicate-formatter is a functor on a built-in type (int).
  826. TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
  827.   ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
  828.                       ++n1_,
  829.                       ++n2_);
  830.   finished_ = true;
  831. }
  832.  
  833. // Tests a successful ASSERT_PRED_FORMAT2 where the
  834. // predicate-formatter is a functor on a user-defined type (Bool).
  835. TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
  836.   ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
  837.                       Bool(++n1_),
  838.                       Bool(++n2_));
  839.   finished_ = true;
  840. }
  841.  
  842. // Tests a failed ASSERT_PRED_FORMAT2 where the
  843. // predicate-formatter is a function on a built-in type (int).
  844. TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
  845.   expected_to_finish_ = false;
  846.   EXPECT_FATAL_FAILURE({  // NOLINT
  847.     ASSERT_PRED_FORMAT2(PredFormatFunction2,
  848.                         n1_++,
  849.                         n2_++);
  850.     finished_ = true;
  851.   }, "");
  852. }
  853.  
  854. // Tests a failed ASSERT_PRED_FORMAT2 where the
  855. // predicate-formatter is a function on a user-defined type (Bool).
  856. TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
  857.   expected_to_finish_ = false;
  858.   EXPECT_FATAL_FAILURE({  // NOLINT
  859.     ASSERT_PRED_FORMAT2(PredFormatFunction2,
  860.                         Bool(n1_++),
  861.                         Bool(n2_++));
  862.     finished_ = true;
  863.   }, "");
  864. }
  865.  
  866. // Tests a failed ASSERT_PRED_FORMAT2 where the
  867. // predicate-formatter is a functor on a built-in type (int).
  868. TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
  869.   expected_to_finish_ = false;
  870.   EXPECT_FATAL_FAILURE({  // NOLINT
  871.     ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
  872.                         n1_++,
  873.                         n2_++);
  874.     finished_ = true;
  875.   }, "");
  876. }
  877.  
  878. // Tests a failed ASSERT_PRED_FORMAT2 where the
  879. // predicate-formatter is a functor on a user-defined type (Bool).
  880. TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
  881.   expected_to_finish_ = false;
  882.   EXPECT_FATAL_FAILURE({  // NOLINT
  883.     ASSERT_PRED_FORMAT2(PredFormatFunctor2(),
  884.                         Bool(n1_++),
  885.                         Bool(n2_++));
  886.     finished_ = true;
  887.   }, "");
  888. }
  889. // Sample functions/functors for testing ternary predicate assertions.
  890.  
  891. // A ternary predicate function.
  892. template <typename T1, typename T2, typename T3>
  893. bool PredFunction3(T1 v1, T2 v2, T3 v3) {
  894.   return v1 + v2 + v3 > 0;
  895. }
  896.  
  897. // The following two functions are needed to circumvent a bug in
  898. // gcc 2.95.3, which sometimes has problem with the above template
  899. // function.
  900. bool PredFunction3Int(int v1, int v2, int v3) {
  901.   return v1 + v2 + v3 > 0;
  902. }
  903. bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
  904.   return v1 + v2 + v3 > 0;
  905. }
  906.  
  907. // A ternary predicate functor.
  908. struct PredFunctor3 {
  909.   template <typename T1, typename T2, typename T3>
  910.   bool operator()(const T1& v1,
  911.                   const T2& v2,
  912.                   const T3& v3) {
  913.     return v1 + v2 + v3 > 0;
  914.   }
  915. };
  916.  
  917. // A ternary predicate-formatter function.
  918. template <typename T1, typename T2, typename T3>
  919. testing::AssertionResult PredFormatFunction3(const char* e1,
  920.                                              const char* e2,
  921.                                              const char* e3,
  922.                                              const T1& v1,
  923.                                              const T2& v2,
  924.                                              const T3& v3) {
  925.   if (PredFunction3(v1, v2, v3))
  926.     return testing::AssertionSuccess();
  927.  
  928.   return testing::AssertionFailure()
  929.       << e1 << " + " << e2 << " + " << e3
  930.       << " is expected to be positive, but evaluates to "
  931.       << v1 + v2 + v3 << ".";
  932. }
  933.  
  934. // A ternary predicate-formatter functor.
  935. struct PredFormatFunctor3 {
  936.   template <typename T1, typename T2, typename T3>
  937.   testing::AssertionResult operator()(const char* e1,
  938.                                       const char* e2,
  939.                                       const char* e3,
  940.                                       const T1& v1,
  941.                                       const T2& v2,
  942.                                       const T3& v3) const {
  943.     return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
  944.   }
  945. };
  946.  
  947. // Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
  948.  
  949. class Predicate3Test : public testing::Test {
  950.  protected:
  951.   virtual void SetUp() {
  952.     expected_to_finish_ = true;
  953.     finished_ = false;
  954.     n1_ = n2_ = n3_ = 0;
  955.   }
  956.  
  957.   virtual void TearDown() {
  958.     // Verifies that each of the predicate's arguments was evaluated
  959.     // exactly once.
  960.     EXPECT_EQ(1, n1_) <<
  961.         "The predicate assertion didn't evaluate argument 2 "
  962.         "exactly once.";
  963.     EXPECT_EQ(1, n2_) <<
  964.         "The predicate assertion didn't evaluate argument 3 "
  965.         "exactly once.";
  966.     EXPECT_EQ(1, n3_) <<
  967.         "The predicate assertion didn't evaluate argument 4 "
  968.         "exactly once.";
  969.  
  970.     // Verifies that the control flow in the test function is expected.
  971.     if (expected_to_finish_ && !finished_) {
  972.       FAIL() << "The predicate assertion unexpactedly aborted the test.";
  973.     } else if (!expected_to_finish_ && finished_) {
  974.       FAIL() << "The failed predicate assertion didn't abort the test "
  975.                 "as expected.";
  976.     }
  977.   }
  978.  
  979.   // true iff the test function is expected to run to finish.
  980.   static bool expected_to_finish_;
  981.  
  982.   // true iff the test function did run to finish.
  983.   static bool finished_;
  984.  
  985.   static int n1_;
  986.   static int n2_;
  987.   static int n3_;
  988. };
  989.  
  990. bool Predicate3Test::expected_to_finish_;
  991. bool Predicate3Test::finished_;
  992. int Predicate3Test::n1_;
  993. int Predicate3Test::n2_;
  994. int Predicate3Test::n3_;
  995.  
  996. typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
  997. typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
  998. typedef Predicate3Test EXPECT_PRED3Test;
  999. typedef Predicate3Test ASSERT_PRED3Test;
  1000.  
  1001. // Tests a successful EXPECT_PRED3 where the
  1002. // predicate-formatter is a function on a built-in type (int).
  1003. TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
  1004.   EXPECT_PRED3(PredFunction3Int,
  1005.                ++n1_,
  1006.                ++n2_,
  1007.                ++n3_);
  1008.   finished_ = true;
  1009. }
  1010.  
  1011. // Tests a successful EXPECT_PRED3 where the
  1012. // predicate-formatter is a function on a user-defined type (Bool).
  1013. TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
  1014.   EXPECT_PRED3(PredFunction3Bool,
  1015.                Bool(++n1_),
  1016.                Bool(++n2_),
  1017.                Bool(++n3_));
  1018.   finished_ = true;
  1019. }
  1020.  
  1021. // Tests a successful EXPECT_PRED3 where the
  1022. // predicate-formatter is a functor on a built-in type (int).
  1023. TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
  1024.   EXPECT_PRED3(PredFunctor3(),
  1025.                ++n1_,
  1026.                ++n2_,
  1027.                ++n3_);
  1028.   finished_ = true;
  1029. }
  1030.  
  1031. // Tests a successful EXPECT_PRED3 where the
  1032. // predicate-formatter is a functor on a user-defined type (Bool).
  1033. TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
  1034.   EXPECT_PRED3(PredFunctor3(),
  1035.                Bool(++n1_),
  1036.                Bool(++n2_),
  1037.                Bool(++n3_));
  1038.   finished_ = true;
  1039. }
  1040.  
  1041. // Tests a failed EXPECT_PRED3 where the
  1042. // predicate-formatter is a function on a built-in type (int).
  1043. TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
  1044.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1045.     EXPECT_PRED3(PredFunction3Int,
  1046.                  n1_++,
  1047.                  n2_++,
  1048.                  n3_++);
  1049.     finished_ = true;
  1050.   }, "");
  1051. }
  1052.  
  1053. // Tests a failed EXPECT_PRED3 where the
  1054. // predicate-formatter is a function on a user-defined type (Bool).
  1055. TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
  1056.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1057.     EXPECT_PRED3(PredFunction3Bool,
  1058.                  Bool(n1_++),
  1059.                  Bool(n2_++),
  1060.                  Bool(n3_++));
  1061.     finished_ = true;
  1062.   }, "");
  1063. }
  1064.  
  1065. // Tests a failed EXPECT_PRED3 where the
  1066. // predicate-formatter is a functor on a built-in type (int).
  1067. TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
  1068.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1069.     EXPECT_PRED3(PredFunctor3(),
  1070.                  n1_++,
  1071.                  n2_++,
  1072.                  n3_++);
  1073.     finished_ = true;
  1074.   }, "");
  1075. }
  1076.  
  1077. // Tests a failed EXPECT_PRED3 where the
  1078. // predicate-formatter is a functor on a user-defined type (Bool).
  1079. TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
  1080.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1081.     EXPECT_PRED3(PredFunctor3(),
  1082.                  Bool(n1_++),
  1083.                  Bool(n2_++),
  1084.                  Bool(n3_++));
  1085.     finished_ = true;
  1086.   }, "");
  1087. }
  1088.  
  1089. // Tests a successful ASSERT_PRED3 where the
  1090. // predicate-formatter is a function on a built-in type (int).
  1091. TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
  1092.   ASSERT_PRED3(PredFunction3Int,
  1093.                ++n1_,
  1094.                ++n2_,
  1095.                ++n3_);
  1096.   finished_ = true;
  1097. }
  1098.  
  1099. // Tests a successful ASSERT_PRED3 where the
  1100. // predicate-formatter is a function on a user-defined type (Bool).
  1101. TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
  1102.   ASSERT_PRED3(PredFunction3Bool,
  1103.                Bool(++n1_),
  1104.                Bool(++n2_),
  1105.                Bool(++n3_));
  1106.   finished_ = true;
  1107. }
  1108.  
  1109. // Tests a successful ASSERT_PRED3 where the
  1110. // predicate-formatter is a functor on a built-in type (int).
  1111. TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
  1112.   ASSERT_PRED3(PredFunctor3(),
  1113.                ++n1_,
  1114.                ++n2_,
  1115.                ++n3_);
  1116.   finished_ = true;
  1117. }
  1118.  
  1119. // Tests a successful ASSERT_PRED3 where the
  1120. // predicate-formatter is a functor on a user-defined type (Bool).
  1121. TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
  1122.   ASSERT_PRED3(PredFunctor3(),
  1123.                Bool(++n1_),
  1124.                Bool(++n2_),
  1125.                Bool(++n3_));
  1126.   finished_ = true;
  1127. }
  1128.  
  1129. // Tests a failed ASSERT_PRED3 where the
  1130. // predicate-formatter is a function on a built-in type (int).
  1131. TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
  1132.   expected_to_finish_ = false;
  1133.   EXPECT_FATAL_FAILURE({  // NOLINT
  1134.     ASSERT_PRED3(PredFunction3Int,
  1135.                  n1_++,
  1136.                  n2_++,
  1137.                  n3_++);
  1138.     finished_ = true;
  1139.   }, "");
  1140. }
  1141.  
  1142. // Tests a failed ASSERT_PRED3 where the
  1143. // predicate-formatter is a function on a user-defined type (Bool).
  1144. TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
  1145.   expected_to_finish_ = false;
  1146.   EXPECT_FATAL_FAILURE({  // NOLINT
  1147.     ASSERT_PRED3(PredFunction3Bool,
  1148.                  Bool(n1_++),
  1149.                  Bool(n2_++),
  1150.                  Bool(n3_++));
  1151.     finished_ = true;
  1152.   }, "");
  1153. }
  1154.  
  1155. // Tests a failed ASSERT_PRED3 where the
  1156. // predicate-formatter is a functor on a built-in type (int).
  1157. TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
  1158.   expected_to_finish_ = false;
  1159.   EXPECT_FATAL_FAILURE({  // NOLINT
  1160.     ASSERT_PRED3(PredFunctor3(),
  1161.                  n1_++,
  1162.                  n2_++,
  1163.                  n3_++);
  1164.     finished_ = true;
  1165.   }, "");
  1166. }
  1167.  
  1168. // Tests a failed ASSERT_PRED3 where the
  1169. // predicate-formatter is a functor on a user-defined type (Bool).
  1170. TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
  1171.   expected_to_finish_ = false;
  1172.   EXPECT_FATAL_FAILURE({  // NOLINT
  1173.     ASSERT_PRED3(PredFunctor3(),
  1174.                  Bool(n1_++),
  1175.                  Bool(n2_++),
  1176.                  Bool(n3_++));
  1177.     finished_ = true;
  1178.   }, "");
  1179. }
  1180.  
  1181. // Tests a successful EXPECT_PRED_FORMAT3 where the
  1182. // predicate-formatter is a function on a built-in type (int).
  1183. TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
  1184.   EXPECT_PRED_FORMAT3(PredFormatFunction3,
  1185.                       ++n1_,
  1186.                       ++n2_,
  1187.                       ++n3_);
  1188.   finished_ = true;
  1189. }
  1190.  
  1191. // Tests a successful EXPECT_PRED_FORMAT3 where the
  1192. // predicate-formatter is a function on a user-defined type (Bool).
  1193. TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
  1194.   EXPECT_PRED_FORMAT3(PredFormatFunction3,
  1195.                       Bool(++n1_),
  1196.                       Bool(++n2_),
  1197.                       Bool(++n3_));
  1198.   finished_ = true;
  1199. }
  1200.  
  1201. // Tests a successful EXPECT_PRED_FORMAT3 where the
  1202. // predicate-formatter is a functor on a built-in type (int).
  1203. TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
  1204.   EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
  1205.                       ++n1_,
  1206.                       ++n2_,
  1207.                       ++n3_);
  1208.   finished_ = true;
  1209. }
  1210.  
  1211. // Tests a successful EXPECT_PRED_FORMAT3 where the
  1212. // predicate-formatter is a functor on a user-defined type (Bool).
  1213. TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
  1214.   EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
  1215.                       Bool(++n1_),
  1216.                       Bool(++n2_),
  1217.                       Bool(++n3_));
  1218.   finished_ = true;
  1219. }
  1220.  
  1221. // Tests a failed EXPECT_PRED_FORMAT3 where the
  1222. // predicate-formatter is a function on a built-in type (int).
  1223. TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
  1224.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1225.     EXPECT_PRED_FORMAT3(PredFormatFunction3,
  1226.                         n1_++,
  1227.                         n2_++,
  1228.                         n3_++);
  1229.     finished_ = true;
  1230.   }, "");
  1231. }
  1232.  
  1233. // Tests a failed EXPECT_PRED_FORMAT3 where the
  1234. // predicate-formatter is a function on a user-defined type (Bool).
  1235. TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
  1236.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1237.     EXPECT_PRED_FORMAT3(PredFormatFunction3,
  1238.                         Bool(n1_++),
  1239.                         Bool(n2_++),
  1240.                         Bool(n3_++));
  1241.     finished_ = true;
  1242.   }, "");
  1243. }
  1244.  
  1245. // Tests a failed EXPECT_PRED_FORMAT3 where the
  1246. // predicate-formatter is a functor on a built-in type (int).
  1247. TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
  1248.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1249.     EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
  1250.                         n1_++,
  1251.                         n2_++,
  1252.                         n3_++);
  1253.     finished_ = true;
  1254.   }, "");
  1255. }
  1256.  
  1257. // Tests a failed EXPECT_PRED_FORMAT3 where the
  1258. // predicate-formatter is a functor on a user-defined type (Bool).
  1259. TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
  1260.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1261.     EXPECT_PRED_FORMAT3(PredFormatFunctor3(),
  1262.                         Bool(n1_++),
  1263.                         Bool(n2_++),
  1264.                         Bool(n3_++));
  1265.     finished_ = true;
  1266.   }, "");
  1267. }
  1268.  
  1269. // Tests a successful ASSERT_PRED_FORMAT3 where the
  1270. // predicate-formatter is a function on a built-in type (int).
  1271. TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
  1272.   ASSERT_PRED_FORMAT3(PredFormatFunction3,
  1273.                       ++n1_,
  1274.                       ++n2_,
  1275.                       ++n3_);
  1276.   finished_ = true;
  1277. }
  1278.  
  1279. // Tests a successful ASSERT_PRED_FORMAT3 where the
  1280. // predicate-formatter is a function on a user-defined type (Bool).
  1281. TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
  1282.   ASSERT_PRED_FORMAT3(PredFormatFunction3,
  1283.                       Bool(++n1_),
  1284.                       Bool(++n2_),
  1285.                       Bool(++n3_));
  1286.   finished_ = true;
  1287. }
  1288.  
  1289. // Tests a successful ASSERT_PRED_FORMAT3 where the
  1290. // predicate-formatter is a functor on a built-in type (int).
  1291. TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
  1292.   ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
  1293.                       ++n1_,
  1294.                       ++n2_,
  1295.                       ++n3_);
  1296.   finished_ = true;
  1297. }
  1298.  
  1299. // Tests a successful ASSERT_PRED_FORMAT3 where the
  1300. // predicate-formatter is a functor on a user-defined type (Bool).
  1301. TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
  1302.   ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
  1303.                       Bool(++n1_),
  1304.                       Bool(++n2_),
  1305.                       Bool(++n3_));
  1306.   finished_ = true;
  1307. }
  1308.  
  1309. // Tests a failed ASSERT_PRED_FORMAT3 where the
  1310. // predicate-formatter is a function on a built-in type (int).
  1311. TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
  1312.   expected_to_finish_ = false;
  1313.   EXPECT_FATAL_FAILURE({  // NOLINT
  1314.     ASSERT_PRED_FORMAT3(PredFormatFunction3,
  1315.                         n1_++,
  1316.                         n2_++,
  1317.                         n3_++);
  1318.     finished_ = true;
  1319.   }, "");
  1320. }
  1321.  
  1322. // Tests a failed ASSERT_PRED_FORMAT3 where the
  1323. // predicate-formatter is a function on a user-defined type (Bool).
  1324. TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
  1325.   expected_to_finish_ = false;
  1326.   EXPECT_FATAL_FAILURE({  // NOLINT
  1327.     ASSERT_PRED_FORMAT3(PredFormatFunction3,
  1328.                         Bool(n1_++),
  1329.                         Bool(n2_++),
  1330.                         Bool(n3_++));
  1331.     finished_ = true;
  1332.   }, "");
  1333. }
  1334.  
  1335. // Tests a failed ASSERT_PRED_FORMAT3 where the
  1336. // predicate-formatter is a functor on a built-in type (int).
  1337. TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
  1338.   expected_to_finish_ = false;
  1339.   EXPECT_FATAL_FAILURE({  // NOLINT
  1340.     ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
  1341.                         n1_++,
  1342.                         n2_++,
  1343.                         n3_++);
  1344.     finished_ = true;
  1345.   }, "");
  1346. }
  1347.  
  1348. // Tests a failed ASSERT_PRED_FORMAT3 where the
  1349. // predicate-formatter is a functor on a user-defined type (Bool).
  1350. TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
  1351.   expected_to_finish_ = false;
  1352.   EXPECT_FATAL_FAILURE({  // NOLINT
  1353.     ASSERT_PRED_FORMAT3(PredFormatFunctor3(),
  1354.                         Bool(n1_++),
  1355.                         Bool(n2_++),
  1356.                         Bool(n3_++));
  1357.     finished_ = true;
  1358.   }, "");
  1359. }
  1360. // Sample functions/functors for testing 4-ary predicate assertions.
  1361.  
  1362. // A 4-ary predicate function.
  1363. template <typename T1, typename T2, typename T3, typename T4>
  1364. bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
  1365.   return v1 + v2 + v3 + v4 > 0;
  1366. }
  1367.  
  1368. // The following two functions are needed to circumvent a bug in
  1369. // gcc 2.95.3, which sometimes has problem with the above template
  1370. // function.
  1371. bool PredFunction4Int(int v1, int v2, int v3, int v4) {
  1372.   return v1 + v2 + v3 + v4 > 0;
  1373. }
  1374. bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
  1375.   return v1 + v2 + v3 + v4 > 0;
  1376. }
  1377.  
  1378. // A 4-ary predicate functor.
  1379. struct PredFunctor4 {
  1380.   template <typename T1, typename T2, typename T3, typename T4>
  1381.   bool operator()(const T1& v1,
  1382.                   const T2& v2,
  1383.                   const T3& v3,
  1384.                   const T4& v4) {
  1385.     return v1 + v2 + v3 + v4 > 0;
  1386.   }
  1387. };
  1388.  
  1389. // A 4-ary predicate-formatter function.
  1390. template <typename T1, typename T2, typename T3, typename T4>
  1391. testing::AssertionResult PredFormatFunction4(const char* e1,
  1392.                                              const char* e2,
  1393.                                              const char* e3,
  1394.                                              const char* e4,
  1395.                                              const T1& v1,
  1396.                                              const T2& v2,
  1397.                                              const T3& v3,
  1398.                                              const T4& v4) {
  1399.   if (PredFunction4(v1, v2, v3, v4))
  1400.     return testing::AssertionSuccess();
  1401.  
  1402.   return testing::AssertionFailure()
  1403.       << e1 << " + " << e2 << " + " << e3 << " + " << e4
  1404.       << " is expected to be positive, but evaluates to "
  1405.       << v1 + v2 + v3 + v4 << ".";
  1406. }
  1407.  
  1408. // A 4-ary predicate-formatter functor.
  1409. struct PredFormatFunctor4 {
  1410.   template <typename T1, typename T2, typename T3, typename T4>
  1411.   testing::AssertionResult operator()(const char* e1,
  1412.                                       const char* e2,
  1413.                                       const char* e3,
  1414.                                       const char* e4,
  1415.                                       const T1& v1,
  1416.                                       const T2& v2,
  1417.                                       const T3& v3,
  1418.                                       const T4& v4) const {
  1419.     return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
  1420.   }
  1421. };
  1422.  
  1423. // Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
  1424.  
  1425. class Predicate4Test : public testing::Test {
  1426.  protected:
  1427.   virtual void SetUp() {
  1428.     expected_to_finish_ = true;
  1429.     finished_ = false;
  1430.     n1_ = n2_ = n3_ = n4_ = 0;
  1431.   }
  1432.  
  1433.   virtual void TearDown() {
  1434.     // Verifies that each of the predicate's arguments was evaluated
  1435.     // exactly once.
  1436.     EXPECT_EQ(1, n1_) <<
  1437.         "The predicate assertion didn't evaluate argument 2 "
  1438.         "exactly once.";
  1439.     EXPECT_EQ(1, n2_) <<
  1440.         "The predicate assertion didn't evaluate argument 3 "
  1441.         "exactly once.";
  1442.     EXPECT_EQ(1, n3_) <<
  1443.         "The predicate assertion didn't evaluate argument 4 "
  1444.         "exactly once.";
  1445.     EXPECT_EQ(1, n4_) <<
  1446.         "The predicate assertion didn't evaluate argument 5 "
  1447.         "exactly once.";
  1448.  
  1449.     // Verifies that the control flow in the test function is expected.
  1450.     if (expected_to_finish_ && !finished_) {
  1451.       FAIL() << "The predicate assertion unexpactedly aborted the test.";
  1452.     } else if (!expected_to_finish_ && finished_) {
  1453.       FAIL() << "The failed predicate assertion didn't abort the test "
  1454.                 "as expected.";
  1455.     }
  1456.   }
  1457.  
  1458.   // true iff the test function is expected to run to finish.
  1459.   static bool expected_to_finish_;
  1460.  
  1461.   // true iff the test function did run to finish.
  1462.   static bool finished_;
  1463.  
  1464.   static int n1_;
  1465.   static int n2_;
  1466.   static int n3_;
  1467.   static int n4_;
  1468. };
  1469.  
  1470. bool Predicate4Test::expected_to_finish_;
  1471. bool Predicate4Test::finished_;
  1472. int Predicate4Test::n1_;
  1473. int Predicate4Test::n2_;
  1474. int Predicate4Test::n3_;
  1475. int Predicate4Test::n4_;
  1476.  
  1477. typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
  1478. typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
  1479. typedef Predicate4Test EXPECT_PRED4Test;
  1480. typedef Predicate4Test ASSERT_PRED4Test;
  1481.  
  1482. // Tests a successful EXPECT_PRED4 where the
  1483. // predicate-formatter is a function on a built-in type (int).
  1484. TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
  1485.   EXPECT_PRED4(PredFunction4Int,
  1486.                ++n1_,
  1487.                ++n2_,
  1488.                ++n3_,
  1489.                ++n4_);
  1490.   finished_ = true;
  1491. }
  1492.  
  1493. // Tests a successful EXPECT_PRED4 where the
  1494. // predicate-formatter is a function on a user-defined type (Bool).
  1495. TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
  1496.   EXPECT_PRED4(PredFunction4Bool,
  1497.                Bool(++n1_),
  1498.                Bool(++n2_),
  1499.                Bool(++n3_),
  1500.                Bool(++n4_));
  1501.   finished_ = true;
  1502. }
  1503.  
  1504. // Tests a successful EXPECT_PRED4 where the
  1505. // predicate-formatter is a functor on a built-in type (int).
  1506. TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
  1507.   EXPECT_PRED4(PredFunctor4(),
  1508.                ++n1_,
  1509.                ++n2_,
  1510.                ++n3_,
  1511.                ++n4_);
  1512.   finished_ = true;
  1513. }
  1514.  
  1515. // Tests a successful EXPECT_PRED4 where the
  1516. // predicate-formatter is a functor on a user-defined type (Bool).
  1517. TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
  1518.   EXPECT_PRED4(PredFunctor4(),
  1519.                Bool(++n1_),
  1520.                Bool(++n2_),
  1521.                Bool(++n3_),
  1522.                Bool(++n4_));
  1523.   finished_ = true;
  1524. }
  1525.  
  1526. // Tests a failed EXPECT_PRED4 where the
  1527. // predicate-formatter is a function on a built-in type (int).
  1528. TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
  1529.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1530.     EXPECT_PRED4(PredFunction4Int,
  1531.                  n1_++,
  1532.                  n2_++,
  1533.                  n3_++,
  1534.                  n4_++);
  1535.     finished_ = true;
  1536.   }, "");
  1537. }
  1538.  
  1539. // Tests a failed EXPECT_PRED4 where the
  1540. // predicate-formatter is a function on a user-defined type (Bool).
  1541. TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
  1542.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1543.     EXPECT_PRED4(PredFunction4Bool,
  1544.                  Bool(n1_++),
  1545.                  Bool(n2_++),
  1546.                  Bool(n3_++),
  1547.                  Bool(n4_++));
  1548.     finished_ = true;
  1549.   }, "");
  1550. }
  1551.  
  1552. // Tests a failed EXPECT_PRED4 where the
  1553. // predicate-formatter is a functor on a built-in type (int).
  1554. TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
  1555.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1556.     EXPECT_PRED4(PredFunctor4(),
  1557.                  n1_++,
  1558.                  n2_++,
  1559.                  n3_++,
  1560.                  n4_++);
  1561.     finished_ = true;
  1562.   }, "");
  1563. }
  1564.  
  1565. // Tests a failed EXPECT_PRED4 where the
  1566. // predicate-formatter is a functor on a user-defined type (Bool).
  1567. TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
  1568.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1569.     EXPECT_PRED4(PredFunctor4(),
  1570.                  Bool(n1_++),
  1571.                  Bool(n2_++),
  1572.                  Bool(n3_++),
  1573.                  Bool(n4_++));
  1574.     finished_ = true;
  1575.   }, "");
  1576. }
  1577.  
  1578. // Tests a successful ASSERT_PRED4 where the
  1579. // predicate-formatter is a function on a built-in type (int).
  1580. TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
  1581.   ASSERT_PRED4(PredFunction4Int,
  1582.                ++n1_,
  1583.                ++n2_,
  1584.                ++n3_,
  1585.                ++n4_);
  1586.   finished_ = true;
  1587. }
  1588.  
  1589. // Tests a successful ASSERT_PRED4 where the
  1590. // predicate-formatter is a function on a user-defined type (Bool).
  1591. TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
  1592.   ASSERT_PRED4(PredFunction4Bool,
  1593.                Bool(++n1_),
  1594.                Bool(++n2_),
  1595.                Bool(++n3_),
  1596.                Bool(++n4_));
  1597.   finished_ = true;
  1598. }
  1599.  
  1600. // Tests a successful ASSERT_PRED4 where the
  1601. // predicate-formatter is a functor on a built-in type (int).
  1602. TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
  1603.   ASSERT_PRED4(PredFunctor4(),
  1604.                ++n1_,
  1605.                ++n2_,
  1606.                ++n3_,
  1607.                ++n4_);
  1608.   finished_ = true;
  1609. }
  1610.  
  1611. // Tests a successful ASSERT_PRED4 where the
  1612. // predicate-formatter is a functor on a user-defined type (Bool).
  1613. TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
  1614.   ASSERT_PRED4(PredFunctor4(),
  1615.                Bool(++n1_),
  1616.                Bool(++n2_),
  1617.                Bool(++n3_),
  1618.                Bool(++n4_));
  1619.   finished_ = true;
  1620. }
  1621.  
  1622. // Tests a failed ASSERT_PRED4 where the
  1623. // predicate-formatter is a function on a built-in type (int).
  1624. TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
  1625.   expected_to_finish_ = false;
  1626.   EXPECT_FATAL_FAILURE({  // NOLINT
  1627.     ASSERT_PRED4(PredFunction4Int,
  1628.                  n1_++,
  1629.                  n2_++,
  1630.                  n3_++,
  1631.                  n4_++);
  1632.     finished_ = true;
  1633.   }, "");
  1634. }
  1635.  
  1636. // Tests a failed ASSERT_PRED4 where the
  1637. // predicate-formatter is a function on a user-defined type (Bool).
  1638. TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
  1639.   expected_to_finish_ = false;
  1640.   EXPECT_FATAL_FAILURE({  // NOLINT
  1641.     ASSERT_PRED4(PredFunction4Bool,
  1642.                  Bool(n1_++),
  1643.                  Bool(n2_++),
  1644.                  Bool(n3_++),
  1645.                  Bool(n4_++));
  1646.     finished_ = true;
  1647.   }, "");
  1648. }
  1649.  
  1650. // Tests a failed ASSERT_PRED4 where the
  1651. // predicate-formatter is a functor on a built-in type (int).
  1652. TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
  1653.   expected_to_finish_ = false;
  1654.   EXPECT_FATAL_FAILURE({  // NOLINT
  1655.     ASSERT_PRED4(PredFunctor4(),
  1656.                  n1_++,
  1657.                  n2_++,
  1658.                  n3_++,
  1659.                  n4_++);
  1660.     finished_ = true;
  1661.   }, "");
  1662. }
  1663.  
  1664. // Tests a failed ASSERT_PRED4 where the
  1665. // predicate-formatter is a functor on a user-defined type (Bool).
  1666. TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
  1667.   expected_to_finish_ = false;
  1668.   EXPECT_FATAL_FAILURE({  // NOLINT
  1669.     ASSERT_PRED4(PredFunctor4(),
  1670.                  Bool(n1_++),
  1671.                  Bool(n2_++),
  1672.                  Bool(n3_++),
  1673.                  Bool(n4_++));
  1674.     finished_ = true;
  1675.   }, "");
  1676. }
  1677.  
  1678. // Tests a successful EXPECT_PRED_FORMAT4 where the
  1679. // predicate-formatter is a function on a built-in type (int).
  1680. TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
  1681.   EXPECT_PRED_FORMAT4(PredFormatFunction4,
  1682.                       ++n1_,
  1683.                       ++n2_,
  1684.                       ++n3_,
  1685.                       ++n4_);
  1686.   finished_ = true;
  1687. }
  1688.  
  1689. // Tests a successful EXPECT_PRED_FORMAT4 where the
  1690. // predicate-formatter is a function on a user-defined type (Bool).
  1691. TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
  1692.   EXPECT_PRED_FORMAT4(PredFormatFunction4,
  1693.                       Bool(++n1_),
  1694.                       Bool(++n2_),
  1695.                       Bool(++n3_),
  1696.                       Bool(++n4_));
  1697.   finished_ = true;
  1698. }
  1699.  
  1700. // Tests a successful EXPECT_PRED_FORMAT4 where the
  1701. // predicate-formatter is a functor on a built-in type (int).
  1702. TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
  1703.   EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
  1704.                       ++n1_,
  1705.                       ++n2_,
  1706.                       ++n3_,
  1707.                       ++n4_);
  1708.   finished_ = true;
  1709. }
  1710.  
  1711. // Tests a successful EXPECT_PRED_FORMAT4 where the
  1712. // predicate-formatter is a functor on a user-defined type (Bool).
  1713. TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
  1714.   EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
  1715.                       Bool(++n1_),
  1716.                       Bool(++n2_),
  1717.                       Bool(++n3_),
  1718.                       Bool(++n4_));
  1719.   finished_ = true;
  1720. }
  1721.  
  1722. // Tests a failed EXPECT_PRED_FORMAT4 where the
  1723. // predicate-formatter is a function on a built-in type (int).
  1724. TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
  1725.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1726.     EXPECT_PRED_FORMAT4(PredFormatFunction4,
  1727.                         n1_++,
  1728.                         n2_++,
  1729.                         n3_++,
  1730.                         n4_++);
  1731.     finished_ = true;
  1732.   }, "");
  1733. }
  1734.  
  1735. // Tests a failed EXPECT_PRED_FORMAT4 where the
  1736. // predicate-formatter is a function on a user-defined type (Bool).
  1737. TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
  1738.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1739.     EXPECT_PRED_FORMAT4(PredFormatFunction4,
  1740.                         Bool(n1_++),
  1741.                         Bool(n2_++),
  1742.                         Bool(n3_++),
  1743.                         Bool(n4_++));
  1744.     finished_ = true;
  1745.   }, "");
  1746. }
  1747.  
  1748. // Tests a failed EXPECT_PRED_FORMAT4 where the
  1749. // predicate-formatter is a functor on a built-in type (int).
  1750. TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
  1751.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1752.     EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
  1753.                         n1_++,
  1754.                         n2_++,
  1755.                         n3_++,
  1756.                         n4_++);
  1757.     finished_ = true;
  1758.   }, "");
  1759. }
  1760.  
  1761. // Tests a failed EXPECT_PRED_FORMAT4 where the
  1762. // predicate-formatter is a functor on a user-defined type (Bool).
  1763. TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
  1764.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  1765.     EXPECT_PRED_FORMAT4(PredFormatFunctor4(),
  1766.                         Bool(n1_++),
  1767.                         Bool(n2_++),
  1768.                         Bool(n3_++),
  1769.                         Bool(n4_++));
  1770.     finished_ = true;
  1771.   }, "");
  1772. }
  1773.  
  1774. // Tests a successful ASSERT_PRED_FORMAT4 where the
  1775. // predicate-formatter is a function on a built-in type (int).
  1776. TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
  1777.   ASSERT_PRED_FORMAT4(PredFormatFunction4,
  1778.                       ++n1_,
  1779.                       ++n2_,
  1780.                       ++n3_,
  1781.                       ++n4_);
  1782.   finished_ = true;
  1783. }
  1784.  
  1785. // Tests a successful ASSERT_PRED_FORMAT4 where the
  1786. // predicate-formatter is a function on a user-defined type (Bool).
  1787. TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
  1788.   ASSERT_PRED_FORMAT4(PredFormatFunction4,
  1789.                       Bool(++n1_),
  1790.                       Bool(++n2_),
  1791.                       Bool(++n3_),
  1792.                       Bool(++n4_));
  1793.   finished_ = true;
  1794. }
  1795.  
  1796. // Tests a successful ASSERT_PRED_FORMAT4 where the
  1797. // predicate-formatter is a functor on a built-in type (int).
  1798. TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
  1799.   ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
  1800.                       ++n1_,
  1801.                       ++n2_,
  1802.                       ++n3_,
  1803.                       ++n4_);
  1804.   finished_ = true;
  1805. }
  1806.  
  1807. // Tests a successful ASSERT_PRED_FORMAT4 where the
  1808. // predicate-formatter is a functor on a user-defined type (Bool).
  1809. TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
  1810.   ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
  1811.                       Bool(++n1_),
  1812.                       Bool(++n2_),
  1813.                       Bool(++n3_),
  1814.                       Bool(++n4_));
  1815.   finished_ = true;
  1816. }
  1817.  
  1818. // Tests a failed ASSERT_PRED_FORMAT4 where the
  1819. // predicate-formatter is a function on a built-in type (int).
  1820. TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
  1821.   expected_to_finish_ = false;
  1822.   EXPECT_FATAL_FAILURE({  // NOLINT
  1823.     ASSERT_PRED_FORMAT4(PredFormatFunction4,
  1824.                         n1_++,
  1825.                         n2_++,
  1826.                         n3_++,
  1827.                         n4_++);
  1828.     finished_ = true;
  1829.   }, "");
  1830. }
  1831.  
  1832. // Tests a failed ASSERT_PRED_FORMAT4 where the
  1833. // predicate-formatter is a function on a user-defined type (Bool).
  1834. TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
  1835.   expected_to_finish_ = false;
  1836.   EXPECT_FATAL_FAILURE({  // NOLINT
  1837.     ASSERT_PRED_FORMAT4(PredFormatFunction4,
  1838.                         Bool(n1_++),
  1839.                         Bool(n2_++),
  1840.                         Bool(n3_++),
  1841.                         Bool(n4_++));
  1842.     finished_ = true;
  1843.   }, "");
  1844. }
  1845.  
  1846. // Tests a failed ASSERT_PRED_FORMAT4 where the
  1847. // predicate-formatter is a functor on a built-in type (int).
  1848. TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
  1849.   expected_to_finish_ = false;
  1850.   EXPECT_FATAL_FAILURE({  // NOLINT
  1851.     ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
  1852.                         n1_++,
  1853.                         n2_++,
  1854.                         n3_++,
  1855.                         n4_++);
  1856.     finished_ = true;
  1857.   }, "");
  1858. }
  1859.  
  1860. // Tests a failed ASSERT_PRED_FORMAT4 where the
  1861. // predicate-formatter is a functor on a user-defined type (Bool).
  1862. TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
  1863.   expected_to_finish_ = false;
  1864.   EXPECT_FATAL_FAILURE({  // NOLINT
  1865.     ASSERT_PRED_FORMAT4(PredFormatFunctor4(),
  1866.                         Bool(n1_++),
  1867.                         Bool(n2_++),
  1868.                         Bool(n3_++),
  1869.                         Bool(n4_++));
  1870.     finished_ = true;
  1871.   }, "");
  1872. }
  1873. // Sample functions/functors for testing 5-ary predicate assertions.
  1874.  
  1875. // A 5-ary predicate function.
  1876. template <typename T1, typename T2, typename T3, typename T4, typename T5>
  1877. bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
  1878.   return v1 + v2 + v3 + v4 + v5 > 0;
  1879. }
  1880.  
  1881. // The following two functions are needed to circumvent a bug in
  1882. // gcc 2.95.3, which sometimes has problem with the above template
  1883. // function.
  1884. bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
  1885.   return v1 + v2 + v3 + v4 + v5 > 0;
  1886. }
  1887. bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
  1888.   return v1 + v2 + v3 + v4 + v5 > 0;
  1889. }
  1890.  
  1891. // A 5-ary predicate functor.
  1892. struct PredFunctor5 {
  1893.   template <typename T1, typename T2, typename T3, typename T4, typename T5>
  1894.   bool operator()(const T1& v1,
  1895.                   const T2& v2,
  1896.                   const T3& v3,
  1897.                   const T4& v4,
  1898.                   const T5& v5) {
  1899.     return v1 + v2 + v3 + v4 + v5 > 0;
  1900.   }
  1901. };
  1902.  
  1903. // A 5-ary predicate-formatter function.
  1904. template <typename T1, typename T2, typename T3, typename T4, typename T5>
  1905. testing::AssertionResult PredFormatFunction5(const char* e1,
  1906.                                              const char* e2,
  1907.                                              const char* e3,
  1908.                                              const char* e4,
  1909.                                              const char* e5,
  1910.                                              const T1& v1,
  1911.                                              const T2& v2,
  1912.                                              const T3& v3,
  1913.                                              const T4& v4,
  1914.                                              const T5& v5) {
  1915.   if (PredFunction5(v1, v2, v3, v4, v5))
  1916.     return testing::AssertionSuccess();
  1917.  
  1918.   return testing::AssertionFailure()
  1919.       << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
  1920.       << " is expected to be positive, but evaluates to "
  1921.       << v1 + v2 + v3 + v4 + v5 << ".";
  1922. }
  1923.  
  1924. // A 5-ary predicate-formatter functor.
  1925. struct PredFormatFunctor5 {
  1926.   template <typename T1, typename T2, typename T3, typename T4, typename T5>
  1927.   testing::AssertionResult operator()(const char* e1,
  1928.                                       const char* e2,
  1929.                                       const char* e3,
  1930.                                       const char* e4,
  1931.                                       const char* e5,
  1932.                                       const T1& v1,
  1933.                                       const T2& v2,
  1934.                                       const T3& v3,
  1935.                                       const T4& v4,
  1936.                                       const T5& v5) const {
  1937.     return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
  1938.   }
  1939. };
  1940.  
  1941. // Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
  1942.  
  1943. class Predicate5Test : public testing::Test {
  1944.  protected:
  1945.   virtual void SetUp() {
  1946.     expected_to_finish_ = true;
  1947.     finished_ = false;
  1948.     n1_ = n2_ = n3_ = n4_ = n5_ = 0;
  1949.   }
  1950.  
  1951.   virtual void TearDown() {
  1952.     // Verifies that each of the predicate's arguments was evaluated
  1953.     // exactly once.
  1954.     EXPECT_EQ(1, n1_) <<
  1955.         "The predicate assertion didn't evaluate argument 2 "
  1956.         "exactly once.";
  1957.     EXPECT_EQ(1, n2_) <<
  1958.         "The predicate assertion didn't evaluate argument 3 "
  1959.         "exactly once.";
  1960.     EXPECT_EQ(1, n3_) <<
  1961.         "The predicate assertion didn't evaluate argument 4 "
  1962.         "exactly once.";
  1963.     EXPECT_EQ(1, n4_) <<
  1964.         "The predicate assertion didn't evaluate argument 5 "
  1965.         "exactly once.";
  1966.     EXPECT_EQ(1, n5_) <<
  1967.         "The predicate assertion didn't evaluate argument 6 "
  1968.         "exactly once.";
  1969.  
  1970.     // Verifies that the control flow in the test function is expected.
  1971.     if (expected_to_finish_ && !finished_) {
  1972.       FAIL() << "The predicate assertion unexpactedly aborted the test.";
  1973.     } else if (!expected_to_finish_ && finished_) {
  1974.       FAIL() << "The failed predicate assertion didn't abort the test "
  1975.                 "as expected.";
  1976.     }
  1977.   }
  1978.  
  1979.   // true iff the test function is expected to run to finish.
  1980.   static bool expected_to_finish_;
  1981.  
  1982.   // true iff the test function did run to finish.
  1983.   static bool finished_;
  1984.  
  1985.   static int n1_;
  1986.   static int n2_;
  1987.   static int n3_;
  1988.   static int n4_;
  1989.   static int n5_;
  1990. };
  1991.  
  1992. bool Predicate5Test::expected_to_finish_;
  1993. bool Predicate5Test::finished_;
  1994. int Predicate5Test::n1_;
  1995. int Predicate5Test::n2_;
  1996. int Predicate5Test::n3_;
  1997. int Predicate5Test::n4_;
  1998. int Predicate5Test::n5_;
  1999.  
  2000. typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
  2001. typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
  2002. typedef Predicate5Test EXPECT_PRED5Test;
  2003. typedef Predicate5Test ASSERT_PRED5Test;
  2004.  
  2005. // Tests a successful EXPECT_PRED5 where the
  2006. // predicate-formatter is a function on a built-in type (int).
  2007. TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
  2008.   EXPECT_PRED5(PredFunction5Int,
  2009.                ++n1_,
  2010.                ++n2_,
  2011.                ++n3_,
  2012.                ++n4_,
  2013.                ++n5_);
  2014.   finished_ = true;
  2015. }
  2016.  
  2017. // Tests a successful EXPECT_PRED5 where the
  2018. // predicate-formatter is a function on a user-defined type (Bool).
  2019. TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
  2020.   EXPECT_PRED5(PredFunction5Bool,
  2021.                Bool(++n1_),
  2022.                Bool(++n2_),
  2023.                Bool(++n3_),
  2024.                Bool(++n4_),
  2025.                Bool(++n5_));
  2026.   finished_ = true;
  2027. }
  2028.  
  2029. // Tests a successful EXPECT_PRED5 where the
  2030. // predicate-formatter is a functor on a built-in type (int).
  2031. TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
  2032.   EXPECT_PRED5(PredFunctor5(),
  2033.                ++n1_,
  2034.                ++n2_,
  2035.                ++n3_,
  2036.                ++n4_,
  2037.                ++n5_);
  2038.   finished_ = true;
  2039. }
  2040.  
  2041. // Tests a successful EXPECT_PRED5 where the
  2042. // predicate-formatter is a functor on a user-defined type (Bool).
  2043. TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
  2044.   EXPECT_PRED5(PredFunctor5(),
  2045.                Bool(++n1_),
  2046.                Bool(++n2_),
  2047.                Bool(++n3_),
  2048.                Bool(++n4_),
  2049.                Bool(++n5_));
  2050.   finished_ = true;
  2051. }
  2052.  
  2053. // Tests a failed EXPECT_PRED5 where the
  2054. // predicate-formatter is a function on a built-in type (int).
  2055. TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
  2056.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2057.     EXPECT_PRED5(PredFunction5Int,
  2058.                  n1_++,
  2059.                  n2_++,
  2060.                  n3_++,
  2061.                  n4_++,
  2062.                  n5_++);
  2063.     finished_ = true;
  2064.   }, "");
  2065. }
  2066.  
  2067. // Tests a failed EXPECT_PRED5 where the
  2068. // predicate-formatter is a function on a user-defined type (Bool).
  2069. TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
  2070.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2071.     EXPECT_PRED5(PredFunction5Bool,
  2072.                  Bool(n1_++),
  2073.                  Bool(n2_++),
  2074.                  Bool(n3_++),
  2075.                  Bool(n4_++),
  2076.                  Bool(n5_++));
  2077.     finished_ = true;
  2078.   }, "");
  2079. }
  2080.  
  2081. // Tests a failed EXPECT_PRED5 where the
  2082. // predicate-formatter is a functor on a built-in type (int).
  2083. TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
  2084.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2085.     EXPECT_PRED5(PredFunctor5(),
  2086.                  n1_++,
  2087.                  n2_++,
  2088.                  n3_++,
  2089.                  n4_++,
  2090.                  n5_++);
  2091.     finished_ = true;
  2092.   }, "");
  2093. }
  2094.  
  2095. // Tests a failed EXPECT_PRED5 where the
  2096. // predicate-formatter is a functor on a user-defined type (Bool).
  2097. TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
  2098.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2099.     EXPECT_PRED5(PredFunctor5(),
  2100.                  Bool(n1_++),
  2101.                  Bool(n2_++),
  2102.                  Bool(n3_++),
  2103.                  Bool(n4_++),
  2104.                  Bool(n5_++));
  2105.     finished_ = true;
  2106.   }, "");
  2107. }
  2108.  
  2109. // Tests a successful ASSERT_PRED5 where the
  2110. // predicate-formatter is a function on a built-in type (int).
  2111. TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
  2112.   ASSERT_PRED5(PredFunction5Int,
  2113.                ++n1_,
  2114.                ++n2_,
  2115.                ++n3_,
  2116.                ++n4_,
  2117.                ++n5_);
  2118.   finished_ = true;
  2119. }
  2120.  
  2121. // Tests a successful ASSERT_PRED5 where the
  2122. // predicate-formatter is a function on a user-defined type (Bool).
  2123. TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
  2124.   ASSERT_PRED5(PredFunction5Bool,
  2125.                Bool(++n1_),
  2126.                Bool(++n2_),
  2127.                Bool(++n3_),
  2128.                Bool(++n4_),
  2129.                Bool(++n5_));
  2130.   finished_ = true;
  2131. }
  2132.  
  2133. // Tests a successful ASSERT_PRED5 where the
  2134. // predicate-formatter is a functor on a built-in type (int).
  2135. TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
  2136.   ASSERT_PRED5(PredFunctor5(),
  2137.                ++n1_,
  2138.                ++n2_,
  2139.                ++n3_,
  2140.                ++n4_,
  2141.                ++n5_);
  2142.   finished_ = true;
  2143. }
  2144.  
  2145. // Tests a successful ASSERT_PRED5 where the
  2146. // predicate-formatter is a functor on a user-defined type (Bool).
  2147. TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
  2148.   ASSERT_PRED5(PredFunctor5(),
  2149.                Bool(++n1_),
  2150.                Bool(++n2_),
  2151.                Bool(++n3_),
  2152.                Bool(++n4_),
  2153.                Bool(++n5_));
  2154.   finished_ = true;
  2155. }
  2156.  
  2157. // Tests a failed ASSERT_PRED5 where the
  2158. // predicate-formatter is a function on a built-in type (int).
  2159. TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
  2160.   expected_to_finish_ = false;
  2161.   EXPECT_FATAL_FAILURE({  // NOLINT
  2162.     ASSERT_PRED5(PredFunction5Int,
  2163.                  n1_++,
  2164.                  n2_++,
  2165.                  n3_++,
  2166.                  n4_++,
  2167.                  n5_++);
  2168.     finished_ = true;
  2169.   }, "");
  2170. }
  2171.  
  2172. // Tests a failed ASSERT_PRED5 where the
  2173. // predicate-formatter is a function on a user-defined type (Bool).
  2174. TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
  2175.   expected_to_finish_ = false;
  2176.   EXPECT_FATAL_FAILURE({  // NOLINT
  2177.     ASSERT_PRED5(PredFunction5Bool,
  2178.                  Bool(n1_++),
  2179.                  Bool(n2_++),
  2180.                  Bool(n3_++),
  2181.                  Bool(n4_++),
  2182.                  Bool(n5_++));
  2183.     finished_ = true;
  2184.   }, "");
  2185. }
  2186.  
  2187. // Tests a failed ASSERT_PRED5 where the
  2188. // predicate-formatter is a functor on a built-in type (int).
  2189. TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
  2190.   expected_to_finish_ = false;
  2191.   EXPECT_FATAL_FAILURE({  // NOLINT
  2192.     ASSERT_PRED5(PredFunctor5(),
  2193.                  n1_++,
  2194.                  n2_++,
  2195.                  n3_++,
  2196.                  n4_++,
  2197.                  n5_++);
  2198.     finished_ = true;
  2199.   }, "");
  2200. }
  2201.  
  2202. // Tests a failed ASSERT_PRED5 where the
  2203. // predicate-formatter is a functor on a user-defined type (Bool).
  2204. TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
  2205.   expected_to_finish_ = false;
  2206.   EXPECT_FATAL_FAILURE({  // NOLINT
  2207.     ASSERT_PRED5(PredFunctor5(),
  2208.                  Bool(n1_++),
  2209.                  Bool(n2_++),
  2210.                  Bool(n3_++),
  2211.                  Bool(n4_++),
  2212.                  Bool(n5_++));
  2213.     finished_ = true;
  2214.   }, "");
  2215. }
  2216.  
  2217. // Tests a successful EXPECT_PRED_FORMAT5 where the
  2218. // predicate-formatter is a function on a built-in type (int).
  2219. TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
  2220.   EXPECT_PRED_FORMAT5(PredFormatFunction5,
  2221.                       ++n1_,
  2222.                       ++n2_,
  2223.                       ++n3_,
  2224.                       ++n4_,
  2225.                       ++n5_);
  2226.   finished_ = true;
  2227. }
  2228.  
  2229. // Tests a successful EXPECT_PRED_FORMAT5 where the
  2230. // predicate-formatter is a function on a user-defined type (Bool).
  2231. TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
  2232.   EXPECT_PRED_FORMAT5(PredFormatFunction5,
  2233.                       Bool(++n1_),
  2234.                       Bool(++n2_),
  2235.                       Bool(++n3_),
  2236.                       Bool(++n4_),
  2237.                       Bool(++n5_));
  2238.   finished_ = true;
  2239. }
  2240.  
  2241. // Tests a successful EXPECT_PRED_FORMAT5 where the
  2242. // predicate-formatter is a functor on a built-in type (int).
  2243. TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
  2244.   EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
  2245.                       ++n1_,
  2246.                       ++n2_,
  2247.                       ++n3_,
  2248.                       ++n4_,
  2249.                       ++n5_);
  2250.   finished_ = true;
  2251. }
  2252.  
  2253. // Tests a successful EXPECT_PRED_FORMAT5 where the
  2254. // predicate-formatter is a functor on a user-defined type (Bool).
  2255. TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
  2256.   EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
  2257.                       Bool(++n1_),
  2258.                       Bool(++n2_),
  2259.                       Bool(++n3_),
  2260.                       Bool(++n4_),
  2261.                       Bool(++n5_));
  2262.   finished_ = true;
  2263. }
  2264.  
  2265. // Tests a failed EXPECT_PRED_FORMAT5 where the
  2266. // predicate-formatter is a function on a built-in type (int).
  2267. TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
  2268.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2269.     EXPECT_PRED_FORMAT5(PredFormatFunction5,
  2270.                         n1_++,
  2271.                         n2_++,
  2272.                         n3_++,
  2273.                         n4_++,
  2274.                         n5_++);
  2275.     finished_ = true;
  2276.   }, "");
  2277. }
  2278.  
  2279. // Tests a failed EXPECT_PRED_FORMAT5 where the
  2280. // predicate-formatter is a function on a user-defined type (Bool).
  2281. TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
  2282.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2283.     EXPECT_PRED_FORMAT5(PredFormatFunction5,
  2284.                         Bool(n1_++),
  2285.                         Bool(n2_++),
  2286.                         Bool(n3_++),
  2287.                         Bool(n4_++),
  2288.                         Bool(n5_++));
  2289.     finished_ = true;
  2290.   }, "");
  2291. }
  2292.  
  2293. // Tests a failed EXPECT_PRED_FORMAT5 where the
  2294. // predicate-formatter is a functor on a built-in type (int).
  2295. TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
  2296.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2297.     EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
  2298.                         n1_++,
  2299.                         n2_++,
  2300.                         n3_++,
  2301.                         n4_++,
  2302.                         n5_++);
  2303.     finished_ = true;
  2304.   }, "");
  2305. }
  2306.  
  2307. // Tests a failed EXPECT_PRED_FORMAT5 where the
  2308. // predicate-formatter is a functor on a user-defined type (Bool).
  2309. TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
  2310.   EXPECT_NONFATAL_FAILURE({  // NOLINT
  2311.     EXPECT_PRED_FORMAT5(PredFormatFunctor5(),
  2312.                         Bool(n1_++),
  2313.                         Bool(n2_++),
  2314.                         Bool(n3_++),
  2315.                         Bool(n4_++),
  2316.                         Bool(n5_++));
  2317.     finished_ = true;
  2318.   }, "");
  2319. }
  2320.  
  2321. // Tests a successful ASSERT_PRED_FORMAT5 where the
  2322. // predicate-formatter is a function on a built-in type (int).
  2323. TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
  2324.   ASSERT_PRED_FORMAT5(PredFormatFunction5,
  2325.                       ++n1_,
  2326.                       ++n2_,
  2327.                       ++n3_,
  2328.                       ++n4_,
  2329.                       ++n5_);
  2330.   finished_ = true;
  2331. }
  2332.  
  2333. // Tests a successful ASSERT_PRED_FORMAT5 where the
  2334. // predicate-formatter is a function on a user-defined type (Bool).
  2335. TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
  2336.   ASSERT_PRED_FORMAT5(PredFormatFunction5,
  2337.                       Bool(++n1_),
  2338.                       Bool(++n2_),
  2339.                       Bool(++n3_),
  2340.                       Bool(++n4_),
  2341.                       Bool(++n5_));
  2342.   finished_ = true;
  2343. }
  2344.  
  2345. // Tests a successful ASSERT_PRED_FORMAT5 where the
  2346. // predicate-formatter is a functor on a built-in type (int).
  2347. TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
  2348.   ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
  2349.                       ++n1_,
  2350.                       ++n2_,
  2351.                       ++n3_,
  2352.                       ++n4_,
  2353.                       ++n5_);
  2354.   finished_ = true;
  2355. }
  2356.  
  2357. // Tests a successful ASSERT_PRED_FORMAT5 where the
  2358. // predicate-formatter is a functor on a user-defined type (Bool).
  2359. TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
  2360.   ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
  2361.                       Bool(++n1_),
  2362.                       Bool(++n2_),
  2363.                       Bool(++n3_),
  2364.                       Bool(++n4_),
  2365.                       Bool(++n5_));
  2366.   finished_ = true;
  2367. }
  2368.  
  2369. // Tests a failed ASSERT_PRED_FORMAT5 where the
  2370. // predicate-formatter is a function on a built-in type (int).
  2371. TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
  2372.   expected_to_finish_ = false;
  2373.   EXPECT_FATAL_FAILURE({  // NOLINT
  2374.     ASSERT_PRED_FORMAT5(PredFormatFunction5,
  2375.                         n1_++,
  2376.                         n2_++,
  2377.                         n3_++,
  2378.                         n4_++,
  2379.                         n5_++);
  2380.     finished_ = true;
  2381.   }, "");
  2382. }
  2383.  
  2384. // Tests a failed ASSERT_PRED_FORMAT5 where the
  2385. // predicate-formatter is a function on a user-defined type (Bool).
  2386. TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
  2387.   expected_to_finish_ = false;
  2388.   EXPECT_FATAL_FAILURE({  // NOLINT
  2389.     ASSERT_PRED_FORMAT5(PredFormatFunction5,
  2390.                         Bool(n1_++),
  2391.                         Bool(n2_++),
  2392.                         Bool(n3_++),
  2393.                         Bool(n4_++),
  2394.                         Bool(n5_++));
  2395.     finished_ = true;
  2396.   }, "");
  2397. }
  2398.  
  2399. // Tests a failed ASSERT_PRED_FORMAT5 where the
  2400. // predicate-formatter is a functor on a built-in type (int).
  2401. TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
  2402.   expected_to_finish_ = false;
  2403.   EXPECT_FATAL_FAILURE({  // NOLINT
  2404.     ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
  2405.                         n1_++,
  2406.                         n2_++,
  2407.                         n3_++,
  2408.                         n4_++,
  2409.                         n5_++);
  2410.     finished_ = true;
  2411.   }, "");
  2412. }
  2413.  
  2414. // Tests a failed ASSERT_PRED_FORMAT5 where the
  2415. // predicate-formatter is a functor on a user-defined type (Bool).
  2416. TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
  2417.   expected_to_finish_ = false;
  2418.   EXPECT_FATAL_FAILURE({  // NOLINT
  2419.     ASSERT_PRED_FORMAT5(PredFormatFunctor5(),
  2420.                         Bool(n1_++),
  2421.                         Bool(n2_++),
  2422.                         Bool(n3_++),
  2423.                         Bool(n4_++),
  2424.                         Bool(n5_++));
  2425.     finished_ = true;
  2426.   }, "");
  2427. }
  2428.