49#include "gtest/gtest-spi.h"
50#include "gtest/gtest.h"
54 explicit Bool(
int val) : value(val != 0) {}
56 bool operator>(
int n)
const {
return value >
Bool(n).value; }
58 Bool operator+(
const Bool& rhs)
const {
return Bool(value + rhs.value); }
60 bool operator==(
const Bool& rhs)
const {
return value == rhs.value; }
66std::ostream& operator<<(std::ostream& os,
const Bool& x) {
67 return os << (x.value ?
"true" :
"false");
74bool PredFunction1(T1 v1) {
80bool PredFunction1Int(
int v1) {
return v1 > 0; }
81bool PredFunction1Bool(
Bool v1) {
return v1 > 0; }
85 template <
typename T1>
86 bool operator()(
const T1& v1) {
93testing::AssertionResult PredFormatFunction1(
const char* e1,
const T1& v1) {
94 if (PredFunction1(v1))
return testing::AssertionSuccess();
96 return testing::AssertionFailure()
97 << e1 <<
" is expected to be positive, but evaluates to " << v1 <<
".";
102 template <
typename T1>
103 testing::AssertionResult operator()(
const char* e1,
const T1& v1)
const {
104 return PredFormatFunction1(e1, v1);
112 void SetUp()
override {
113 expected_to_finish_ =
true;
118 void TearDown()
override {
121 EXPECT_EQ(1, n1_) <<
"The predicate assertion didn't evaluate argument 2 "
125 if (expected_to_finish_ && !finished_) {
126 FAIL() <<
"The predicate assertion unexpectedly aborted the test.";
127 }
else if (!expected_to_finish_ && finished_) {
128 FAIL() <<
"The failed predicate assertion didn't abort the test "
134 static bool expected_to_finish_;
137 static bool finished_;
142bool Predicate1Test::expected_to_finish_;
143bool Predicate1Test::finished_;
144int Predicate1Test::n1_;
154 EXPECT_PRED1(PredFunction1Int, ++n1_);
161 EXPECT_PRED1(PredFunction1Bool,
Bool(++n1_));
182 EXPECT_NONFATAL_FAILURE(
184 EXPECT_PRED1(PredFunction1Int, n1_++);
193 EXPECT_NONFATAL_FAILURE(
195 EXPECT_PRED1(PredFunction1Bool,
Bool(n1_++));
204 EXPECT_NONFATAL_FAILURE(
215 EXPECT_NONFATAL_FAILURE(
226 ASSERT_PRED1(PredFunction1Int, ++n1_);
233 ASSERT_PRED1(PredFunction1Bool,
Bool(++n1_));
254 expected_to_finish_ =
false;
255 EXPECT_FATAL_FAILURE(
257 ASSERT_PRED1(PredFunction1Int, n1_++);
266 expected_to_finish_ =
false;
267 EXPECT_FATAL_FAILURE(
269 ASSERT_PRED1(PredFunction1Bool,
Bool(n1_++));
278 expected_to_finish_ =
false;
279 EXPECT_FATAL_FAILURE(
290 expected_to_finish_ =
false;
291 EXPECT_FATAL_FAILURE(
302 EXPECT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
309 EXPECT_PRED_FORMAT1(PredFormatFunction1,
Bool(++n1_));
330 EXPECT_NONFATAL_FAILURE(
332 EXPECT_PRED_FORMAT1(PredFormatFunction1, n1_++);
341 EXPECT_NONFATAL_FAILURE(
343 EXPECT_PRED_FORMAT1(PredFormatFunction1,
Bool(n1_++));
352 EXPECT_NONFATAL_FAILURE(
363 EXPECT_NONFATAL_FAILURE(
374 ASSERT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
381 ASSERT_PRED_FORMAT1(PredFormatFunction1,
Bool(++n1_));
402 expected_to_finish_ =
false;
403 EXPECT_FATAL_FAILURE(
405 ASSERT_PRED_FORMAT1(PredFormatFunction1, n1_++);
414 expected_to_finish_ =
false;
415 EXPECT_FATAL_FAILURE(
417 ASSERT_PRED_FORMAT1(PredFormatFunction1,
Bool(n1_++));
426 expected_to_finish_ =
false;
427 EXPECT_FATAL_FAILURE(
438 expected_to_finish_ =
false;
439 EXPECT_FATAL_FAILURE(
449template <
typename T1,
typename T2>
450bool PredFunction2(T1 v1, T2 v2) {
456bool PredFunction2Int(
int v1,
int v2) {
return v1 + v2 > 0; }
457bool PredFunction2Bool(
Bool v1,
Bool v2) {
return v1 + v2 > 0; }
461 template <
typename T1,
typename T2>
462 bool operator()(
const T1& v1,
const T2& v2) {
468template <
typename T1,
typename T2>
469testing::AssertionResult PredFormatFunction2(
const char* e1,
const char* e2,
470 const T1& v1,
const T2& v2) {
471 if (PredFunction2(v1, v2))
return testing::AssertionSuccess();
473 return testing::AssertionFailure()
475 <<
" is expected to be positive, but evaluates to " << v1 + v2 <<
".";
480 template <
typename T1,
typename T2>
481 testing::AssertionResult operator()(
const char* e1,
const char* e2,
482 const T1& v1,
const T2& v2)
const {
483 return PredFormatFunction2(e1, e2, v1, v2);
491 void SetUp()
override {
492 expected_to_finish_ =
true;
497 void TearDown()
override {
500 EXPECT_EQ(1, n1_) <<
"The predicate assertion didn't evaluate argument 2 "
502 EXPECT_EQ(1, n2_) <<
"The predicate assertion didn't evaluate argument 3 "
506 if (expected_to_finish_ && !finished_) {
507 FAIL() <<
"The predicate assertion unexpectedly aborted the test.";
508 }
else if (!expected_to_finish_ && finished_) {
509 FAIL() <<
"The failed predicate assertion didn't abort the test "
515 static bool expected_to_finish_;
518 static bool finished_;
524bool Predicate2Test::expected_to_finish_;
525bool Predicate2Test::finished_;
526int Predicate2Test::n1_;
527int Predicate2Test::n2_;
537 EXPECT_PRED2(PredFunction2Int, ++n1_, ++n2_);
544 EXPECT_PRED2(PredFunction2Bool,
Bool(++n1_),
Bool(++n2_));
565 EXPECT_NONFATAL_FAILURE(
567 EXPECT_PRED2(PredFunction2Int, n1_++, n2_++);
576 EXPECT_NONFATAL_FAILURE(
578 EXPECT_PRED2(PredFunction2Bool,
Bool(n1_++),
Bool(n2_++));
587 EXPECT_NONFATAL_FAILURE(
598 EXPECT_NONFATAL_FAILURE(
609 ASSERT_PRED2(PredFunction2Int, ++n1_, ++n2_);
616 ASSERT_PRED2(PredFunction2Bool,
Bool(++n1_),
Bool(++n2_));
637 expected_to_finish_ =
false;
638 EXPECT_FATAL_FAILURE(
640 ASSERT_PRED2(PredFunction2Int, n1_++, n2_++);
649 expected_to_finish_ =
false;
650 EXPECT_FATAL_FAILURE(
652 ASSERT_PRED2(PredFunction2Bool,
Bool(n1_++),
Bool(n2_++));
661 expected_to_finish_ =
false;
662 EXPECT_FATAL_FAILURE(
673 expected_to_finish_ =
false;
674 EXPECT_FATAL_FAILURE(
685 EXPECT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
692 EXPECT_PRED_FORMAT2(PredFormatFunction2,
Bool(++n1_),
Bool(++n2_));
713 EXPECT_NONFATAL_FAILURE(
715 EXPECT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
724 EXPECT_NONFATAL_FAILURE(
726 EXPECT_PRED_FORMAT2(PredFormatFunction2,
Bool(n1_++),
Bool(n2_++));
735 EXPECT_NONFATAL_FAILURE(
746 EXPECT_NONFATAL_FAILURE(
757 ASSERT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
764 ASSERT_PRED_FORMAT2(PredFormatFunction2,
Bool(++n1_),
Bool(++n2_));
785 expected_to_finish_ =
false;
786 EXPECT_FATAL_FAILURE(
788 ASSERT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
797 expected_to_finish_ =
false;
798 EXPECT_FATAL_FAILURE(
800 ASSERT_PRED_FORMAT2(PredFormatFunction2,
Bool(n1_++),
Bool(n2_++));
809 expected_to_finish_ =
false;
810 EXPECT_FATAL_FAILURE(
821 expected_to_finish_ =
false;
822 EXPECT_FATAL_FAILURE(
832template <
typename T1,
typename T2,
typename T3>
833bool PredFunction3(T1 v1, T2 v2, T3 v3) {
834 return v1 + v2 + v3 > 0;
839bool PredFunction3Int(
int v1,
int v2,
int v3) {
return v1 + v2 + v3 > 0; }
840bool PredFunction3Bool(
Bool v1,
Bool v2,
Bool v3) {
return v1 + v2 + v3 > 0; }
844 template <
typename T1,
typename T2,
typename T3>
845 bool operator()(
const T1& v1,
const T2& v2,
const T3& v3) {
846 return v1 + v2 + v3 > 0;
851template <
typename T1,
typename T2,
typename T3>
852testing::AssertionResult PredFormatFunction3(
const char* e1,
const char* e2,
853 const char* e3,
const T1& v1,
854 const T2& v2,
const T3& v3) {
855 if (PredFunction3(v1, v2, v3))
return testing::AssertionSuccess();
857 return testing::AssertionFailure()
858 << e1 <<
" + " << e2 <<
" + " << e3
859 <<
" is expected to be positive, but evaluates to " << v1 + v2 + v3
865 template <
typename T1,
typename T2,
typename T3>
866 testing::AssertionResult operator()(
const char* e1,
const char* e2,
867 const char* e3,
const T1& v1,
868 const T2& v2,
const T3& v3)
const {
869 return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
877 void SetUp()
override {
878 expected_to_finish_ =
true;
883 void TearDown()
override {
886 EXPECT_EQ(1, n1_) <<
"The predicate assertion didn't evaluate argument 2 "
888 EXPECT_EQ(1, n2_) <<
"The predicate assertion didn't evaluate argument 3 "
890 EXPECT_EQ(1, n3_) <<
"The predicate assertion didn't evaluate argument 4 "
894 if (expected_to_finish_ && !finished_) {
895 FAIL() <<
"The predicate assertion unexpectedly aborted the test.";
896 }
else if (!expected_to_finish_ && finished_) {
897 FAIL() <<
"The failed predicate assertion didn't abort the test "
903 static bool expected_to_finish_;
906 static bool finished_;
913bool Predicate3Test::expected_to_finish_;
914bool Predicate3Test::finished_;
915int Predicate3Test::n1_;
916int Predicate3Test::n2_;
917int Predicate3Test::n3_;
927 EXPECT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
934 EXPECT_PRED3(PredFunction3Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
955 EXPECT_NONFATAL_FAILURE(
957 EXPECT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
966 EXPECT_NONFATAL_FAILURE(
968 EXPECT_PRED3(PredFunction3Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++));
977 EXPECT_NONFATAL_FAILURE(
988 EXPECT_NONFATAL_FAILURE(
999 ASSERT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
1006 ASSERT_PRED3(PredFunction3Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
1027 expected_to_finish_ =
false;
1028 EXPECT_FATAL_FAILURE(
1030 ASSERT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
1039 expected_to_finish_ =
false;
1040 EXPECT_FATAL_FAILURE(
1042 ASSERT_PRED3(PredFunction3Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++));
1051 expected_to_finish_ =
false;
1052 EXPECT_FATAL_FAILURE(
1063 expected_to_finish_ =
false;
1064 EXPECT_FATAL_FAILURE(
1075 EXPECT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
1082 EXPECT_PRED_FORMAT3(PredFormatFunction3,
Bool(++n1_),
Bool(++n2_),
1105 EXPECT_NONFATAL_FAILURE(
1107 EXPECT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
1116 EXPECT_NONFATAL_FAILURE(
1118 EXPECT_PRED_FORMAT3(PredFormatFunction3,
Bool(n1_++),
Bool(n2_++),
1128 EXPECT_NONFATAL_FAILURE(
1139 EXPECT_NONFATAL_FAILURE(
1151 ASSERT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
1158 ASSERT_PRED_FORMAT3(PredFormatFunction3,
Bool(++n1_),
Bool(++n2_),
1181 expected_to_finish_ =
false;
1182 EXPECT_FATAL_FAILURE(
1184 ASSERT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
1193 expected_to_finish_ =
false;
1194 EXPECT_FATAL_FAILURE(
1196 ASSERT_PRED_FORMAT3(PredFormatFunction3,
Bool(n1_++),
Bool(n2_++),
1206 expected_to_finish_ =
false;
1207 EXPECT_FATAL_FAILURE(
1218 expected_to_finish_ =
false;
1219 EXPECT_FATAL_FAILURE(
1230template <
typename T1,
typename T2,
typename T3,
typename T4>
1231bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
1232 return v1 + v2 + v3 + v4 > 0;
1237bool PredFunction4Int(
int v1,
int v2,
int v3,
int v4) {
1238 return v1 + v2 + v3 + v4 > 0;
1241 return v1 + v2 + v3 + v4 > 0;
1246 template <
typename T1,
typename T2,
typename T3,
typename T4>
1247 bool operator()(
const T1& v1,
const T2& v2,
const T3& v3,
const T4& v4) {
1248 return v1 + v2 + v3 + v4 > 0;
1253template <
typename T1,
typename T2,
typename T3,
typename T4>
1254testing::AssertionResult PredFormatFunction4(
const char* e1,
const char* e2,
1255 const char* e3,
const char* e4,
1256 const T1& v1,
const T2& v2,
1257 const T3& v3,
const T4& v4) {
1258 if (PredFunction4(v1, v2, v3, v4))
return testing::AssertionSuccess();
1260 return testing::AssertionFailure()
1261 << e1 <<
" + " << e2 <<
" + " << e3 <<
" + " << e4
1262 <<
" is expected to be positive, but evaluates to "
1263 << v1 + v2 + v3 + v4 <<
".";
1268 template <
typename T1,
typename T2,
typename T3,
typename T4>
1269 testing::AssertionResult operator()(
const char* e1,
const char* e2,
1270 const char* e3,
const char* e4,
1271 const T1& v1,
const T2& v2,
const T3& v3,
1272 const T4& v4)
const {
1273 return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
1281 void SetUp()
override {
1282 expected_to_finish_ =
true;
1284 n1_ = n2_ = n3_ = n4_ = 0;
1287 void TearDown()
override {
1290 EXPECT_EQ(1, n1_) <<
"The predicate assertion didn't evaluate argument 2 "
1292 EXPECT_EQ(1, n2_) <<
"The predicate assertion didn't evaluate argument 3 "
1294 EXPECT_EQ(1, n3_) <<
"The predicate assertion didn't evaluate argument 4 "
1296 EXPECT_EQ(1, n4_) <<
"The predicate assertion didn't evaluate argument 5 "
1300 if (expected_to_finish_ && !finished_) {
1301 FAIL() <<
"The predicate assertion unexpectedly aborted the test.";
1302 }
else if (!expected_to_finish_ && finished_) {
1303 FAIL() <<
"The failed predicate assertion didn't abort the test "
1309 static bool expected_to_finish_;
1312 static bool finished_;
1320bool Predicate4Test::expected_to_finish_;
1321bool Predicate4Test::finished_;
1322int Predicate4Test::n1_;
1323int Predicate4Test::n2_;
1324int Predicate4Test::n3_;
1325int Predicate4Test::n4_;
1335 EXPECT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
1342 EXPECT_PRED4(PredFunction4Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
1350 EXPECT_PRED4(
PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
1365 EXPECT_NONFATAL_FAILURE(
1367 EXPECT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
1376 EXPECT_NONFATAL_FAILURE(
1378 EXPECT_PRED4(PredFunction4Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++),
1388 EXPECT_NONFATAL_FAILURE(
1390 EXPECT_PRED4(
PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
1399 EXPECT_NONFATAL_FAILURE(
1411 ASSERT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
1418 ASSERT_PRED4(PredFunction4Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
1426 ASSERT_PRED4(
PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
1441 expected_to_finish_ =
false;
1442 EXPECT_FATAL_FAILURE(
1444 ASSERT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
1453 expected_to_finish_ =
false;
1454 EXPECT_FATAL_FAILURE(
1456 ASSERT_PRED4(PredFunction4Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++),
1466 expected_to_finish_ =
false;
1467 EXPECT_FATAL_FAILURE(
1469 ASSERT_PRED4(
PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
1478 expected_to_finish_ =
false;
1479 EXPECT_FATAL_FAILURE(
1491 EXPECT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
1498 EXPECT_PRED_FORMAT4(PredFormatFunction4,
Bool(++n1_),
Bool(++n2_),
1521 EXPECT_NONFATAL_FAILURE(
1523 EXPECT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
1532 EXPECT_NONFATAL_FAILURE(
1534 EXPECT_PRED_FORMAT4(PredFormatFunction4,
Bool(n1_++),
Bool(n2_++),
1544 EXPECT_NONFATAL_FAILURE(
1555 EXPECT_NONFATAL_FAILURE(
1567 ASSERT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
1574 ASSERT_PRED_FORMAT4(PredFormatFunction4,
Bool(++n1_),
Bool(++n2_),
1597 expected_to_finish_ =
false;
1598 EXPECT_FATAL_FAILURE(
1600 ASSERT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
1609 expected_to_finish_ =
false;
1610 EXPECT_FATAL_FAILURE(
1612 ASSERT_PRED_FORMAT4(PredFormatFunction4,
Bool(n1_++),
Bool(n2_++),
1622 expected_to_finish_ =
false;
1623 EXPECT_FATAL_FAILURE(
1634 expected_to_finish_ =
false;
1635 EXPECT_FATAL_FAILURE(
1646template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1647bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
1648 return v1 + v2 + v3 + v4 + v5 > 0;
1653bool PredFunction5Int(
int v1,
int v2,
int v3,
int v4,
int v5) {
1654 return v1 + v2 + v3 + v4 + v5 > 0;
1657 return v1 + v2 + v3 + v4 + v5 > 0;
1662 template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1663 bool operator()(
const T1& v1,
const T2& v2,
const T3& v3,
const T4& v4,
1665 return v1 + v2 + v3 + v4 + v5 > 0;
1670template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1671testing::AssertionResult PredFormatFunction5(
const char* e1,
const char* e2,
1672 const char* e3,
const char* e4,
1673 const char* e5,
const T1& v1,
1674 const T2& v2,
const T3& v3,
1675 const T4& v4,
const T5& v5) {
1676 if (PredFunction5(v1, v2, v3, v4, v5))
return testing::AssertionSuccess();
1678 return testing::AssertionFailure()
1679 << e1 <<
" + " << e2 <<
" + " << e3 <<
" + " << e4 <<
" + " << e5
1680 <<
" is expected to be positive, but evaluates to "
1681 << v1 + v2 + v3 + v4 + v5 <<
".";
1686 template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1687 testing::AssertionResult operator()(
const char* e1,
const char* e2,
1688 const char* e3,
const char* e4,
1689 const char* e5,
const T1& v1,
1690 const T2& v2,
const T3& v3,
const T4& v4,
1691 const T5& v5)
const {
1692 return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
1700 void SetUp()
override {
1701 expected_to_finish_ =
true;
1703 n1_ = n2_ = n3_ = n4_ = n5_ = 0;
1706 void TearDown()
override {
1709 EXPECT_EQ(1, n1_) <<
"The predicate assertion didn't evaluate argument 2 "
1711 EXPECT_EQ(1, n2_) <<
"The predicate assertion didn't evaluate argument 3 "
1713 EXPECT_EQ(1, n3_) <<
"The predicate assertion didn't evaluate argument 4 "
1715 EXPECT_EQ(1, n4_) <<
"The predicate assertion didn't evaluate argument 5 "
1717 EXPECT_EQ(1, n5_) <<
"The predicate assertion didn't evaluate argument 6 "
1721 if (expected_to_finish_ && !finished_) {
1722 FAIL() <<
"The predicate assertion unexpectedly aborted the test.";
1723 }
else if (!expected_to_finish_ && finished_) {
1724 FAIL() <<
"The failed predicate assertion didn't abort the test "
1730 static bool expected_to_finish_;
1733 static bool finished_;
1742bool Predicate5Test::expected_to_finish_;
1743bool Predicate5Test::finished_;
1744int Predicate5Test::n1_;
1745int Predicate5Test::n2_;
1746int Predicate5Test::n3_;
1747int Predicate5Test::n4_;
1748int Predicate5Test::n5_;
1758 EXPECT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1765 EXPECT_PRED5(PredFunction5Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
1773 EXPECT_PRED5(
PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1788 EXPECT_NONFATAL_FAILURE(
1790 EXPECT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
1799 EXPECT_NONFATAL_FAILURE(
1801 EXPECT_PRED5(PredFunction5Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++),
1811 EXPECT_NONFATAL_FAILURE(
1813 EXPECT_PRED5(
PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
1822 EXPECT_NONFATAL_FAILURE(
1834 ASSERT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1841 ASSERT_PRED5(PredFunction5Bool,
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
1849 ASSERT_PRED5(
PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1864 expected_to_finish_ =
false;
1865 EXPECT_FATAL_FAILURE(
1867 ASSERT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
1876 expected_to_finish_ =
false;
1877 EXPECT_FATAL_FAILURE(
1879 ASSERT_PRED5(PredFunction5Bool,
Bool(n1_++),
Bool(n2_++),
Bool(n3_++),
1889 expected_to_finish_ =
false;
1890 EXPECT_FATAL_FAILURE(
1892 ASSERT_PRED5(
PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
1901 expected_to_finish_ =
false;
1902 EXPECT_FATAL_FAILURE(
1914 EXPECT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1921 EXPECT_PRED_FORMAT5(PredFormatFunction5,
Bool(++n1_),
Bool(++n2_),
1944 EXPECT_NONFATAL_FAILURE(
1946 EXPECT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
1956 EXPECT_NONFATAL_FAILURE(
1958 EXPECT_PRED_FORMAT5(PredFormatFunction5,
Bool(n1_++),
Bool(n2_++),
1968 EXPECT_NONFATAL_FAILURE(
1980 EXPECT_NONFATAL_FAILURE(
1992 ASSERT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
1999 ASSERT_PRED_FORMAT5(PredFormatFunction5,
Bool(++n1_),
Bool(++n2_),
2022 expected_to_finish_ =
false;
2023 EXPECT_FATAL_FAILURE(
2025 ASSERT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
2035 expected_to_finish_ =
false;
2036 EXPECT_FATAL_FAILURE(
2038 ASSERT_PRED_FORMAT5(PredFormatFunction5,
Bool(n1_++),
Bool(n2_++),
2048 expected_to_finish_ =
false;
2049 EXPECT_FATAL_FAILURE(
2061 expected_to_finish_ =
false;
2062 EXPECT_FATAL_FAILURE(
Definition gtest_pred_impl_unittest.cc:110
Definition gtest_pred_impl_unittest.cc:489
Definition gtest_pred_impl_unittest.cc:875
Definition gtest_pred_impl_unittest.cc:1279
Definition gtest_pred_impl_unittest.cc:1698
Definition gtest_pred_impl_unittest.cc:53
Definition gtest_pred_impl_unittest.cc:84
Definition gtest_pred_impl_unittest.cc:460
Definition gtest_pred_impl_unittest.cc:843
Definition gtest_pred_impl_unittest.cc:1245
Definition gtest_pred_impl_unittest.cc:1661