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.
56struct 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.
69std::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.
76template <typename T1>
77bool 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.
84bool PredFunction1Int(int v1) {
85  return v1 > 0;
86}
87bool PredFunction1Bool(Bool v1) {
88  return v1 > 0;
89}
90
91// A unary predicate functor.
92struct PredFunctor1 {
93  template <typename T1>
94  bool operator()(const T1& v1) {
95    return v1 > 0;
96  }
97};
98
99// A unary predicate-formatter function.
100template <typename T1>
101testing::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.
113struct PredFormatFunctor1 {
114  template <typename T1>
115  testing::AssertionResult operator()(const char* e1,
116                                      const T1& v1) const {
117    return PredFormatFunction1(e1, v1);
118  }
119};
120
121// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
122
123class Predicate1Test : public testing::Test {
124 protected:
125  virtual void SetUp() {
126    expected_to_finish_ = true;
127    finished_ = false;
128    n1_ = 0;
129  }
130
131  virtual void TearDown() {
132    // Verifies that each of the predicate's arguments was evaluated
133    // exactly once.
134    EXPECT_EQ(1, n1_) <<
135        "The predicate assertion didn't evaluate argument 2 "
136        "exactly once.";
137
138    // Verifies that the control flow in the test function is expected.
139    if (expected_to_finish_ && !finished_) {
140      FAIL() << "The predicate assertion unexpactedly aborted the test.";
141    } else if (!expected_to_finish_ && finished_) {
142      FAIL() << "The failed predicate assertion didn't abort the test "
143                "as expected.";
144    }
145  }
146
147  // true iff the test function is expected to run to finish.
148  static bool expected_to_finish_;
149
150  // true iff the test function did run to finish.
151  static bool finished_;
152
153  static int n1_;
154};
155
156bool Predicate1Test::expected_to_finish_;
157bool Predicate1Test::finished_;
158int Predicate1Test::n1_;
159
160typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
161typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
162typedef Predicate1Test EXPECT_PRED1Test;
163typedef Predicate1Test ASSERT_PRED1Test;
164
165// Tests a successful EXPECT_PRED1 where the
166// predicate-formatter is a function on a built-in type (int).
167TEST_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).
175TEST_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).
183TEST_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).
191TEST_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).
199TEST_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).
209TEST_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).
219TEST_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).
229TEST_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).
239TEST_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).
247TEST_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).
255TEST_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).
263TEST_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).
271TEST_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).
282TEST_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).
293TEST_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).
304TEST_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).
315TEST_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).
323TEST_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).
331TEST_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).
339TEST_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).
347TEST_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).
357TEST_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).
367TEST_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).
377TEST_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).
387TEST_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).
395TEST_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).
403TEST_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).
411TEST_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).
419TEST_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).
430TEST_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).
441TEST_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).
452TEST_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.
463template <typename T1, typename T2>
464bool 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.
471bool PredFunction2Int(int v1, int v2) {
472  return v1 + v2 > 0;
473}
474bool PredFunction2Bool(Bool v1, Bool v2) {
475  return v1 + v2 > 0;
476}
477
478// A binary predicate functor.
479struct 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.
488template <typename T1, typename T2>
489testing::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.
503struct PredFormatFunctor2 {
504  template <typename T1, typename T2>
505  testing::AssertionResult operator()(const char* e1,
506                                      const char* e2,
507                                      const T1& v1,
508                                      const T2& v2) const {
509    return PredFormatFunction2(e1, e2, v1, v2);
510  }
511};
512
513// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
514
515class Predicate2Test : public testing::Test {
516 protected:
517  virtual void SetUp() {
518    expected_to_finish_ = true;
519    finished_ = false;
520    n1_ = n2_ = 0;
521  }
522
523  virtual void TearDown() {
524    // Verifies that each of the predicate's arguments was evaluated
525    // exactly once.
526    EXPECT_EQ(1, n1_) <<
527        "The predicate assertion didn't evaluate argument 2 "
528        "exactly once.";
529    EXPECT_EQ(1, n2_) <<
530        "The predicate assertion didn't evaluate argument 3 "
531        "exactly once.";
532
533    // Verifies that the control flow in the test function is expected.
534    if (expected_to_finish_ && !finished_) {
535      FAIL() << "The predicate assertion unexpactedly aborted the test.";
536    } else if (!expected_to_finish_ && finished_) {
537      FAIL() << "The failed predicate assertion didn't abort the test "
538                "as expected.";
539    }
540  }
541
542  // true iff the test function is expected to run to finish.
543  static bool expected_to_finish_;
544
545  // true iff the test function did run to finish.
546  static bool finished_;
547
548  static int n1_;
549  static int n2_;
550};
551
552bool Predicate2Test::expected_to_finish_;
553bool Predicate2Test::finished_;
554int Predicate2Test::n1_;
555int Predicate2Test::n2_;
556
557typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
558typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
559typedef Predicate2Test EXPECT_PRED2Test;
560typedef Predicate2Test ASSERT_PRED2Test;
561
562// Tests a successful EXPECT_PRED2 where the
563// predicate-formatter is a function on a built-in type (int).
564TEST_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).
573TEST_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).
582TEST_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).
591TEST_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).
600TEST_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).
611TEST_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).
622TEST_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).
633TEST_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).
644TEST_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).
653TEST_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).
662TEST_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).
671TEST_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).
680TEST_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).
692TEST_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).
704TEST_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).
716TEST_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).
728TEST_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).
737TEST_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).
746TEST_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).
755TEST_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).
764TEST_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).
775TEST_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).
786TEST_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).
797TEST_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).
808TEST_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).
817TEST_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).
826TEST_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).
835TEST_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).
844TEST_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).
856TEST_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).
868TEST_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).
880TEST_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.
892template <typename T1, typename T2, typename T3>
893bool 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.
900bool PredFunction3Int(int v1, int v2, int v3) {
901  return v1 + v2 + v3 > 0;
902}
903bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
904  return v1 + v2 + v3 > 0;
905}
906
907// A ternary predicate functor.
908struct 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.
918template <typename T1, typename T2, typename T3>
919testing::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.
935struct PredFormatFunctor3 {
936  template <typename T1, typename T2, typename T3>
937  testing::AssertionResult operator()(const char* e1,
938                                      const char* e2,
939                                      const char* e3,
940                                      const T1& v1,
941                                      const T2& v2,
942                                      const T3& v3) const {
943    return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
944  }
945};
946
947// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
948
949class Predicate3Test : public testing::Test {
950 protected:
951  virtual void SetUp() {
952    expected_to_finish_ = true;
953    finished_ = false;
954    n1_ = n2_ = n3_ = 0;
955  }
956
957  virtual void TearDown() {
958    // Verifies that each of the predicate's arguments was evaluated
959    // exactly once.
960    EXPECT_EQ(1, n1_) <<
961        "The predicate assertion didn't evaluate argument 2 "
962        "exactly once.";
963    EXPECT_EQ(1, n2_) <<
964        "The predicate assertion didn't evaluate argument 3 "
965        "exactly once.";
966    EXPECT_EQ(1, n3_) <<
967        "The predicate assertion didn't evaluate argument 4 "
968        "exactly once.";
969
970    // Verifies that the control flow in the test function is expected.
971    if (expected_to_finish_ && !finished_) {
972      FAIL() << "The predicate assertion unexpactedly aborted the test.";
973    } else if (!expected_to_finish_ && finished_) {
974      FAIL() << "The failed predicate assertion didn't abort the test "
975                "as expected.";
976    }
977  }
978
979  // true iff the test function is expected to run to finish.
980  static bool expected_to_finish_;
981
982  // true iff the test function did run to finish.
983  static bool finished_;
984
985  static int n1_;
986  static int n2_;
987  static int n3_;
988};
989
990bool Predicate3Test::expected_to_finish_;
991bool Predicate3Test::finished_;
992int Predicate3Test::n1_;
993int Predicate3Test::n2_;
994int Predicate3Test::n3_;
995
996typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
997typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
998typedef Predicate3Test EXPECT_PRED3Test;
999typedef Predicate3Test ASSERT_PRED3Test;
1000
1001// Tests a successful EXPECT_PRED3 where the
1002// predicate-formatter is a function on a built-in type (int).
1003TEST_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).
1013TEST_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).
1023TEST_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).
1033TEST_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).
1043TEST_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).
1055TEST_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).
1067TEST_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).
1079TEST_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).
1091TEST_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).
1101TEST_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).
1111TEST_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).
1121TEST_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).
1131TEST_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).
1144TEST_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).
1157TEST_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).
1170TEST_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).
1183TEST_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).
1193TEST_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).
1203TEST_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).
1213TEST_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).
1223TEST_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).
1235TEST_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).
1247TEST_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).
1259TEST_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).
1271TEST_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).
1281TEST_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).
1291TEST_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).
1301TEST_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).
1311TEST_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).
1324TEST_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).
1337TEST_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).
1350TEST_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.
1363template <typename T1, typename T2, typename T3, typename T4>
1364bool 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.
1371bool PredFunction4Int(int v1, int v2, int v3, int v4) {
1372  return v1 + v2 + v3 + v4 > 0;
1373}
1374bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
1375  return v1 + v2 + v3 + v4 > 0;
1376}
1377
1378// A 4-ary predicate functor.
1379struct PredFunctor4 {
1380  template <typename T1, typename T2, typename T3, typename T4>
1381  bool operator()(const T1& v1,
1382                  const T2& v2,
1383                  const T3& v3,
1384                  const T4& v4) {
1385    return v1 + v2 + v3 + v4 > 0;
1386  }
1387};
1388
1389// A 4-ary predicate-formatter function.
1390template <typename T1, typename T2, typename T3, typename T4>
1391testing::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.
1409struct PredFormatFunctor4 {
1410  template <typename T1, typename T2, typename T3, typename T4>
1411  testing::AssertionResult operator()(const char* e1,
1412                                      const char* e2,
1413                                      const char* e3,
1414                                      const char* e4,
1415                                      const T1& v1,
1416                                      const T2& v2,
1417                                      const T3& v3,
1418                                      const T4& v4) const {
1419    return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
1420  }
1421};
1422
1423// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
1424
1425class Predicate4Test : public testing::Test {
1426 protected:
1427  virtual void SetUp() {
1428    expected_to_finish_ = true;
1429    finished_ = false;
1430    n1_ = n2_ = n3_ = n4_ = 0;
1431  }
1432
1433  virtual void TearDown() {
1434    // Verifies that each of the predicate's arguments was evaluated
1435    // exactly once.
1436    EXPECT_EQ(1, n1_) <<
1437        "The predicate assertion didn't evaluate argument 2 "
1438        "exactly once.";
1439    EXPECT_EQ(1, n2_) <<
1440        "The predicate assertion didn't evaluate argument 3 "
1441        "exactly once.";
1442    EXPECT_EQ(1, n3_) <<
1443        "The predicate assertion didn't evaluate argument 4 "
1444        "exactly once.";
1445    EXPECT_EQ(1, n4_) <<
1446        "The predicate assertion didn't evaluate argument 5 "
1447        "exactly once.";
1448
1449    // Verifies that the control flow in the test function is expected.
1450    if (expected_to_finish_ && !finished_) {
1451      FAIL() << "The predicate assertion unexpactedly aborted the test.";
1452    } else if (!expected_to_finish_ && finished_) {
1453      FAIL() << "The failed predicate assertion didn't abort the test "
1454                "as expected.";
1455    }
1456  }
1457
1458  // true iff the test function is expected to run to finish.
1459  static bool expected_to_finish_;
1460
1461  // true iff the test function did run to finish.
1462  static bool finished_;
1463
1464  static int n1_;
1465  static int n2_;
1466  static int n3_;
1467  static int n4_;
1468};
1469
1470bool Predicate4Test::expected_to_finish_;
1471bool Predicate4Test::finished_;
1472int Predicate4Test::n1_;
1473int Predicate4Test::n2_;
1474int Predicate4Test::n3_;
1475int Predicate4Test::n4_;
1476
1477typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
1478typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
1479typedef Predicate4Test EXPECT_PRED4Test;
1480typedef Predicate4Test ASSERT_PRED4Test;
1481
1482// Tests a successful EXPECT_PRED4 where the
1483// predicate-formatter is a function on a built-in type (int).
1484TEST_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).
1495TEST_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).
1506TEST_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).
1517TEST_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).
1528TEST_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).
1541TEST_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).
1554TEST_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).
1567TEST_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).
1580TEST_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).
1591TEST_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).
1602TEST_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).
1613TEST_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).
1624TEST_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).
1638TEST_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).
1652TEST_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).
1666TEST_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).
1680TEST_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).
1691TEST_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).
1702TEST_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).
1713TEST_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).
1724TEST_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).
1737TEST_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).
1750TEST_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).
1763TEST_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).
1776TEST_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).
1787TEST_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).
1798TEST_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).
1809TEST_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).
1820TEST_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).
1834TEST_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).
1848TEST_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).
1862TEST_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.
1876template <typename T1, typename T2, typename T3, typename T4, typename T5>
1877bool 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.
1884bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
1885  return v1 + v2 + v3 + v4 + v5 > 0;
1886}
1887bool 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.
1892struct PredFunctor5 {
1893  template <typename T1, typename T2, typename T3, typename T4, typename T5>
1894  bool operator()(const T1& v1,
1895                  const T2& v2,
1896                  const T3& v3,
1897                  const T4& v4,
1898                  const T5& v5) {
1899    return v1 + v2 + v3 + v4 + v5 > 0;
1900  }
1901};
1902
1903// A 5-ary predicate-formatter function.
1904template <typename T1, typename T2, typename T3, typename T4, typename T5>
1905testing::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.
1925struct PredFormatFunctor5 {
1926  template <typename T1, typename T2, typename T3, typename T4, typename T5>
1927  testing::AssertionResult operator()(const char* e1,
1928                                      const char* e2,
1929                                      const char* e3,
1930                                      const char* e4,
1931                                      const char* e5,
1932                                      const T1& v1,
1933                                      const T2& v2,
1934                                      const T3& v3,
1935                                      const T4& v4,
1936                                      const T5& v5) const {
1937    return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
1938  }
1939};
1940
1941// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
1942
1943class Predicate5Test : public testing::Test {
1944 protected:
1945  virtual void SetUp() {
1946    expected_to_finish_ = true;
1947    finished_ = false;
1948    n1_ = n2_ = n3_ = n4_ = n5_ = 0;
1949  }
1950
1951  virtual void TearDown() {
1952    // Verifies that each of the predicate's arguments was evaluated
1953    // exactly once.
1954    EXPECT_EQ(1, n1_) <<
1955        "The predicate assertion didn't evaluate argument 2 "
1956        "exactly once.";
1957    EXPECT_EQ(1, n2_) <<
1958        "The predicate assertion didn't evaluate argument 3 "
1959        "exactly once.";
1960    EXPECT_EQ(1, n3_) <<
1961        "The predicate assertion didn't evaluate argument 4 "
1962        "exactly once.";
1963    EXPECT_EQ(1, n4_) <<
1964        "The predicate assertion didn't evaluate argument 5 "
1965        "exactly once.";
1966    EXPECT_EQ(1, n5_) <<
1967        "The predicate assertion didn't evaluate argument 6 "
1968        "exactly once.";
1969
1970    // Verifies that the control flow in the test function is expected.
1971    if (expected_to_finish_ && !finished_) {
1972      FAIL() << "The predicate assertion unexpactedly aborted the test.";
1973    } else if (!expected_to_finish_ && finished_) {
1974      FAIL() << "The failed predicate assertion didn't abort the test "
1975                "as expected.";
1976    }
1977  }
1978
1979  // true iff the test function is expected to run to finish.
1980  static bool expected_to_finish_;
1981
1982  // true iff the test function did run to finish.
1983  static bool finished_;
1984
1985  static int n1_;
1986  static int n2_;
1987  static int n3_;
1988  static int n4_;
1989  static int n5_;
1990};
1991
1992bool Predicate5Test::expected_to_finish_;
1993bool Predicate5Test::finished_;
1994int Predicate5Test::n1_;
1995int Predicate5Test::n2_;
1996int Predicate5Test::n3_;
1997int Predicate5Test::n4_;
1998int Predicate5Test::n5_;
1999
2000typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
2001typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
2002typedef Predicate5Test EXPECT_PRED5Test;
2003typedef Predicate5Test ASSERT_PRED5Test;
2004
2005// Tests a successful EXPECT_PRED5 where the
2006// predicate-formatter is a function on a built-in type (int).
2007TEST_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).
2019TEST_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).
2031TEST_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).
2043TEST_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).
2055TEST_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).
2069TEST_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).
2083TEST_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).
2097TEST_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).
2111TEST_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).
2123TEST_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).
2135TEST_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).
2147TEST_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).
2159TEST_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).
2174TEST_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).
2189TEST_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).
2204TEST_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).
2219TEST_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).
2231TEST_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).
2243TEST_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).
2255TEST_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).
2267TEST_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).
2281TEST_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).
2295TEST_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).
2309TEST_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).
2323TEST_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).
2335TEST_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).
2347TEST_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).
2359TEST_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).
2371TEST_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).
2386TEST_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).
2401TEST_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).
2416TEST_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