"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/gtest_pred_impl_unittest.cc" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

gtest_pred_impl_unittest.cc  (googletest-release-1.11.0)	:	gtest_pred_impl_unittest.cc  (googletest-release-1.12.0)
skipping to change at line 30		skipping to change at line 30
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR		// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT		// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,		// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT		// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,		// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE		// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// This file is AUTOMATICALLY GENERATED on 11/05/2019 by command
// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND!
// Regression test for gtest_pred_impl.h		// Regression test for gtest_pred_impl.h
//		//
// This file is generated by a script and quite long. If you intend to		// This file is generated by a script and quite long. If you intend to
// learn how Google Test works by reading its unit tests, read		// learn how Google Test works by reading its unit tests, read
// gtest_unittest.cc instead.		// gtest_unittest.cc instead.
//		//
// This is intended as a regression test for the Google Test predicate		// This is intended as a regression test for the Google Test predicate
// assertions. We compile it as part of the gtest_unittest target		// assertions. We compile it as part of the gtest_unittest target
// only to keep the implementation tidy and compact, as it is quite		// only to keep the implementation tidy and compact, as it is quite
// involved to set up the stage for testing Google Test using Google		// involved to set up the stage for testing Google Test using Google
// Test itself.		// Test itself.
//		//
// Currently, gtest_unittest takes ~11 seconds to run in the testing		// Currently, gtest_unittest takes ~11 seconds to run in the testing
// daemon. In the future, if it grows too large and needs much more		// daemon. In the future, if it grows too large and needs much more
// time to finish, we should consider separating this file into a		// time to finish, we should consider separating this file into a
// stand-alone regression test.		// stand-alone regression test.
#include <iostream>		#include <iostream>
#include "gtest/gtest.h"
#include "gtest/gtest-spi.h"		#include "gtest/gtest-spi.h"
		#include "gtest/gtest.h"
