52#include "gtest/gtest.h"
53#include "gtest/gtest-spi.h"
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; }
69std::ostream& operator<<(std::ostream& os,
const Bool& x) {
70 return os << (x.value ?
"true" :
"false");
77bool PredFunction1(T1 v1) {
83bool PredFunction1Int(
int v1) {
86bool PredFunction1Bool(
Bool v1) {
92 template <
typename T1>
93 bool operator()(
const T1& v1) {
100testing::AssertionResult PredFormatFunction1(
const char* e1,
102 if (PredFunction1(v1))
103 return testing::AssertionSuccess();
105 return testing::AssertionFailure()
107 <<
" is expected to be positive, but evaluates to "
113 template <
typename T1>
114 testing::AssertionResult operator()(
const char* e1,
115 const T1& v1)
const {
116 return PredFormatFunction1(e1, v1);
124 void SetUp()
override {
125 expected_to_finish_ =
true;
130 void TearDown()
override {
134 "The predicate assertion didn't evaluate argument 2 "
138 if (expected_to_finish_ && !finished_) {
139 FAIL() <<
"The predicate assertion unexpactedly aborted the test.";
140 }
else if (!expected_to_finish_ && finished_) {
141 FAIL() <<
"The failed predicate assertion didn't abort the test "
147 static bool expected_to_finish_;
150 static bool finished_;
155bool Predicate1Test::expected_to_finish_;
156bool Predicate1Test::finished_;
157int Predicate1Test::n1_;
167 EXPECT_PRED1(PredFunction1Int,
175 EXPECT_PRED1(PredFunction1Bool,
199 EXPECT_NONFATAL_FAILURE({
200 EXPECT_PRED1(PredFunction1Int,
209 EXPECT_NONFATAL_FAILURE({
210 EXPECT_PRED1(PredFunction1Bool,
219 EXPECT_NONFATAL_FAILURE({
229 EXPECT_NONFATAL_FAILURE({
239 ASSERT_PRED1(PredFunction1Int,
247 ASSERT_PRED1(PredFunction1Bool,
271 expected_to_finish_ =
false;
272 EXPECT_FATAL_FAILURE({
273 ASSERT_PRED1(PredFunction1Int,
282 expected_to_finish_ =
false;
283 EXPECT_FATAL_FAILURE({
284 ASSERT_PRED1(PredFunction1Bool,
293 expected_to_finish_ =
false;
294 EXPECT_FATAL_FAILURE({
304 expected_to_finish_ =
false;
305 EXPECT_FATAL_FAILURE({
315 EXPECT_PRED_FORMAT1(PredFormatFunction1,
323 EXPECT_PRED_FORMAT1(PredFormatFunction1,
347 EXPECT_NONFATAL_FAILURE({
348 EXPECT_PRED_FORMAT1(PredFormatFunction1,
357 EXPECT_NONFATAL_FAILURE({
358 EXPECT_PRED_FORMAT1(PredFormatFunction1,
367 EXPECT_NONFATAL_FAILURE({
377 EXPECT_NONFATAL_FAILURE({
387 ASSERT_PRED_FORMAT1(PredFormatFunction1,
395 ASSERT_PRED_FORMAT1(PredFormatFunction1,
419 expected_to_finish_ =
false;
420 EXPECT_FATAL_FAILURE({
421 ASSERT_PRED_FORMAT1(PredFormatFunction1,
430 expected_to_finish_ =
false;
431 EXPECT_FATAL_FAILURE({
432 ASSERT_PRED_FORMAT1(PredFormatFunction1,
441 expected_to_finish_ =
false;
442 EXPECT_FATAL_FAILURE({
452 expected_to_finish_ =
false;
453 EXPECT_FATAL_FAILURE({
462template <
typename T1,
typename T2>
463bool PredFunction2(T1 v1, T2 v2) {
469bool PredFunction2Int(
int v1,
int v2) {
472bool PredFunction2Bool(
Bool v1,
Bool v2) {
478 template <
typename T1,
typename T2>
479 bool operator()(
const T1& v1,
486template <
typename T1,
typename T2>
487testing::AssertionResult PredFormatFunction2(
const char* e1,
491 if (PredFunction2(v1, v2))
492 return testing::AssertionSuccess();
494 return testing::AssertionFailure()
496 <<
" is expected to be positive, but evaluates to "
502 template <
typename T1,
typename T2>
503 testing::AssertionResult operator()(
const char* e1,
506 const T2& v2)
const {
507 return PredFormatFunction2(e1, e2, v1, v2);
515 void SetUp()
override {
516 expected_to_finish_ =
true;
521 void TearDown()
override {
525 "The predicate assertion didn't evaluate argument 2 "
528 "The predicate assertion didn't evaluate argument 3 "
532 if (expected_to_finish_ && !finished_) {
533 FAIL() <<
"The predicate assertion unexpactedly aborted the test.";
534 }
else if (!expected_to_finish_ && finished_) {
535 FAIL() <<
"The failed predicate assertion didn't abort the test "
541 static bool expected_to_finish_;
544 static bool finished_;
550bool Predicate2Test::expected_to_finish_;
551bool Predicate2Test::finished_;
552int Predicate2Test::n1_;
553int Predicate2Test::n2_;
563 EXPECT_PRED2(PredFunction2Int,
572 EXPECT_PRED2(PredFunction2Bool,
599 EXPECT_NONFATAL_FAILURE({
600 EXPECT_PRED2(PredFunction2Int,
610 EXPECT_NONFATAL_FAILURE({
611 EXPECT_PRED2(PredFunction2Bool,
621 EXPECT_NONFATAL_FAILURE({
632 EXPECT_NONFATAL_FAILURE({
643 ASSERT_PRED2(PredFunction2Int,
652 ASSERT_PRED2(PredFunction2Bool,
679 expected_to_finish_ =
false;
680 EXPECT_FATAL_FAILURE({
681 ASSERT_PRED2(PredFunction2Int,
691 expected_to_finish_ =
false;
692 EXPECT_FATAL_FAILURE({
693 ASSERT_PRED2(PredFunction2Bool,
703 expected_to_finish_ =
false;
704 EXPECT_FATAL_FAILURE({
715 expected_to_finish_ =
false;
716 EXPECT_FATAL_FAILURE({
727 EXPECT_PRED_FORMAT2(PredFormatFunction2,
736 EXPECT_PRED_FORMAT2(PredFormatFunction2,
763 EXPECT_NONFATAL_FAILURE({
764 EXPECT_PRED_FORMAT2(PredFormatFunction2,
774 EXPECT_NONFATAL_FAILURE({
775 EXPECT_PRED_FORMAT2(PredFormatFunction2,
785 EXPECT_NONFATAL_FAILURE({
796 EXPECT_NONFATAL_FAILURE({
807 ASSERT_PRED_FORMAT2(PredFormatFunction2,
816 ASSERT_PRED_FORMAT2(PredFormatFunction2,
843 expected_to_finish_ =
false;
844 EXPECT_FATAL_FAILURE({
845 ASSERT_PRED_FORMAT2(PredFormatFunction2,
855 expected_to_finish_ =
false;
856 EXPECT_FATAL_FAILURE({
857 ASSERT_PRED_FORMAT2(PredFormatFunction2,
867 expected_to_finish_ =
false;
868 EXPECT_FATAL_FAILURE({
879 expected_to_finish_ =
false;
880 EXPECT_FATAL_FAILURE({
890template <
typename T1,
typename T2,
typename T3>
891bool PredFunction3(T1 v1, T2 v2, T3 v3) {
892 return v1 + v2 + v3 > 0;
897bool PredFunction3Int(
int v1,
int v2,
int v3) {
898 return v1 + v2 + v3 > 0;
901 return v1 + v2 + v3 > 0;
906 template <
typename T1,
typename T2,
typename T3>
907 bool operator()(
const T1& v1,
910 return v1 + v2 + v3 > 0;
915template <
typename T1,
typename T2,
typename T3>
916testing::AssertionResult PredFormatFunction3(
const char* e1,
922 if (PredFunction3(v1, v2, v3))
923 return testing::AssertionSuccess();
925 return testing::AssertionFailure()
926 << e1 <<
" + " << e2 <<
" + " << e3
927 <<
" is expected to be positive, but evaluates to "
928 << v1 + v2 + v3 <<
".";
933 template <
typename T1,
typename T2,
typename T3>
934 testing::AssertionResult operator()(
const char* e1,
939 const T3& v3)
const {
940 return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
948 void SetUp()
override {
949 expected_to_finish_ =
true;
954 void TearDown()
override {
958 "The predicate assertion didn't evaluate argument 2 "
961 "The predicate assertion didn't evaluate argument 3 "
964 "The predicate assertion didn't evaluate argument 4 "
968 if (expected_to_finish_ && !finished_) {
969 FAIL() <<
"The predicate assertion unexpactedly aborted the test.";
970 }
else if (!expected_to_finish_ && finished_) {
971 FAIL() <<
"The failed predicate assertion didn't abort the test "
977 static bool expected_to_finish_;
980 static bool finished_;
987bool Predicate3Test::expected_to_finish_;
988bool Predicate3Test::finished_;
989int Predicate3Test::n1_;
990int Predicate3Test::n2_;
991int Predicate3Test::n3_;
1001 EXPECT_PRED3(PredFunction3Int,
1011 EXPECT_PRED3(PredFunction3Bool,
1041 EXPECT_NONFATAL_FAILURE({
1042 EXPECT_PRED3(PredFunction3Int,
1053 EXPECT_NONFATAL_FAILURE({
1054 EXPECT_PRED3(PredFunction3Bool,
1065 EXPECT_NONFATAL_FAILURE({
1077 EXPECT_NONFATAL_FAILURE({
1089 ASSERT_PRED3(PredFunction3Int,
1099 ASSERT_PRED3(PredFunction3Bool,
1129 expected_to_finish_ =
false;
1130 EXPECT_FATAL_FAILURE({
1131 ASSERT_PRED3(PredFunction3Int,
1142 expected_to_finish_ =
false;
1143 EXPECT_FATAL_FAILURE({
1144 ASSERT_PRED3(PredFunction3Bool,
1155 expected_to_finish_ =
false;
1156 EXPECT_FATAL_FAILURE({
1168 expected_to_finish_ =
false;
1169 EXPECT_FATAL_FAILURE({
1181 EXPECT_PRED_FORMAT3(PredFormatFunction3,
1191 EXPECT_PRED_FORMAT3(PredFormatFunction3,
1221 EXPECT_NONFATAL_FAILURE({
1222 EXPECT_PRED_FORMAT3(PredFormatFunction3,
1233 EXPECT_NONFATAL_FAILURE({
1234 EXPECT_PRED_FORMAT3(PredFormatFunction3,
1245 EXPECT_NONFATAL_FAILURE({
1257 EXPECT_NONFATAL_FAILURE({
1269 ASSERT_PRED_FORMAT3(PredFormatFunction3,
1279 ASSERT_PRED_FORMAT3(PredFormatFunction3,
1309 expected_to_finish_ =
false;
1310 EXPECT_FATAL_FAILURE({
1311 ASSERT_PRED_FORMAT3(PredFormatFunction3,
1322 expected_to_finish_ =
false;
1323 EXPECT_FATAL_FAILURE({
1324 ASSERT_PRED_FORMAT3(PredFormatFunction3,
1335 expected_to_finish_ =
false;
1336 EXPECT_FATAL_FAILURE({
1348 expected_to_finish_ =
false;
1349 EXPECT_FATAL_FAILURE({
1360template <
typename T1,
typename T2,
typename T3,
typename T4>
1361bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
1362 return v1 + v2 + v3 + v4 > 0;
1367bool PredFunction4Int(
int v1,
int v2,
int v3,
int v4) {
1368 return v1 + v2 + v3 + v4 > 0;
1371 return v1 + v2 + v3 + v4 > 0;
1376 template <
typename T1,
typename T2,
typename T3,
typename T4>
1377 bool operator()(
const T1& v1,
1381 return v1 + v2 + v3 + v4 > 0;
1386template <
typename T1,
typename T2,
typename T3,
typename T4>
1387testing::AssertionResult PredFormatFunction4(
const char* e1,
1395 if (PredFunction4(v1, v2, v3, v4))
1396 return testing::AssertionSuccess();
1398 return testing::AssertionFailure()
1399 << e1 <<
" + " << e2 <<
" + " << e3 <<
" + " << e4
1400 <<
" is expected to be positive, but evaluates to "
1401 << v1 + v2 + v3 + v4 <<
".";
1406 template <
typename T1,
typename T2,
typename T3,
typename T4>
1407 testing::AssertionResult operator()(
const char* e1,
1414 const T4& v4)
const {
1415 return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
1423 void SetUp()
override {
1424 expected_to_finish_ =
true;
1426 n1_ = n2_ = n3_ = n4_ = 0;
1429 void TearDown()
override {
1432 EXPECT_EQ(1, n1_) <<
1433 "The predicate assertion didn't evaluate argument 2 "
1435 EXPECT_EQ(1, n2_) <<
1436 "The predicate assertion didn't evaluate argument 3 "
1438 EXPECT_EQ(1, n3_) <<
1439 "The predicate assertion didn't evaluate argument 4 "
1441 EXPECT_EQ(1, n4_) <<
1442 "The predicate assertion didn't evaluate argument 5 "
1446 if (expected_to_finish_ && !finished_) {
1447 FAIL() <<
"The predicate assertion unexpactedly aborted the test.";
1448 }
else if (!expected_to_finish_ && finished_) {
1449 FAIL() <<
"The failed predicate assertion didn't abort the test "
1455 static bool expected_to_finish_;
1458 static bool finished_;
1466bool Predicate4Test::expected_to_finish_;
1467bool Predicate4Test::finished_;
1468int Predicate4Test::n1_;
1469int Predicate4Test::n2_;
1470int Predicate4Test::n3_;
1471int Predicate4Test::n4_;
1481 EXPECT_PRED4(PredFunction4Int,
1492 EXPECT_PRED4(PredFunction4Bool,
1525 EXPECT_NONFATAL_FAILURE({
1526 EXPECT_PRED4(PredFunction4Int,
1538 EXPECT_NONFATAL_FAILURE({
1539 EXPECT_PRED4(PredFunction4Bool,
1551 EXPECT_NONFATAL_FAILURE({
1564 EXPECT_NONFATAL_FAILURE({
1577 ASSERT_PRED4(PredFunction4Int,
1588 ASSERT_PRED4(PredFunction4Bool,
1621 expected_to_finish_ =
false;
1622 EXPECT_FATAL_FAILURE({
1623 ASSERT_PRED4(PredFunction4Int,
1635 expected_to_finish_ =
false;
1636 EXPECT_FATAL_FAILURE({
1637 ASSERT_PRED4(PredFunction4Bool,
1649 expected_to_finish_ =
false;
1650 EXPECT_FATAL_FAILURE({
1663 expected_to_finish_ =
false;
1664 EXPECT_FATAL_FAILURE({
1677 EXPECT_PRED_FORMAT4(PredFormatFunction4,
1688 EXPECT_PRED_FORMAT4(PredFormatFunction4,
1721 EXPECT_NONFATAL_FAILURE({
1722 EXPECT_PRED_FORMAT4(PredFormatFunction4,
1734 EXPECT_NONFATAL_FAILURE({
1735 EXPECT_PRED_FORMAT4(PredFormatFunction4,
1747 EXPECT_NONFATAL_FAILURE({
1760 EXPECT_NONFATAL_FAILURE({
1773 ASSERT_PRED_FORMAT4(PredFormatFunction4,
1784 ASSERT_PRED_FORMAT4(PredFormatFunction4,
1817 expected_to_finish_ =
false;
1818 EXPECT_FATAL_FAILURE({
1819 ASSERT_PRED_FORMAT4(PredFormatFunction4,
1831 expected_to_finish_ =
false;
1832 EXPECT_FATAL_FAILURE({
1833 ASSERT_PRED_FORMAT4(PredFormatFunction4,
1845 expected_to_finish_ =
false;
1846 EXPECT_FATAL_FAILURE({
1859 expected_to_finish_ =
false;
1860 EXPECT_FATAL_FAILURE({
1872template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1873bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
1874 return v1 + v2 + v3 + v4 + v5 > 0;
1879bool PredFunction5Int(
int v1,
int v2,
int v3,
int v4,
int v5) {
1880 return v1 + v2 + v3 + v4 + v5 > 0;
1883 return v1 + v2 + v3 + v4 + v5 > 0;
1888 template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1889 bool operator()(
const T1& v1,
1894 return v1 + v2 + v3 + v4 + v5 > 0;
1899template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1900testing::AssertionResult PredFormatFunction5(
const char* e1,
1910 if (PredFunction5(v1, v2, v3, v4, v5))
1911 return testing::AssertionSuccess();
1913 return testing::AssertionFailure()
1914 << e1 <<
" + " << e2 <<
" + " << e3 <<
" + " << e4 <<
" + " << e5
1915 <<
" is expected to be positive, but evaluates to "
1916 << v1 + v2 + v3 + v4 + v5 <<
".";
1921 template <
typename T1,
typename T2,
typename T3,
typename T4,
typename T5>
1922 testing::AssertionResult operator()(
const char* e1,
1931 const T5& v5)
const {
1932 return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
1940 void SetUp()
override {
1941 expected_to_finish_ =
true;
1943 n1_ = n2_ = n3_ = n4_ = n5_ = 0;
1946 void TearDown()
override {
1949 EXPECT_EQ(1, n1_) <<
1950 "The predicate assertion didn't evaluate argument 2 "
1952 EXPECT_EQ(1, n2_) <<
1953 "The predicate assertion didn't evaluate argument 3 "
1955 EXPECT_EQ(1, n3_) <<
1956 "The predicate assertion didn't evaluate argument 4 "
1958 EXPECT_EQ(1, n4_) <<
1959 "The predicate assertion didn't evaluate argument 5 "
1961 EXPECT_EQ(1, n5_) <<
1962 "The predicate assertion didn't evaluate argument 6 "
1966 if (expected_to_finish_ && !finished_) {
1967 FAIL() <<
"The predicate assertion unexpactedly aborted the test.";
1968 }
else if (!expected_to_finish_ && finished_) {
1969 FAIL() <<
"The failed predicate assertion didn't abort the test "
1975 static bool expected_to_finish_;
1978 static bool finished_;
1987bool Predicate5Test::expected_to_finish_;
1988bool Predicate5Test::finished_;
1989int Predicate5Test::n1_;
1990int Predicate5Test::n2_;
1991int Predicate5Test::n3_;
1992int Predicate5Test::n4_;
1993int Predicate5Test::n5_;
2003 EXPECT_PRED5(PredFunction5Int,
2015 EXPECT_PRED5(PredFunction5Bool,
2051 EXPECT_NONFATAL_FAILURE({
2052 EXPECT_PRED5(PredFunction5Int,
2065 EXPECT_NONFATAL_FAILURE({
2066 EXPECT_PRED5(PredFunction5Bool,
2079 EXPECT_NONFATAL_FAILURE({
2093 EXPECT_NONFATAL_FAILURE({
2107 ASSERT_PRED5(PredFunction5Int,
2119 ASSERT_PRED5(PredFunction5Bool,
2155 expected_to_finish_ =
false;
2156 EXPECT_FATAL_FAILURE({
2157 ASSERT_PRED5(PredFunction5Int,
2170 expected_to_finish_ =
false;
2171 EXPECT_FATAL_FAILURE({
2172 ASSERT_PRED5(PredFunction5Bool,
2185 expected_to_finish_ =
false;
2186 EXPECT_FATAL_FAILURE({
2200 expected_to_finish_ =
false;
2201 EXPECT_FATAL_FAILURE({
2215 EXPECT_PRED_FORMAT5(PredFormatFunction5,
2227 EXPECT_PRED_FORMAT5(PredFormatFunction5,
2263 EXPECT_NONFATAL_FAILURE({
2264 EXPECT_PRED_FORMAT5(PredFormatFunction5,
2277 EXPECT_NONFATAL_FAILURE({
2278 EXPECT_PRED_FORMAT5(PredFormatFunction5,
2291 EXPECT_NONFATAL_FAILURE({
2305 EXPECT_NONFATAL_FAILURE({
2319 ASSERT_PRED_FORMAT5(PredFormatFunction5,
2331 ASSERT_PRED_FORMAT5(PredFormatFunction5,
2367 expected_to_finish_ =
false;
2368 EXPECT_FATAL_FAILURE({
2369 ASSERT_PRED_FORMAT5(PredFormatFunction5,
2382 expected_to_finish_ =
false;
2383 EXPECT_FATAL_FAILURE({
2384 ASSERT_PRED_FORMAT5(PredFormatFunction5,
2397 expected_to_finish_ =
false;
2398 EXPECT_FATAL_FAILURE({
2412 expected_to_finish_ =
false;
2413 EXPECT_FATAL_FAILURE({
Definition gtest_pred_impl_unittest.cc:122
Definition gtest_pred_impl_unittest.cc:513
Definition gtest_pred_impl_unittest.cc:946
Definition gtest_pred_impl_unittest.cc:1421
Definition gtest_pred_impl_unittest.cc:1938
Definition gtest_pred_impl_unittest.cc:56
Definition gtest_pred_impl_unittest.cc:91
Definition gtest_pred_impl_unittest.cc:477
Definition gtest_pred_impl_unittest.cc:905
Definition gtest_pred_impl_unittest.cc:1375
Definition gtest_pred_impl_unittest.cc:1887