• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2006, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 
30 // This file is AUTOMATICALLY GENERATED on 10/31/2011 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 {
BoolBool57   explicit Bool(int val) : value(val != 0) {}
58 
operator >Bool59   bool operator>(int n) const { return value > Bool(n).value; }
60 
operator +Bool61   Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
62 
operator ==Bool63   bool operator==(const Bool& rhs) const { return value == rhs.value; }
64 
65   bool value;
66 };
67 
68 // Enables Bool to be used in assertions.
operator <<(std::ostream & os,const Bool & x)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>
PredFunction1(T1 v1)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.
PredFunction1Int(int v1)84 bool PredFunction1Int(int v1) {
85   return v1 > 0;
86 }
PredFunction1Bool(Bool v1)87 bool PredFunction1Bool(Bool v1) {
88   return v1 > 0;
89 }
90 
91 // A unary predicate functor.
92 struct PredFunctor1 {
93   template <typename T1>
operator ()PredFunctor194   bool operator()(const T1& v1) {
95     return v1 > 0;
96   }
97 };
98 
99 // A unary predicate-formatter function.
100 template <typename T1>
PredFormatFunction1(const char * e1,const T1 & v1)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>
operator ()PredFormatFunctor1115   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:
SetUp()125   virtual void SetUp() {
126     expected_to_finish_ = true;
127     finished_ = false;
128     n1_ = 0;
129   }
130 
TearDown()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).
TEST_F(EXPECT_PRED1Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED1Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED1Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED1Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED1Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED1Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED1Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED1Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED1Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED1Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED1Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED1Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED1Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED1Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED1Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED1Test,FunctorOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT1Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT1Test,FunctorOnUserTypeFailure)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>
PredFunction2(T1 v1,T2 v2)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.
PredFunction2Int(int v1,int v2)471 bool PredFunction2Int(int v1, int v2) {
472   return v1 + v2 > 0;
473 }
PredFunction2Bool(Bool v1,Bool v2)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>
operator ()PredFunctor2481   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>
PredFormatFunction2(const char * e1,const char * e2,const T1 & v1,const T2 & v2)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>
operator ()PredFormatFunctor2505   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:
SetUp()517   virtual void SetUp() {
518     expected_to_finish_ = true;
519     finished_ = false;
520     n1_ = n2_ = 0;
521   }
522 
TearDown()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).
TEST_F(EXPECT_PRED2Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED2Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED2Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED2Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED2Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED2Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED2Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED2Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED2Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED2Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED2Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED2Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED2Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED2Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED2Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED2Test,FunctorOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT2Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT2Test,FunctorOnUserTypeFailure)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>
PredFunction3(T1 v1,T2 v2,T3 v3)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.
PredFunction3Int(int v1,int v2,int v3)900 bool PredFunction3Int(int v1, int v2, int v3) {
901   return v1 + v2 + v3 > 0;
902 }
PredFunction3Bool(Bool v1,Bool v2,Bool v3)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>
operator ()PredFunctor3910   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>
PredFormatFunction3(const char * e1,const char * e2,const char * e3,const T1 & v1,const T2 & v2,const T3 & v3)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>
operator ()PredFormatFunctor3937   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:
SetUp()951   virtual void SetUp() {
952     expected_to_finish_ = true;
953     finished_ = false;
954     n1_ = n2_ = n3_ = 0;
955   }
956 
TearDown()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).
TEST_F(EXPECT_PRED3Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED3Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED3Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED3Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED3Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED3Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED3Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED3Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED3Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED3Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED3Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED3Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED3Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED3Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED3Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED3Test,FunctorOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT3Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT3Test,FunctorOnUserTypeFailure)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>
PredFunction4(T1 v1,T2 v2,T3 v3,T4 v4)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.
PredFunction4Int(int v1,int v2,int v3,int v4)1371 bool PredFunction4Int(int v1, int v2, int v3, int v4) {
1372   return v1 + v2 + v3 + v4 > 0;
1373 }
PredFunction4Bool(Bool v1,Bool v2,Bool v3,Bool v4)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>
operator ()PredFunctor41381   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>
PredFormatFunction4(const char * e1,const char * e2,const char * e3,const char * e4,const T1 & v1,const T2 & v2,const T3 & v3,const T4 & v4)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>
operator ()PredFormatFunctor41411   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:
SetUp()1427   virtual void SetUp() {
1428     expected_to_finish_ = true;
1429     finished_ = false;
1430     n1_ = n2_ = n3_ = n4_ = 0;
1431   }
1432 
TearDown()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).
TEST_F(EXPECT_PRED4Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED4Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED4Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED4Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED4Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED4Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED4Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED4Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED4Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED4Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED4Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED4Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED4Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED4Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED4Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED4Test,FunctorOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT4Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT4Test,FunctorOnUserTypeFailure)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>
PredFunction5(T1 v1,T2 v2,T3 v3,T4 v4,T5 v5)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.
PredFunction5Int(int v1,int v2,int v3,int v4,int v5)1884 bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
1885   return v1 + v2 + v3 + v4 + v5 > 0;
1886 }
PredFunction5Bool(Bool v1,Bool v2,Bool v3,Bool v4,Bool v5)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>
operator ()PredFunctor51894   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>
PredFormatFunction5(const char * e1,const char * e2,const char * e3,const char * e4,const char * e5,const T1 & v1,const T2 & v2,const T3 & v3,const T4 & v4,const T5 & v5)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>
operator ()PredFormatFunctor51927   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:
SetUp()1945   virtual void SetUp() {
1946     expected_to_finish_ = true;
1947     finished_ = false;
1948     n1_ = n2_ = n3_ = n4_ = n5_ = 0;
1949   }
1950 
TearDown()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).
TEST_F(EXPECT_PRED5Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED5Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED5Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED5Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED5Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED5Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED5Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED5Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED5Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED5Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED5Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED5Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED5Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED5Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED5Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED5Test,FunctorOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctionOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctorOnUserTypeSuccess)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctionOnUserTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(EXPECT_PRED_FORMAT5Test,FunctorOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctionOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctionOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctorOnBuiltInTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctorOnUserTypeSuccess)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctionOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctionOnUserTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctorOnBuiltInTypeFailure)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).
TEST_F(ASSERT_PRED_FORMAT5Test,FunctorOnUserTypeFailure)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