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