// A user-defined data type.		// A user-defined data type.
struct Bool {		struct Bool {
explicit Bool(int val) : value(val != 0) {}		explicit Bool(int val) : value(val != 0) {}
bool operator>(int n) const { return value > Bool(n).value; }		bool operator>(int n) const { return value > Bool(n).value; }
Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }		Bool operator+(const Bool& rhs) const { return Bool(value + rhs.value); }
bool operator==(const Bool& rhs) const { return value == rhs.value; }		bool operator==(const Bool& rhs) const { return value == rhs.value; }
skipping to change at line 83		skipping to change at line 80
// Sample functions/functors for testing unary predicate assertions.		// Sample functions/functors for testing unary predicate assertions.
// A unary predicate function.		// A unary predicate function.
template <typename T1>		template <typename T1>
bool PredFunction1(T1 v1) {		bool PredFunction1(T1 v1) {
return v1 > 0;		return v1 > 0;
}		}
// The following two functions are needed because a compiler doesn't have		// The following two functions are needed because a compiler doesn't have
// a context yet to know which template function must be instantiated.		// a context yet to know which template function must be instantiated.
bool PredFunction1Int(int v1) {		bool PredFunction1Int(int v1) { return v1 > 0; }
return v1 > 0;		bool PredFunction1Bool(Bool v1) { return v1 > 0; }
}
bool PredFunction1Bool(Bool v1) {
return v1 > 0;
}
// A unary predicate functor.		// A unary predicate functor.
struct PredFunctor1 {		struct PredFunctor1 {
template <typename T1>		template <typename T1>
bool operator()(const T1& v1) {		bool operator()(const T1& v1) {
return v1 > 0;		return v1 > 0;
}		}
};		};
// A unary predicate-formatter function.		// A unary predicate-formatter function.
template <typename T1>		template <typename T1>
testing::AssertionResult PredFormatFunction1(const char* e1,		testing::AssertionResult PredFormatFunction1(const char* e1, const T1& v1) {
const T1& v1) {		if (PredFunction1(v1)) return testing::AssertionSuccess();
if (PredFunction1(v1))
return testing::AssertionSuccess();
return testing::AssertionFailure()		return testing::AssertionFailure()
<< e1		<< e1 << " is expected to be positive, but evaluates to " << v1 << ".";
<< " is expected to be positive, but evaluates to "
<< v1 << ".";
}		}
// A unary predicate-formatter functor.		// A unary predicate-formatter functor.
struct PredFormatFunctor1 {		struct PredFormatFunctor1 {
template <typename T1>		template <typename T1>
testing::AssertionResult operator()(const char* e1,		testing::AssertionResult operator()(const char* e1, const T1& v1) const {
const T1& v1) const {
return PredFormatFunction1(e1, v1);		return PredFormatFunction1(e1, v1);
}		}
};		};
// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.		// Tests for {EXPECT|ASSERT}_PRED_FORMAT1.
class Predicate1Test : public testing::Test {		class Predicate1Test : public testing::Test {
protected:		protected:
void SetUp() override {		void SetUp() override {
expected_to_finish_ = true;		expected_to_finish_ = true;
finished_ = false;		finished_ = false;
n1_ = 0;		n1_ = 0;
}		}
void TearDown() override {		void TearDown() override {
// Verifies that each of the predicate's arguments was evaluated		// Verifies that each of the predicate's arguments was evaluated
// exactly once.		// exactly once.
EXPECT_EQ(1, n1_) <<		EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
"The predicate assertion didn't evaluate argument 2 "		"exactly once.";
"exactly once.";
// Verifies that the control flow in the test function is expected.		// Verifies that the control flow in the test function is expected.
if (expected_to_finish_ && !finished_) {		if (expected_to_finish_ && !finished_) {
FAIL() << "The predicate assertion unexpactedly aborted the test.";		FAIL() << "The predicate assertion unexpectedly aborted the test.";
} else if (!expected_to_finish_ && finished_) {		} else if (!expected_to_finish_ && finished_) {
FAIL() << "The failed predicate assertion didn't abort the test "		FAIL() << "The failed predicate assertion didn't abort the test "
"as expected.";		"as expected.";
}		}
}		}
// true if and only if the test function is expected to run to finish.		// true if and only if the test function is expected to run to finish.
static bool expected_to_finish_;		static bool expected_to_finish_;
// true if and only if the test function did run to finish.		// true if and only if the test function did run to finish.
skipping to change at line 167		skipping to change at line 154
int Predicate1Test::n1_;		int Predicate1Test::n1_;
typedef Predicate1Test EXPECT_PRED_FORMAT1Test;		typedef Predicate1Test EXPECT_PRED_FORMAT1Test;
typedef Predicate1Test ASSERT_PRED_FORMAT1Test;		typedef Predicate1Test ASSERT_PRED_FORMAT1Test;
typedef Predicate1Test EXPECT_PRED1Test;		typedef Predicate1Test EXPECT_PRED1Test;
typedef Predicate1Test ASSERT_PRED1Test;		typedef Predicate1Test ASSERT_PRED1Test;
// Tests a successful EXPECT_PRED1 where the		// Tests a successful EXPECT_PRED1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED1(PredFunction1Int,		EXPECT_PRED1(PredFunction1Int, ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED1 where the		// Tests a successful EXPECT_PRED1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED1(PredFunction1Bool,		EXPECT_PRED1(PredFunction1Bool, Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED1 where the		// Tests a successful EXPECT_PRED1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED1(PredFunctor1(),		EXPECT_PRED1(PredFunctor1(), ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED1 where the		// Tests a successful EXPECT_PRED1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED1(PredFunctor1(),		EXPECT_PRED1(PredFunctor1(), Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED1 where the		// Tests a failed EXPECT_PRED1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED1Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED1(PredFunction1Int,		{ // NOLINT
n1_++);		EXPECT_PRED1(PredFunction1Int, n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED1 where the		// Tests a failed EXPECT_PRED1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED1Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED1(PredFunction1Bool,		{ // NOLINT
Bool(n1_++));		EXPECT_PRED1(PredFunction1Bool, Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED1 where the		// Tests a failed EXPECT_PRED1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED1Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED1(PredFunctor1(),		{ // NOLINT
n1_++);		EXPECT_PRED1(PredFunctor1(), n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED1 where the		// Tests a failed EXPECT_PRED1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED1Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED1(PredFunctor1(),		{ // NOLINT
Bool(n1_++));		EXPECT_PRED1(PredFunctor1(), Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a successful ASSERT_PRED1 where the		// Tests a successful ASSERT_PRED1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED1(PredFunction1Int,		ASSERT_PRED1(PredFunction1Int, ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED1 where the		// Tests a successful ASSERT_PRED1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED1(PredFunction1Bool,		ASSERT_PRED1(PredFunction1Bool, Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED1 where the		// Tests a successful ASSERT_PRED1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED1(PredFunctor1(),		ASSERT_PRED1(PredFunctor1(), ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED1 where the		// Tests a successful ASSERT_PRED1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED1(PredFunctor1(),		ASSERT_PRED1(PredFunctor1(), Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED1 where the		// Tests a failed ASSERT_PRED1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED1Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED1(PredFunction1Int,		{ // NOLINT
n1_++);		ASSERT_PRED1(PredFunction1Int, n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED1 where the		// Tests a failed ASSERT_PRED1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED1Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED1(PredFunction1Bool,		{ // NOLINT
Bool(n1_++));		ASSERT_PRED1(PredFunction1Bool, Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED1 where the		// Tests a failed ASSERT_PRED1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED1Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED1(PredFunctor1(),		{ // NOLINT
n1_++);		ASSERT_PRED1(PredFunctor1(), n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED1 where the		// Tests a failed ASSERT_PRED1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED1Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED1(PredFunctor1(),		{ // NOLINT
Bool(n1_++));		ASSERT_PRED1(PredFunctor1(), Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a successful EXPECT_PRED_FORMAT1 where the		// Tests a successful EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT1(PredFormatFunction1,		EXPECT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT1 where the		// Tests a successful EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED_FORMAT1(PredFormatFunction1,		EXPECT_PRED_FORMAT1(PredFormatFunction1, Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT1 where the		// Tests a successful EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT1(PredFormatFunctor1(),		EXPECT_PRED_FORMAT1(PredFormatFunctor1(), ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT1 where the		// Tests a successful EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED_FORMAT1(PredFormatFunctor1(),		EXPECT_PRED_FORMAT1(PredFormatFunctor1(), Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED_FORMAT1 where the		// Tests a failed EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT1(PredFormatFunction1,		{ // NOLINT
n1_++);		EXPECT_PRED_FORMAT1(PredFormatFunction1, n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT1 where the		// Tests a failed EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT1(PredFormatFunction1,		{ // NOLINT
Bool(n1_++));		EXPECT_PRED_FORMAT1(PredFormatFunction1, Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT1 where the		// Tests a failed EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT1(PredFormatFunctor1(),		{ // NOLINT
n1_++);		EXPECT_PRED_FORMAT1(PredFormatFunctor1(), n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT1 where the		// Tests a failed EXPECT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT1(PredFormatFunctor1(),		{ // NOLINT
Bool(n1_++));		EXPECT_PRED_FORMAT1(PredFormatFunctor1(), Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a successful ASSERT_PRED_FORMAT1 where the		// Tests a successful ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT1(PredFormatFunction1,		ASSERT_PRED_FORMAT1(PredFormatFunction1, ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT1 where the		// Tests a successful ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED_FORMAT1(PredFormatFunction1,		ASSERT_PRED_FORMAT1(PredFormatFunction1, Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT1 where the		// Tests a successful ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT1(PredFormatFunctor1(),		ASSERT_PRED_FORMAT1(PredFormatFunctor1(), ++n1_);
++n1_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT1 where the		// Tests a successful ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED_FORMAT1(PredFormatFunctor1(),		ASSERT_PRED_FORMAT1(PredFormatFunctor1(), Bool(++n1_));
Bool(++n1_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED_FORMAT1 where the		// Tests a failed ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT1(PredFormatFunction1,		{ // NOLINT
n1_++);		ASSERT_PRED_FORMAT1(PredFormatFunction1, n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT1 where the		// Tests a failed ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT1(PredFormatFunction1,		{ // NOLINT
Bool(n1_++));		ASSERT_PRED_FORMAT1(PredFormatFunction1, Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT1 where the		// Tests a failed ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT1(PredFormatFunctor1(),		{ // NOLINT
n1_++);		ASSERT_PRED_FORMAT1(PredFormatFunctor1(), n1_++);
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT1 where the		// Tests a failed ASSERT_PRED_FORMAT1 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT1Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT1(PredFormatFunctor1(),		{ // NOLINT
Bool(n1_++));		ASSERT_PRED_FORMAT1(PredFormatFunctor1(), Bool(n1_++));
finished_ = true;		finished_ = true;
}, "");		},
		"");
}		}
// Sample functions/functors for testing binary predicate assertions.		// Sample functions/functors for testing binary predicate assertions.
// A binary predicate function.		// A binary predicate function.
template <typename T1, typename T2>		template <typename T1, typename T2>
bool PredFunction2(T1 v1, T2 v2) {		bool PredFunction2(T1 v1, T2 v2) {
return v1 + v2 > 0;		return v1 + v2 > 0;
}		}
// The following two functions are needed because a compiler doesn't have		// The following two functions are needed because a compiler doesn't have
// a context yet to know which template function must be instantiated.		// a context yet to know which template function must be instantiated.
bool PredFunction2Int(int v1, int v2) {		bool PredFunction2Int(int v1, int v2) { return v1 + v2 > 0; }
return v1 + v2 > 0;		bool PredFunction2Bool(Bool v1, Bool v2) { return v1 + v2 > 0; }
}
bool PredFunction2Bool(Bool v1, Bool v2) {
return v1 + v2 > 0;
}
// A binary predicate functor.		// A binary predicate functor.
struct PredFunctor2 {		struct PredFunctor2 {
template <typename T1, typename T2>		template <typename T1, typename T2>
bool operator()(const T1& v1,		bool operator()(const T1& v1, const T2& v2) {
const T2& v2) {
return v1 + v2 > 0;		return v1 + v2 > 0;
}		}
};		};
// A binary predicate-formatter function.		// A binary predicate-formatter function.
template <typename T1, typename T2>		template <typename T1, typename T2>
testing::AssertionResult PredFormatFunction2(const char* e1,		testing::AssertionResult PredFormatFunction2(const char* e1, const char* e2,
const char* e2,		const T1& v1, const T2& v2) {
const T1& v1,		if (PredFunction2(v1, v2)) return testing::AssertionSuccess();
const T2& v2) {
if (PredFunction2(v1, v2))
return testing::AssertionSuccess();
return testing::AssertionFailure()		return testing::AssertionFailure()
<< e1 << " + " << e2		<< e1 << " + " << e2
<< " is expected to be positive, but evaluates to "		<< " is expected to be positive, but evaluates to " << v1 + v2 << ".";
<< v1 + v2 << ".";
}		}
// A binary predicate-formatter functor.		// A binary predicate-formatter functor.
struct PredFormatFunctor2 {		struct PredFormatFunctor2 {
template <typename T1, typename T2>		template <typename T1, typename T2>
testing::AssertionResult operator()(const char* e1,		testing::AssertionResult operator()(const char* e1, const char* e2,
const char* e2,		const T1& v1, const T2& v2) const {
const T1& v1,
const T2& v2) const {
return PredFormatFunction2(e1, e2, v1, v2);		return PredFormatFunction2(e1, e2, v1, v2);
}		}
};		};
// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.		// Tests for {EXPECT|ASSERT}_PRED_FORMAT2.
class Predicate2Test : public testing::Test {		class Predicate2Test : public testing::Test {
protected:		protected:
void SetUp() override {		void SetUp() override {
expected_to_finish_ = true;		expected_to_finish_ = true;
finished_ = false;		finished_ = false;
n1_ = n2_ = 0;		n1_ = n2_ = 0;
}		}
void TearDown() override {		void TearDown() override {
// Verifies that each of the predicate's arguments was evaluated		// Verifies that each of the predicate's arguments was evaluated
// exactly once.		// exactly once.
EXPECT_EQ(1, n1_) <<		EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
"The predicate assertion didn't evaluate argument 2 "		"exactly once.";
"exactly once.";		EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
EXPECT_EQ(1, n2_) <<		"exactly once.";
"The predicate assertion didn't evaluate argument 3 "
"exactly once.";
// Verifies that the control flow in the test function is expected.		// Verifies that the control flow in the test function is expected.
if (expected_to_finish_ && !finished_) {		if (expected_to_finish_ && !finished_) {
FAIL() << "The predicate assertion unexpactedly aborted the test.";		FAIL() << "The predicate assertion unexpectedly aborted the test.";
} else if (!expected_to_finish_ && finished_) {		} else if (!expected_to_finish_ && finished_) {
FAIL() << "The failed predicate assertion didn't abort the test "		FAIL() << "The failed predicate assertion didn't abort the test "
"as expected.";		"as expected.";
}		}
}		}
// true if and only if the test function is expected to run to finish.		// true if and only if the test function is expected to run to finish.
static bool expected_to_finish_;		static bool expected_to_finish_;
// true if and only if the test function did run to finish.		// true if and only if the test function did run to finish.
skipping to change at line 563		skipping to change at line 537
int Predicate2Test::n2_;		int Predicate2Test::n2_;
typedef Predicate2Test EXPECT_PRED_FORMAT2Test;		typedef Predicate2Test EXPECT_PRED_FORMAT2Test;
typedef Predicate2Test ASSERT_PRED_FORMAT2Test;		typedef Predicate2Test ASSERT_PRED_FORMAT2Test;
typedef Predicate2Test EXPECT_PRED2Test;		typedef Predicate2Test EXPECT_PRED2Test;
typedef Predicate2Test ASSERT_PRED2Test;		typedef Predicate2Test ASSERT_PRED2Test;
// Tests a successful EXPECT_PRED2 where the		// Tests a successful EXPECT_PRED2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED2(PredFunction2Int,		EXPECT_PRED2(PredFunction2Int, ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED2 where the		// Tests a successful EXPECT_PRED2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED2(PredFunction2Bool,		EXPECT_PRED2(PredFunction2Bool, Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED2 where the		// Tests a successful EXPECT_PRED2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED2(PredFunctor2(),		EXPECT_PRED2(PredFunctor2(), ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED2 where the		// Tests a successful EXPECT_PRED2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED2(PredFunctor2(),		EXPECT_PRED2(PredFunctor2(), Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED2 where the		// Tests a failed EXPECT_PRED2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED2Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED2(PredFunction2Int,		{ // NOLINT
n1_++,		EXPECT_PRED2(PredFunction2Int, n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED2 where the		// Tests a failed EXPECT_PRED2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED2Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED2(PredFunction2Bool,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED2(PredFunction2Bool, Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED2 where the		// Tests a failed EXPECT_PRED2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED2Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED2(PredFunctor2(),		{ // NOLINT
n1_++,		EXPECT_PRED2(PredFunctor2(), n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED2 where the		// Tests a failed EXPECT_PRED2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED2Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED2(PredFunctor2(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED2(PredFunctor2(), Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a successful ASSERT_PRED2 where the		// Tests a successful ASSERT_PRED2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED2(PredFunction2Int,		ASSERT_PRED2(PredFunction2Int, ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED2 where the		// Tests a successful ASSERT_PRED2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED2(PredFunction2Bool,		ASSERT_PRED2(PredFunction2Bool, Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED2 where the		// Tests a successful ASSERT_PRED2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED2(PredFunctor2(),		ASSERT_PRED2(PredFunctor2(), ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED2 where the		// Tests a successful ASSERT_PRED2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED2(PredFunctor2(),		ASSERT_PRED2(PredFunctor2(), Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED2 where the		// Tests a failed ASSERT_PRED2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED2Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED2(PredFunction2Int,		{ // NOLINT
n1_++,		ASSERT_PRED2(PredFunction2Int, n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED2 where the		// Tests a failed ASSERT_PRED2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED2Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED2(PredFunction2Bool,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED2(PredFunction2Bool, Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED2 where the		// Tests a failed ASSERT_PRED2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED2Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED2(PredFunctor2(),		{ // NOLINT
n1_++,		ASSERT_PRED2(PredFunctor2(), n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED2 where the		// Tests a failed ASSERT_PRED2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED2Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED2(PredFunctor2(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED2(PredFunctor2(), Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a successful EXPECT_PRED_FORMAT2 where the		// Tests a successful EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT2(PredFormatFunction2,		EXPECT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT2 where the		// Tests a successful EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED_FORMAT2(PredFormatFunction2,		EXPECT_PRED_FORMAT2(PredFormatFunction2, Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT2 where the		// Tests a successful EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT2(PredFormatFunctor2(),		EXPECT_PRED_FORMAT2(PredFormatFunctor2(), ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT2 where the		// Tests a successful EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED_FORMAT2(PredFormatFunctor2(),		EXPECT_PRED_FORMAT2(PredFormatFunctor2(), Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED_FORMAT2 where the		// Tests a failed EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT2(PredFormatFunction2,		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT2 where the		// Tests a failed EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT2(PredFormatFunction2,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT2(PredFormatFunction2, Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT2 where the		// Tests a failed EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT2(PredFormatFunctor2(),		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT2(PredFormatFunctor2(), n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT2 where the		// Tests a failed EXPECT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT2(PredFormatFunctor2(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT2(PredFormatFunctor2(), Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a successful ASSERT_PRED_FORMAT2 where the		// Tests a successful ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT2(PredFormatFunction2,		ASSERT_PRED_FORMAT2(PredFormatFunction2, ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT2 where the		// Tests a successful ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED_FORMAT2(PredFormatFunction2,		ASSERT_PRED_FORMAT2(PredFormatFunction2, Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT2 where the		// Tests a successful ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT2(PredFormatFunctor2(),		ASSERT_PRED_FORMAT2(PredFormatFunctor2(), ++n1_, ++n2_);
++n1_,
++n2_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT2 where the		// Tests a successful ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED_FORMAT2(PredFormatFunctor2(),		ASSERT_PRED_FORMAT2(PredFormatFunctor2(), Bool(++n1_), Bool(++n2_));
Bool(++n1_),
Bool(++n2_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED_FORMAT2 where the		// Tests a failed ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT2(PredFormatFunction2,		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT2(PredFormatFunction2, n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT2 where the		// Tests a failed ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT2(PredFormatFunction2,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT2(PredFormatFunction2, Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT2 where the		// Tests a failed ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT2(PredFormatFunctor2(),		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT2(PredFormatFunctor2(), n1_++, n2_++);
n2_++);		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT2 where the		// Tests a failed ASSERT_PRED_FORMAT2 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT2Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT2(PredFormatFunctor2(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT2(PredFormatFunctor2(), Bool(n1_++), Bool(n2_++));
Bool(n2_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Sample functions/functors for testing ternary predicate assertions.		// Sample functions/functors for testing ternary predicate assertions.
// A ternary predicate function.		// A ternary predicate function.
template <typename T1, typename T2, typename T3>		template <typename T1, typename T2, typename T3>
bool PredFunction3(T1 v1, T2 v2, T3 v3) {		bool PredFunction3(T1 v1, T2 v2, T3 v3) {
return v1 + v2 + v3 > 0;		return v1 + v2 + v3 > 0;
}		}
// The following two functions are needed because a compiler doesn't have		// The following two functions are needed because a compiler doesn't have
// a context yet to know which template function must be instantiated.		// a context yet to know which template function must be instantiated.
bool PredFunction3Int(int v1, int v2, int v3) {		bool PredFunction3Int(int v1, int v2, int v3) { return v1 + v2 + v3 > 0; }
return v1 + v2 + v3 > 0;		bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) { return v1 + v2 + v3 > 0; }
}
bool PredFunction3Bool(Bool v1, Bool v2, Bool v3) {
return v1 + v2 + v3 > 0;
}
// A ternary predicate functor.		// A ternary predicate functor.
struct PredFunctor3 {		struct PredFunctor3 {
template <typename T1, typename T2, typename T3>		template <typename T1, typename T2, typename T3>
bool operator()(const T1& v1,		bool operator()(const T1& v1, const T2& v2, const T3& v3) {
const T2& v2,
const T3& v3) {
return v1 + v2 + v3 > 0;		return v1 + v2 + v3 > 0;
}		}
};		};
// A ternary predicate-formatter function.		// A ternary predicate-formatter function.
template <typename T1, typename T2, typename T3>		template <typename T1, typename T2, typename T3>
testing::AssertionResult PredFormatFunction3(const char* e1,		testing::AssertionResult PredFormatFunction3(const char* e1, const char* e2,
const char* e2,		const char* e3, const T1& v1,
const char* e3,		const T2& v2, const T3& v3) {
const T1& v1,		if (PredFunction3(v1, v2, v3)) return testing::AssertionSuccess();
const T2& v2,
const T3& v3) {
if (PredFunction3(v1, v2, v3))
return testing::AssertionSuccess();
return testing::AssertionFailure()		return testing::AssertionFailure()
<< e1 << " + " << e2 << " + " << e3		<< e1 << " + " << e2 << " + " << e3
<< " is expected to be positive, but evaluates to "		<< " is expected to be positive, but evaluates to " << v1 + v2 + v3
<< v1 + v2 + v3 << ".";		<< ".";
}		}
// A ternary predicate-formatter functor.		// A ternary predicate-formatter functor.
struct PredFormatFunctor3 {		struct PredFormatFunctor3 {
template <typename T1, typename T2, typename T3>		template <typename T1, typename T2, typename T3>
testing::AssertionResult operator()(const char* e1,		testing::AssertionResult operator()(const char* e1, const char* e2,
const char* e2,		const char* e3, const T1& v1,
const char* e3,		const T2& v2, const T3& v3) const {
const T1& v1,
const T2& v2,
const T3& v3) const {
return PredFormatFunction3(e1, e2, e3, v1, v2, v3);		return PredFormatFunction3(e1, e2, e3, v1, v2, v3);
}		}
};		};
// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.		// Tests for {EXPECT|ASSERT}_PRED_FORMAT3.
class Predicate3Test : public testing::Test {		class Predicate3Test : public testing::Test {
protected:		protected:
void SetUp() override {		void SetUp() override {
expected_to_finish_ = true;		expected_to_finish_ = true;
finished_ = false;		finished_ = false;
n1_ = n2_ = n3_ = 0;		n1_ = n2_ = n3_ = 0;
}		}
void TearDown() override {		void TearDown() override {
// Verifies that each of the predicate's arguments was evaluated		// Verifies that each of the predicate's arguments was evaluated
// exactly once.		// exactly once.
EXPECT_EQ(1, n1_) <<		EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
"The predicate assertion didn't evaluate argument 2 "		"exactly once.";
"exactly once.";		EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
EXPECT_EQ(1, n2_) <<		"exactly once.";
"The predicate assertion didn't evaluate argument 3 "		EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
"exactly once.";		"exactly once.";
EXPECT_EQ(1, n3_) <<
"The predicate assertion didn't evaluate argument 4 "
"exactly once.";
// Verifies that the control flow in the test function is expected.		// Verifies that the control flow in the test function is expected.
if (expected_to_finish_ && !finished_) {		if (expected_to_finish_ && !finished_) {
FAIL() << "The predicate assertion unexpactedly aborted the test.";		FAIL() << "The predicate assertion unexpectedly aborted the test.";
} else if (!expected_to_finish_ && finished_) {		} else if (!expected_to_finish_ && finished_) {
FAIL() << "The failed predicate assertion didn't abort the test "		FAIL() << "The failed predicate assertion didn't abort the test "
"as expected.";		"as expected.";
}		}
}		}
// true if and only if the test function is expected to run to finish.		// true if and only if the test function is expected to run to finish.
static bool expected_to_finish_;		static bool expected_to_finish_;
// true if and only if the test function did run to finish.		// true if and only if the test function did run to finish.
skipping to change at line 1001		skipping to change at line 927
int Predicate3Test::n3_;		int Predicate3Test::n3_;
typedef Predicate3Test EXPECT_PRED_FORMAT3Test;		typedef Predicate3Test EXPECT_PRED_FORMAT3Test;
typedef Predicate3Test ASSERT_PRED_FORMAT3Test;		typedef Predicate3Test ASSERT_PRED_FORMAT3Test;
typedef Predicate3Test EXPECT_PRED3Test;		typedef Predicate3Test EXPECT_PRED3Test;
typedef Predicate3Test ASSERT_PRED3Test;		typedef Predicate3Test ASSERT_PRED3Test;
// Tests a successful EXPECT_PRED3 where the		// Tests a successful EXPECT_PRED3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED3(PredFunction3Int,		EXPECT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED3 where the		// Tests a successful EXPECT_PRED3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED3(PredFunction3Bool,		EXPECT_PRED3(PredFunction3Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_));
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED3 where the		// Tests a successful EXPECT_PRED3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED3(PredFunctor3(),		EXPECT_PRED3(PredFunctor3(), ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED3 where the		// Tests a successful EXPECT_PRED3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED3(PredFunctor3(),		EXPECT_PRED3(PredFunctor3(), Bool(++n1_), Bool(++n2_), Bool(++n3_));
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED3 where the		// Tests a failed EXPECT_PRED3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED3Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED3(PredFunction3Int,		{ // NOLINT
n1_++,		EXPECT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED3 where the		// Tests a failed EXPECT_PRED3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED3Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED3(PredFunction3Bool,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED3(PredFunction3Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++));
Bool(n2_++),		finished_ = true;
Bool(n3_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED3 where the		// Tests a failed EXPECT_PRED3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED3Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED3(PredFunctor3(),		{ // NOLINT
n1_++,		EXPECT_PRED3(PredFunctor3(), n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED3 where the		// Tests a failed EXPECT_PRED3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED3Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED3(PredFunctor3(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED3(PredFunctor3(), Bool(n1_++), Bool(n2_++), Bool(n3_++));
Bool(n2_++),		finished_ = true;
Bool(n3_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a successful ASSERT_PRED3 where the		// Tests a successful ASSERT_PRED3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED3(PredFunction3Int,		ASSERT_PRED3(PredFunction3Int, ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED3 where the		// Tests a successful ASSERT_PRED3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED3(PredFunction3Bool,		ASSERT_PRED3(PredFunction3Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_));
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED3 where the		// Tests a successful ASSERT_PRED3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED3(PredFunctor3(),		ASSERT_PRED3(PredFunctor3(), ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED3 where the		// Tests a successful ASSERT_PRED3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED3(PredFunctor3(),		ASSERT_PRED3(PredFunctor3(), Bool(++n1_), Bool(++n2_), Bool(++n3_));
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED3 where the		// Tests a failed ASSERT_PRED3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED3Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED3(PredFunction3Int,		{ // NOLINT
n1_++,		ASSERT_PRED3(PredFunction3Int, n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED3 where the		// Tests a failed ASSERT_PRED3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED3Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED3(PredFunction3Bool,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED3(PredFunction3Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++));
Bool(n2_++),		finished_ = true;
Bool(n3_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED3 where the		// Tests a failed ASSERT_PRED3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED3Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED3(PredFunctor3(),		{ // NOLINT
n1_++,		ASSERT_PRED3(PredFunctor3(), n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED3 where the		// Tests a failed ASSERT_PRED3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED3Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED3(PredFunctor3(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED3(PredFunctor3(), Bool(n1_++), Bool(n2_++), Bool(n3_++));
Bool(n2_++),		finished_ = true;
Bool(n3_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a successful EXPECT_PRED_FORMAT3 where the		// Tests a successful EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT3(PredFormatFunction3,		EXPECT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT3 where the		// Tests a successful EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED_FORMAT3(PredFormatFunction3,		EXPECT_PRED_FORMAT3(PredFormatFunction3, Bool(++n1_), Bool(++n2_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));		Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT3 where the		// Tests a successful EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT3(PredFormatFunctor3(),		EXPECT_PRED_FORMAT3(PredFormatFunctor3(), ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT3 where the		// Tests a successful EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED_FORMAT3(PredFormatFunctor3(),		EXPECT_PRED_FORMAT3(PredFormatFunctor3(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));		Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED_FORMAT3 where the		// Tests a failed EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT3(PredFormatFunction3,		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT3 where the		// Tests a failed EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT3(PredFormatFunction3,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT3(PredFormatFunction3, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++));
Bool(n3_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed EXPECT_PRED_FORMAT3 where the		// Tests a failed EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT3(PredFormatFunctor3(),		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT3(PredFormatFunctor3(), n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT3 where the		// Tests a failed EXPECT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT3(PredFormatFunctor3(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT3(PredFormatFunctor3(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++));
Bool(n3_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a successful ASSERT_PRED_FORMAT3 where the		// Tests a successful ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT3(PredFormatFunction3,		ASSERT_PRED_FORMAT3(PredFormatFunction3, ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT3 where the		// Tests a successful ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED_FORMAT3(PredFormatFunction3,		ASSERT_PRED_FORMAT3(PredFormatFunction3, Bool(++n1_), Bool(++n2_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));		Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT3 where the		// Tests a successful ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT3(PredFormatFunctor3(),		ASSERT_PRED_FORMAT3(PredFormatFunctor3(), ++n1_, ++n2_, ++n3_);
++n1_,
++n2_,
++n3_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT3 where the		// Tests a successful ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED_FORMAT3(PredFormatFunctor3(),		ASSERT_PRED_FORMAT3(PredFormatFunctor3(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_));		Bool(++n3_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED_FORMAT3 where the		// Tests a failed ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT3(PredFormatFunction3,		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT3(PredFormatFunction3, n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT3 where the		// Tests a failed ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT3(PredFormatFunction3,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT3(PredFormatFunction3, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++));
Bool(n3_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Tests a failed ASSERT_PRED_FORMAT3 where the		// Tests a failed ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT3(PredFormatFunctor3(),		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT3(PredFormatFunctor3(), n1_++, n2_++, n3_++);
n2_++,		finished_ = true;
n3_++);		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT3 where the		// Tests a failed ASSERT_PRED_FORMAT3 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT3Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT3(PredFormatFunctor3(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT3(PredFormatFunctor3(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++));
Bool(n3_++));		finished_ = true;
finished_ = true;		},
}, "");		"");
}		}
// Sample functions/functors for testing 4-ary predicate assertions.		// Sample functions/functors for testing 4-ary predicate assertions.
// A 4-ary predicate function.		// A 4-ary predicate function.
template <typename T1, typename T2, typename T3, typename T4>		template <typename T1, typename T2, typename T3, typename T4>
bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {		bool PredFunction4(T1 v1, T2 v2, T3 v3, T4 v4) {
return v1 + v2 + v3 + v4 > 0;		return v1 + v2 + v3 + v4 > 0;
}		}
// The following two functions are needed because a compiler doesn't have		// The following two functions are needed because a compiler doesn't have
skipping to change at line 1377		skipping to change at line 1247
bool PredFunction4Int(int v1, int v2, int v3, int v4) {		bool PredFunction4Int(int v1, int v2, int v3, int v4) {
return v1 + v2 + v3 + v4 > 0;		return v1 + v2 + v3 + v4 > 0;
}		}
bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {		bool PredFunction4Bool(Bool v1, Bool v2, Bool v3, Bool v4) {
return v1 + v2 + v3 + v4 > 0;		return v1 + v2 + v3 + v4 > 0;
}		}
// A 4-ary predicate functor.		// A 4-ary predicate functor.
struct PredFunctor4 {		struct PredFunctor4 {
template <typename T1, typename T2, typename T3, typename T4>		template <typename T1, typename T2, typename T3, typename T4>
bool operator()(const T1& v1,		bool operator()(const T1& v1, const T2& v2, const T3& v3, const T4& v4) {
const T2& v2,
const T3& v3,
const T4& v4) {
return v1 + v2 + v3 + v4 > 0;		return v1 + v2 + v3 + v4 > 0;
}		}
};		};
// A 4-ary predicate-formatter function.		// A 4-ary predicate-formatter function.
template <typename T1, typename T2, typename T3, typename T4>		template <typename T1, typename T2, typename T3, typename T4>
testing::AssertionResult PredFormatFunction4(const char* e1,		testing::AssertionResult PredFormatFunction4(const char* e1, const char* e2,
const char* e2,		const char* e3, const char* e4,
const char* e3,		const T1& v1, const T2& v2,
const char* e4,		const T3& v3, const T4& v4) {
const T1& v1,		if (PredFunction4(v1, v2, v3, v4)) return testing::AssertionSuccess();
const T2& v2,
const T3& v3,
const T4& v4) {
if (PredFunction4(v1, v2, v3, v4))
return testing::AssertionSuccess();
return testing::AssertionFailure()		return testing::AssertionFailure()
<< e1 << " + " << e2 << " + " << e3 << " + " << e4		<< e1 << " + " << e2 << " + " << e3 << " + " << e4
<< " is expected to be positive, but evaluates to "		<< " is expected to be positive, but evaluates to "
<< v1 + v2 + v3 + v4 << ".";		<< v1 + v2 + v3 + v4 << ".";
}		}
// A 4-ary predicate-formatter functor.		// A 4-ary predicate-formatter functor.
struct PredFormatFunctor4 {		struct PredFormatFunctor4 {
template <typename T1, typename T2, typename T3, typename T4>		template <typename T1, typename T2, typename T3, typename T4>
testing::AssertionResult operator()(const char* e1,		testing::AssertionResult operator()(const char* e1, const char* e2,
const char* e2,		const char* e3, const char* e4,
const char* e3,		const T1& v1, const T2& v2, const T3& v3,
const char* e4,
const T1& v1,
const T2& v2,
const T3& v3,
const T4& v4) const {		const T4& v4) const {
return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);		return PredFormatFunction4(e1, e2, e3, e4, v1, v2, v3, v4);
}		}
};		};
// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.		// Tests for {EXPECT|ASSERT}_PRED_FORMAT4.
class Predicate4Test : public testing::Test {		class Predicate4Test : public testing::Test {
protected:		protected:
void SetUp() override {		void SetUp() override {
expected_to_finish_ = true;		expected_to_finish_ = true;
finished_ = false;		finished_ = false;
n1_ = n2_ = n3_ = n4_ = 0;		n1_ = n2_ = n3_ = n4_ = 0;
}		}
void TearDown() override {		void TearDown() override {
// Verifies that each of the predicate's arguments was evaluated		// Verifies that each of the predicate's arguments was evaluated
// exactly once.		// exactly once.
EXPECT_EQ(1, n1_) <<		EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
"The predicate assertion didn't evaluate argument 2 "		"exactly once.";
"exactly once.";		EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
EXPECT_EQ(1, n2_) <<		"exactly once.";
"The predicate assertion didn't evaluate argument 3 "		EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
"exactly once.";		"exactly once.";
EXPECT_EQ(1, n3_) <<		EXPECT_EQ(1, n4_) << "The predicate assertion didn't evaluate argument 5 "
"The predicate assertion didn't evaluate argument 4 "		"exactly once.";
"exactly once.";
EXPECT_EQ(1, n4_) <<
"The predicate assertion didn't evaluate argument 5 "
"exactly once.";
// Verifies that the control flow in the test function is expected.		// Verifies that the control flow in the test function is expected.
if (expected_to_finish_ && !finished_) {		if (expected_to_finish_ && !finished_) {
FAIL() << "The predicate assertion unexpactedly aborted the test.";		FAIL() << "The predicate assertion unexpectedly aborted the test.";
} else if (!expected_to_finish_ && finished_) {		} else if (!expected_to_finish_ && finished_) {
FAIL() << "The failed predicate assertion didn't abort the test "		FAIL() << "The failed predicate assertion didn't abort the test "
"as expected.";		"as expected.";
}		}
}		}
// true if and only if the test function is expected to run to finish.		// true if and only if the test function is expected to run to finish.
static bool expected_to_finish_;		static bool expected_to_finish_;
// true if and only if the test function did run to finish.		// true if and only if the test function did run to finish.
skipping to change at line 1481		skipping to change at line 1335
int Predicate4Test::n4_;		int Predicate4Test::n4_;
typedef Predicate4Test EXPECT_PRED_FORMAT4Test;		typedef Predicate4Test EXPECT_PRED_FORMAT4Test;
typedef Predicate4Test ASSERT_PRED_FORMAT4Test;		typedef Predicate4Test ASSERT_PRED_FORMAT4Test;
typedef Predicate4Test EXPECT_PRED4Test;		typedef Predicate4Test EXPECT_PRED4Test;
typedef Predicate4Test ASSERT_PRED4Test;		typedef Predicate4Test ASSERT_PRED4Test;
// Tests a successful EXPECT_PRED4 where the		// Tests a successful EXPECT_PRED4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED4(PredFunction4Int,		EXPECT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED4 where the		// Tests a successful EXPECT_PRED4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED4(PredFunction4Bool,		EXPECT_PRED4(PredFunction4Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));		Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED4 where the		// Tests a successful EXPECT_PRED4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED4(PredFunctor4(),		EXPECT_PRED4(PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED4 where the		// Tests a successful EXPECT_PRED4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED4(PredFunctor4(),		EXPECT_PRED4(PredFunctor4(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));		Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED4 where the		// Tests a failed EXPECT_PRED4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED4Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED4(PredFunction4Int,		{ // NOLINT
n1_++,		EXPECT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED4 where the		// Tests a failed EXPECT_PRED4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED4Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED4(PredFunction4Bool,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED4(PredFunction4Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED4 where the		// Tests a failed EXPECT_PRED4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED4Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED4(PredFunctor4(),		{ // NOLINT
n1_++,		EXPECT_PRED4(PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED4 where the		// Tests a failed EXPECT_PRED4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED4Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED4(PredFunctor4(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED4(PredFunctor4(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a successful ASSERT_PRED4 where the		// Tests a successful ASSERT_PRED4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED4(PredFunction4Int,		ASSERT_PRED4(PredFunction4Int, ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED4 where the		// Tests a successful ASSERT_PRED4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED4(PredFunction4Bool,		ASSERT_PRED4(PredFunction4Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));		Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED4 where the		// Tests a successful ASSERT_PRED4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED4(PredFunctor4(),		ASSERT_PRED4(PredFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED4 where the		// Tests a successful ASSERT_PRED4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED4(PredFunctor4(),		ASSERT_PRED4(PredFunctor4(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));		Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED4 where the		// Tests a failed ASSERT_PRED4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED4Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED4(PredFunction4Int,		{ // NOLINT
n1_++,		ASSERT_PRED4(PredFunction4Int, n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED4 where the		// Tests a failed ASSERT_PRED4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED4Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED4(PredFunction4Bool,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED4(PredFunction4Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED4 where the		// Tests a failed ASSERT_PRED4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED4Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED4(PredFunctor4(),		{ // NOLINT
n1_++,		ASSERT_PRED4(PredFunctor4(), n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED4 where the		// Tests a failed ASSERT_PRED4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED4Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED4(PredFunctor4(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED4(PredFunctor4(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a successful EXPECT_PRED_FORMAT4 where the		// Tests a successful EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT4(PredFormatFunction4,		EXPECT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT4 where the		// Tests a successful EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED_FORMAT4(PredFormatFunction4,		EXPECT_PRED_FORMAT4(PredFormatFunction4, Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT4 where the		// Tests a successful EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT4(PredFormatFunctor4(),		EXPECT_PRED_FORMAT4(PredFormatFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT4 where the		// Tests a successful EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED_FORMAT4(PredFormatFunctor4(),		EXPECT_PRED_FORMAT4(PredFormatFunctor4(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED_FORMAT4 where the		// Tests a failed EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT4(PredFormatFunction4,		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT4 where the		// Tests a failed EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT4(PredFormatFunction4,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT4(PredFormatFunction4, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT4 where the		// Tests a failed EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT4(PredFormatFunctor4(),		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT4(PredFormatFunctor4(), n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT4 where the		// Tests a failed EXPECT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT4(PredFormatFunctor4(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT4(PredFormatFunctor4(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a successful ASSERT_PRED_FORMAT4 where the		// Tests a successful ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT4(PredFormatFunction4,		ASSERT_PRED_FORMAT4(PredFormatFunction4, ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT4 where the		// Tests a successful ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED_FORMAT4(PredFormatFunction4,		ASSERT_PRED_FORMAT4(PredFormatFunction4, Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT4 where the		// Tests a successful ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT4(PredFormatFunctor4(),		ASSERT_PRED_FORMAT4(PredFormatFunctor4(), ++n1_, ++n2_, ++n3_, ++n4_);
++n1_,
++n2_,
++n3_,
++n4_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT4 where the		// Tests a successful ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED_FORMAT4(PredFormatFunctor4(),		ASSERT_PRED_FORMAT4(PredFormatFunctor4(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED_FORMAT4 where the		// Tests a failed ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT4(PredFormatFunction4,		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT4(PredFormatFunction4, n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT4 where the		// Tests a failed ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT4(PredFormatFunction4,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT4(PredFormatFunction4, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT4 where the		// Tests a failed ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT4(PredFormatFunctor4(),		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT4(PredFormatFunctor4(), n1_++, n2_++, n3_++, n4_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT4 where the		// Tests a failed ASSERT_PRED_FORMAT4 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT4Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT4(PredFormatFunctor4(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT4(PredFormatFunctor4(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++));		},
finished_ = true;		"");
}, "");
}		}
// Sample functions/functors for testing 5-ary predicate assertions.		// Sample functions/functors for testing 5-ary predicate assertions.
// A 5-ary predicate function.		// A 5-ary predicate function.
template <typename T1, typename T2, typename T3, typename T4, typename T5>		template <typename T1, typename T2, typename T3, typename T4, typename T5>
bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {		bool PredFunction5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
return v1 + v2 + v3 + v4 + v5 > 0;		return v1 + v2 + v3 + v4 + v5 > 0;
}		}
// The following two functions are needed because a compiler doesn't have		// The following two functions are needed because a compiler doesn't have
skipping to change at line 1889		skipping to change at line 1663
bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {		bool PredFunction5Int(int v1, int v2, int v3, int v4, int v5) {
return v1 + v2 + v3 + v4 + v5 > 0;		return v1 + v2 + v3 + v4 + v5 > 0;
}		}
bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {		bool PredFunction5Bool(Bool v1, Bool v2, Bool v3, Bool v4, Bool v5) {
return v1 + v2 + v3 + v4 + v5 > 0;		return v1 + v2 + v3 + v4 + v5 > 0;
}		}
// A 5-ary predicate functor.		// A 5-ary predicate functor.
struct PredFunctor5 {		struct PredFunctor5 {
template <typename T1, typename T2, typename T3, typename T4, typename T5>		template <typename T1, typename T2, typename T3, typename T4, typename T5>
bool operator()(const T1& v1,		bool operator()(const T1& v1, const T2& v2, const T3& v3, const T4& v4,
const T2& v2,
const T3& v3,
const T4& v4,
const T5& v5) {		const T5& v5) {
return v1 + v2 + v3 + v4 + v5 > 0;		return v1 + v2 + v3 + v4 + v5 > 0;
}		}
};		};
// A 5-ary predicate-formatter function.		// A 5-ary predicate-formatter function.
template <typename T1, typename T2, typename T3, typename T4, typename T5>		template <typename T1, typename T2, typename T3, typename T4, typename T5>
testing::AssertionResult PredFormatFunction5(const char* e1,		testing::AssertionResult PredFormatFunction5(const char* e1, const char* e2,
const char* e2,		const char* e3, const char* e4,
const char* e3,		const char* e5, const T1& v1,
const char* e4,		const T2& v2, const T3& v3,
const char* e5,		const T4& v4, const T5& v5) {
const T1& v1,		if (PredFunction5(v1, v2, v3, v4, v5)) return testing::AssertionSuccess();
const T2& v2,
const T3& v3,
const T4& v4,
const T5& v5) {
if (PredFunction5(v1, v2, v3, v4, v5))
return testing::AssertionSuccess();
return testing::AssertionFailure()		return testing::AssertionFailure()
<< e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5		<< e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
<< " is expected to be positive, but evaluates to "		<< " is expected to be positive, but evaluates to "
<< v1 + v2 + v3 + v4 + v5 << ".";		<< v1 + v2 + v3 + v4 + v5 << ".";
}		}
// A 5-ary predicate-formatter functor.		// A 5-ary predicate-formatter functor.
struct PredFormatFunctor5 {		struct PredFormatFunctor5 {
template <typename T1, typename T2, typename T3, typename T4, typename T5>		template <typename T1, typename T2, typename T3, typename T4, typename T5>
testing::AssertionResult operator()(const char* e1,		testing::AssertionResult operator()(const char* e1, const char* e2,
const char* e2,		const char* e3, const char* e4,
const char* e3,		const char* e5, const T1& v1,
const char* e4,		const T2& v2, const T3& v3, const T4& v4,
const char* e5,
const T1& v1,
const T2& v2,
const T3& v3,
const T4& v4,
const T5& v5) const {		const T5& v5) const {
return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);		return PredFormatFunction5(e1, e2, e3, e4, e5, v1, v2, v3, v4, v5);
}		}
};		};
// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.		// Tests for {EXPECT|ASSERT}_PRED_FORMAT5.
class Predicate5Test : public testing::Test {		class Predicate5Test : public testing::Test {
protected:		protected:
void SetUp() override {		void SetUp() override {
expected_to_finish_ = true;		expected_to_finish_ = true;
finished_ = false;		finished_ = false;
n1_ = n2_ = n3_ = n4_ = n5_ = 0;		n1_ = n2_ = n3_ = n4_ = n5_ = 0;
}		}
void TearDown() override {		void TearDown() override {
// Verifies that each of the predicate's arguments was evaluated		// Verifies that each of the predicate's arguments was evaluated
// exactly once.		// exactly once.
EXPECT_EQ(1, n1_) <<		EXPECT_EQ(1, n1_) << "The predicate assertion didn't evaluate argument 2 "
"The predicate assertion didn't evaluate argument 2 "		"exactly once.";
"exactly once.";		EXPECT_EQ(1, n2_) << "The predicate assertion didn't evaluate argument 3 "
EXPECT_EQ(1, n2_) <<		"exactly once.";
"The predicate assertion didn't evaluate argument 3 "		EXPECT_EQ(1, n3_) << "The predicate assertion didn't evaluate argument 4 "
"exactly once.";		"exactly once.";
EXPECT_EQ(1, n3_) <<		EXPECT_EQ(1, n4_) << "The predicate assertion didn't evaluate argument 5 "
"The predicate assertion didn't evaluate argument 4 "		"exactly once.";
"exactly once.";		EXPECT_EQ(1, n5_) << "The predicate assertion didn't evaluate argument 6 "
EXPECT_EQ(1, n4_) <<		"exactly once.";
"The predicate assertion didn't evaluate argument 5 "
"exactly once.";
EXPECT_EQ(1, n5_) <<
"The predicate assertion didn't evaluate argument 6 "
"exactly once.";
// Verifies that the control flow in the test function is expected.		// Verifies that the control flow in the test function is expected.
if (expected_to_finish_ && !finished_) {		if (expected_to_finish_ && !finished_) {
FAIL() << "The predicate assertion unexpactedly aborted the test.";		FAIL() << "The predicate assertion unexpectedly aborted the test.";
} else if (!expected_to_finish_ && finished_) {		} else if (!expected_to_finish_ && finished_) {
FAIL() << "The failed predicate assertion didn't abort the test "		FAIL() << "The failed predicate assertion didn't abort the test "
"as expected.";		"as expected.";
}		}
}		}
// true if and only if the test function is expected to run to finish.		// true if and only if the test function is expected to run to finish.
static bool expected_to_finish_;		static bool expected_to_finish_;
// true if and only if the test function did run to finish.		// true if and only if the test function did run to finish.
skipping to change at line 2003		skipping to change at line 1758
int Predicate5Test::n5_;		int Predicate5Test::n5_;
typedef Predicate5Test EXPECT_PRED_FORMAT5Test;		typedef Predicate5Test EXPECT_PRED_FORMAT5Test;
typedef Predicate5Test ASSERT_PRED_FORMAT5Test;		typedef Predicate5Test ASSERT_PRED_FORMAT5Test;
typedef Predicate5Test EXPECT_PRED5Test;		typedef Predicate5Test EXPECT_PRED5Test;
typedef Predicate5Test ASSERT_PRED5Test;		typedef Predicate5Test ASSERT_PRED5Test;
// Tests a successful EXPECT_PRED5 where the		// Tests a successful EXPECT_PRED5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED5(PredFunction5Int,		EXPECT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED5 where the		// Tests a successful EXPECT_PRED5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED5(PredFunction5Bool,		EXPECT_PRED5(PredFunction5Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),		Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED5 where the		// Tests a successful EXPECT_PRED5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED5(PredFunctor5(),		EXPECT_PRED5(PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED5 where the		// Tests a successful EXPECT_PRED5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED5(PredFunctor5(),		EXPECT_PRED5(PredFunctor5(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),		Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED5 where the		// Tests a failed EXPECT_PRED5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED5Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED5(PredFunction5Int,		{ // NOLINT
n1_++,		EXPECT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++,		"");
n5_++);
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED5 where the		// Tests a failed EXPECT_PRED5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED5Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED5(PredFunction5Bool,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED5(PredFunction5Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED5 where the		// Tests a failed EXPECT_PRED5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED5Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED5(PredFunctor5(),		{ // NOLINT
n1_++,		EXPECT_PRED5(PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++,		"");
n5_++);
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED5 where the		// Tests a failed EXPECT_PRED5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED5Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED5(PredFunctor5(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED5(PredFunctor5(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a successful ASSERT_PRED5 where the		// Tests a successful ASSERT_PRED5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED5(PredFunction5Int,		ASSERT_PRED5(PredFunction5Int, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED5 where the		// Tests a successful ASSERT_PRED5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED5(PredFunction5Bool,		ASSERT_PRED5(PredFunction5Bool, Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),		Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED5 where the		// Tests a successful ASSERT_PRED5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED5(PredFunctor5(),		ASSERT_PRED5(PredFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED5 where the		// Tests a successful ASSERT_PRED5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED5(PredFunctor5(),		ASSERT_PRED5(PredFunctor5(), Bool(++n1_), Bool(++n2_), Bool(++n3_),
Bool(++n1_),		Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED5 where the		// Tests a failed ASSERT_PRED5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED5Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED5(PredFunction5Int,		{ // NOLINT
n1_++,		ASSERT_PRED5(PredFunction5Int, n1_++, n2_++, n3_++, n4_++, n5_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++,		"");
n5_++);
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED5 where the		// Tests a failed ASSERT_PRED5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED5Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED5(PredFunction5Bool,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED5(PredFunction5Bool, Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED5 where the		// Tests a failed ASSERT_PRED5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED5Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED5(PredFunctor5(),		{ // NOLINT
n1_++,		ASSERT_PRED5(PredFunctor5(), n1_++, n2_++, n3_++, n4_++, n5_++);
n2_++,		finished_ = true;
n3_++,		},
n4_++,		"");
n5_++);
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED5 where the		// Tests a failed ASSERT_PRED5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED5Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED5(PredFunctor5(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED5(PredFunctor5(), Bool(n1_++), Bool(n2_++), Bool(n3_++),
Bool(n2_++),		Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a successful EXPECT_PRED_FORMAT5 where the		// Tests a successful EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT5(PredFormatFunction5,		EXPECT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT5 where the		// Tests a successful EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
EXPECT_PRED_FORMAT5(PredFormatFunction5,		EXPECT_PRED_FORMAT5(PredFormatFunction5, Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT5 where the		// Tests a successful EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
EXPECT_PRED_FORMAT5(PredFormatFunctor5(),		EXPECT_PRED_FORMAT5(PredFormatFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful EXPECT_PRED_FORMAT5 where the		// Tests a successful EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
EXPECT_PRED_FORMAT5(PredFormatFunctor5(),		EXPECT_PRED_FORMAT5(PredFormatFunctor5(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed EXPECT_PRED_FORMAT5 where the		// Tests a failed EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT5(PredFormatFunction5,		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
n2_++,		n5_++);
n3_++,		finished_ = true;
n4_++,		},
n5_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT5 where the		// Tests a failed EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT5(PredFormatFunction5,		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT5(PredFormatFunction5, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT5 where the		// Tests a failed EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT5(PredFormatFunctor5(),		{ // NOLINT
n1_++,		EXPECT_PRED_FORMAT5(PredFormatFunctor5(), n1_++, n2_++, n3_++, n4_++,
n2_++,		n5_++);
n3_++,		finished_ = true;
n4_++,		},
n5_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed EXPECT_PRED_FORMAT5 where the		// Tests a failed EXPECT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {		TEST_F(EXPECT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
EXPECT_NONFATAL_FAILURE({ // NOLINT		EXPECT_NONFATAL_FAILURE(
EXPECT_PRED_FORMAT5(PredFormatFunctor5(),		{ // NOLINT
Bool(n1_++),		EXPECT_PRED_FORMAT5(PredFormatFunctor5(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a successful ASSERT_PRED_FORMAT5 where the		// Tests a successful ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT5(PredFormatFunction5,		ASSERT_PRED_FORMAT5(PredFormatFunction5, ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT5 where the		// Tests a successful ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeSuccess) {
ASSERT_PRED_FORMAT5(PredFormatFunction5,		ASSERT_PRED_FORMAT5(PredFormatFunction5, Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT5 where the		// Tests a successful ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeSuccess) {
ASSERT_PRED_FORMAT5(PredFormatFunctor5(),		ASSERT_PRED_FORMAT5(PredFormatFunctor5(), ++n1_, ++n2_, ++n3_, ++n4_, ++n5_);
++n1_,
++n2_,
++n3_,
++n4_,
++n5_);
finished_ = true;		finished_ = true;
}		}
// Tests a successful ASSERT_PRED_FORMAT5 where the		// Tests a successful ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeSuccess) {
ASSERT_PRED_FORMAT5(PredFormatFunctor5(),		ASSERT_PRED_FORMAT5(PredFormatFunctor5(), Bool(++n1_), Bool(++n2_),
Bool(++n1_),		Bool(++n3_), Bool(++n4_), Bool(++n5_));
Bool(++n2_),
Bool(++n3_),
Bool(++n4_),
Bool(++n5_));
finished_ = true;		finished_ = true;
}		}
// Tests a failed ASSERT_PRED_FORMAT5 where the		// Tests a failed ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a function on a built-in type (int).		// predicate-formatter is a function on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT5(PredFormatFunction5,		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT5(PredFormatFunction5, n1_++, n2_++, n3_++, n4_++,
n2_++,		n5_++);
n3_++,		finished_ = true;
n4_++,		},
n5_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT5 where the		// Tests a failed ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a function on a user-defined type (Bool).		// predicate-formatter is a function on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctionOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT5(PredFormatFunction5,		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT5(PredFormatFunction5, Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT5 where the		// Tests a failed ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a built-in type (int).		// predicate-formatter is a functor on a built-in type (int).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnBuiltInTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT5(PredFormatFunctor5(),		{ // NOLINT
n1_++,		ASSERT_PRED_FORMAT5(PredFormatFunctor5(), n1_++, n2_++, n3_++, n4_++,
n2_++,		n5_++);
n3_++,		finished_ = true;
n4_++,		},
n5_++);		"");
finished_ = true;
}, "");
}		}
// Tests a failed ASSERT_PRED_FORMAT5 where the		// Tests a failed ASSERT_PRED_FORMAT5 where the
// predicate-formatter is a functor on a user-defined type (Bool).		// predicate-formatter is a functor on a user-defined type (Bool).
TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {		TEST_F(ASSERT_PRED_FORMAT5Test, FunctorOnUserTypeFailure) {
expected_to_finish_ = false;		expected_to_finish_ = false;
EXPECT_FATAL_FAILURE({ // NOLINT		EXPECT_FATAL_FAILURE(
ASSERT_PRED_FORMAT5(PredFormatFunctor5(),		{ // NOLINT
Bool(n1_++),		ASSERT_PRED_FORMAT5(PredFormatFunctor5(), Bool(n1_++), Bool(n2_++),
Bool(n2_++),		Bool(n3_++), Bool(n4_++), Bool(n5_++));
Bool(n3_++),		finished_ = true;
Bool(n4_++),		},
Bool(n5_++));		"");
finished_ = true;
}, "");
}		}
End of changes. 195 change blocks.
1040 lines changed or deleted		687 lines changed or added

---