Home | History | Annotate | Download | only in test
      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 09/24/2010 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