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