"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/googletest-output-test_.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.

googletest-output-test_.cc  (googletest-release-1.11.0)	:	googletest-output-test_.cc  (googletest-release-1.12.0)
skipping to change at line 36		skipping to change at line 36
// 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.
//		//
// The purpose of this file is to generate Google Test output under		// The purpose of this file is to generate Google Test output under
// various conditions. The output will then be verified by		// various conditions. The output will then be verified by
// googletest-output-test.py to ensure that Google Test generates the		// googletest-output-test.py to ensure that Google Test generates the
// desired messages. Therefore, most tests in this file are MEANT TO		// desired messages. Therefore, most tests in this file are MEANT TO
// FAIL.		// FAIL.
		#include <stdlib.h>
#include "gtest/gtest-spi.h"		#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"		#include "gtest/gtest.h"
#include "src/gtest-internal-inl.h"		#include "src/gtest-internal-inl.h"
#include <stdlib.h>
#if _MSC_VER		#if _MSC_VER
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */)		GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */)
#endif // _MSC_VER		#endif // _MSC_VER
#if GTEST_IS_THREADSAFE		#if GTEST_IS_THREADSAFE
using testing::ScopedFakeTestPartResultReporter;		using testing::ScopedFakeTestPartResultReporter;
using testing::TestPartResultArray;		using testing::TestPartResultArray;
using testing::internal::Notification;		using testing::internal::Notification;
using testing::internal::ThreadWithParam;		using testing::internal::ThreadWithParam;
#endif		#endif
namespace posix = ::testing::internal::posix;		namespace posix = ::testing::internal::posix;
// Tests catching fatal failures.		// Tests catching fatal failures.
// A subroutine used by the following test.		// A subroutine used by the following test.
void TestEq1(int x) {		void TestEq1(int x) { ASSERT_EQ(1, x); }
ASSERT_EQ(1, x);
}
// This function calls a test subroutine, catches the fatal failure it		// This function calls a test subroutine, catches the fatal failure it
// generates, and then returns early.		// generates, and then returns early.
void TryTestSubroutine() {		void TryTestSubroutine() {
// Calls a subrountine that yields a fatal failure.		// Calls a subrountine that yields a fatal failure.
TestEq1(2);		TestEq1(2);
// Catches the fatal failure and aborts the test.		// Catches the fatal failure and aborts the test.
//		//
// The testing::Test:: prefix is necessary when calling		// The testing::Test:: prefix is necessary when calling
// HasFatalFailure() outside of a TEST, TEST_F, or test fixture.		// HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
if (testing::Test::HasFatalFailure()) return;		if (testing::Test::HasFatalFailure()) return;
// If we get here, something is wrong.		// If we get here, something is wrong.
FAIL() << "This should never be reached.";		FAIL() << "This should never be reached.";
}		}
TEST(PassingTest, PassingTest1) {		TEST(PassingTest, PassingTest1) {}
}
TEST(PassingTest, PassingTest2) {		TEST(PassingTest, PassingTest2) {}
}
// Tests that parameters of failing parameterized tests are printed in the		// Tests that parameters of failing parameterized tests are printed in the
// failing test summary.		// failing test summary.
class FailingParamTest : public testing::TestWithParam<int> {};		class FailingParamTest : public testing::TestWithParam<int> {};
TEST_P(FailingParamTest, Fails) {		TEST_P(FailingParamTest, Fails) { EXPECT_EQ(1, GetParam()); }
EXPECT_EQ(1, GetParam());
}
// This generates a test which will fail. Google Test is expected to print		// This generates a test which will fail. Google Test is expected to print
// its parameter when it outputs the list of all failed tests.		// its parameter when it outputs the list of all failed tests.
INSTANTIATE_TEST_SUITE_P(PrintingFailingParams,		INSTANTIATE_TEST_SUITE_P(PrintingFailingParams, FailingParamTest,
FailingParamTest,
testing::Values(2));		testing::Values(2));
// Tests that an empty value for the test suite basename yields just		// Tests that an empty value for the test suite basename yields just
// the test name without any prior /		// the test name without any prior /
class EmptyBasenameParamInst : public testing::TestWithParam<int> {};		class EmptyBasenameParamInst : public testing::TestWithParam<int> {};
TEST_P(EmptyBasenameParamInst, Passes) { EXPECT_EQ(1, GetParam()); }		TEST_P(EmptyBasenameParamInst, Passes) { EXPECT_EQ(1, GetParam()); }
INSTANTIATE_TEST_SUITE_P(, EmptyBasenameParamInst, testing::Values(1));		INSTANTIATE_TEST_SUITE_P(, EmptyBasenameParamInst, testing::Values(1));
skipping to change at line 149		skipping to change at line 142
// fixture, the testing::Test:: prefix is not needed.		// fixture, the testing::Test:: prefix is not needed.
if (HasFatalFailure()) return;		if (HasFatalFailure()) return;
// If we get here, something is wrong.		// If we get here, something is wrong.
FAIL() << "This should never be reached.";		FAIL() << "This should never be reached.";
}		}
// Tests HasFatalFailure() after a failed EXPECT check.		// Tests HasFatalFailure() after a failed EXPECT check.
TEST(FatalFailureTest, NonfatalFailureInSubroutine) {		TEST(FatalFailureTest, NonfatalFailureInSubroutine) {
printf("(expecting a failure on false)\n");		printf("(expecting a failure on false)\n");
EXPECT_TRUE(false); // Generates a nonfatal failure		EXPECT_TRUE(false); // Generates a nonfatal failure
ASSERT_FALSE(HasFatalFailure()); // This should succeed.		ASSERT_FALSE(HasFatalFailure()); // This should succeed.
}		}
// Tests interleaving user logging and Google Test assertions.		// Tests interleaving user logging and Google Test assertions.
TEST(LoggingTest, InterleavingLoggingAndAssertions) {		TEST(LoggingTest, InterleavingLoggingAndAssertions) {
static const int a[4] = {		static const int a[4] = {3, 9, 2, 6};
3, 9, 2, 6
};
printf("(expecting 2 failures on (3) >= (a[i]))\n");		printf("(expecting 2 failures on (3) >= (a[i]))\n");
for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {		for (int i = 0; i < static_cast<int>(sizeof(a) / sizeof(*a)); i++) {
printf("i == %d\n", i);		printf("i == %d\n", i);
EXPECT_GE(3, a[i]);		EXPECT_GE(3, a[i]);
}		}
}		}
// Tests the SCOPED_TRACE macro.		// Tests the SCOPED_TRACE macro.
// A helper function for testing SCOPED_TRACE.		// A helper function for testing SCOPED_TRACE.
void SubWithoutTrace(int n) {		void SubWithoutTrace(int n) {
EXPECT_EQ(1, n);		EXPECT_EQ(1, n);
skipping to change at line 300		skipping to change at line 291
struct CheckPoints {		struct CheckPoints {
Notification n1;		Notification n1;
Notification n2;		Notification n2;
Notification n3;		Notification n3;
};		};
static void ThreadWithScopedTrace(CheckPoints* check_points) {		static void ThreadWithScopedTrace(CheckPoints* check_points) {
{		{
SCOPED_TRACE("Trace B");		SCOPED_TRACE("Trace B");
ADD_FAILURE()		ADD_FAILURE() << "Expected failure #1 (in thread B, only trace B alive).";
<< "Expected failure #1 (in thread B, only trace B alive).";
check_points->n1.Notify();		check_points->n1.Notify();
check_points->n2.WaitForNotification();		check_points->n2.WaitForNotification();
ADD_FAILURE()		ADD_FAILURE()
<< "Expected failure #3 (in thread B, trace A & B both alive).";		<< "Expected failure #3 (in thread B, trace A & B both alive).";
} // Trace B dies here.		} // Trace B dies here.
ADD_FAILURE()		ADD_FAILURE() << "Expected failure #4 (in thread B, only trace A alive).";
<< "Expected failure #4 (in thread B, only trace A alive).";
check_points->n3.Notify();		check_points->n3.Notify();
}		}
TEST(SCOPED_TRACETest, WorksConcurrently) {		TEST(SCOPED_TRACETest, WorksConcurrently) {
printf("(expecting 6 failures)\n");		printf("(expecting 6 failures)\n");
CheckPoints check_points;		CheckPoints check_points;
ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, &check_points,		ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, &check_points,
nullptr);		nullptr);
check_points.n1.WaitForNotification();		check_points.n1.WaitForNotification();
{		{
SCOPED_TRACE("Trace A");		SCOPED_TRACE("Trace A");
ADD_FAILURE()		ADD_FAILURE()
<< "Expected failure #2 (in thread A, trace A & B both alive).";		<< "Expected failure #2 (in thread A, trace A & B both alive).";
check_points.n2.Notify();		check_points.n2.Notify();
check_points.n3.WaitForNotification();		check_points.n3.WaitForNotification();
ADD_FAILURE()		ADD_FAILURE() << "Expected failure #5 (in thread A, only trace A alive).";
<< "Expected failure #5 (in thread A, only trace A alive).";
} // Trace A dies here.		} // Trace A dies here.
ADD_FAILURE()		ADD_FAILURE() << "Expected failure #6 (in thread A, no trace alive).";
<< "Expected failure #6 (in thread A, no trace alive).";
thread.Join();		thread.Join();
}		}
#endif // GTEST_IS_THREADSAFE		#endif // GTEST_IS_THREADSAFE
// Tests basic functionality of the ScopedTrace utility (most of its features		// Tests basic functionality of the ScopedTrace utility (most of its features
// are already tested in SCOPED_TRACETest).		// are already tested in SCOPED_TRACETest).
TEST(ScopedTraceTest, WithExplicitFileAndLine) {		TEST(ScopedTraceTest, WithExplicitFileAndLine) {
testing::ScopedTrace trace("explicit_file.cc", 123, "expected trace message");		testing::ScopedTrace trace("explicit_file.cc", 123, "expected trace message");
ADD_FAILURE() << "Check that the trace is attached to a particular location.";		ADD_FAILURE() << "Check that the trace is attached to a particular location.";
}		}
skipping to change at line 415		skipping to change at line 402
<< "had a fatal failure.";		<< "had a fatal failure.";
}		}
void TearDown() override {		void TearDown() override {
ADD_FAILURE() << "UNEXPECTED failure in TearDown(). "		ADD_FAILURE() << "UNEXPECTED failure in TearDown(). "
<< "We should never get here, as the test fixture c'tor "		<< "We should never get here, as the test fixture c'tor "
<< "had a fatal failure.";		<< "had a fatal failure.";
}		}
private:		private:
void Init() {		void Init() { FAIL() << "Expected failure #1, in the test fixture c'tor."; }
FAIL() << "Expected failure #1, in the test fixture c'tor.";
}
};		};
TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {		TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {
ADD_FAILURE() << "UNEXPECTED failure in the test body. "		ADD_FAILURE() << "UNEXPECTED failure in the test body. "
<< "We should never get here, as the test fixture c'tor "		<< "We should never get here, as the test fixture c'tor "
<< "had a fatal failure.";		<< "had a fatal failure.";
}		}
// Tests non-fatal failures in SetUp().		// Tests non-fatal failures in SetUp().
class NonFatalFailureInSetUpTest : public testing::Test {		class NonFatalFailureInSetUpTest : public testing::Test {
skipping to change at line 439		skipping to change at line 424
~NonFatalFailureInSetUpTest() override { Deinit(); }		~NonFatalFailureInSetUpTest() override { Deinit(); }
void SetUp() override {		void SetUp() override {
printf("(expecting 4 failures)\n");		printf("(expecting 4 failures)\n");
ADD_FAILURE() << "Expected failure #1, in SetUp().";		ADD_FAILURE() << "Expected failure #1, in SetUp().";
}		}
void TearDown() override { FAIL() << "Expected failure #3, in TearDown()."; }		void TearDown() override { FAIL() << "Expected failure #3, in TearDown()."; }
private:		private:
void Deinit() {		void Deinit() { FAIL() << "Expected failure #4, in the test fixture d'tor."; }
FAIL() << "Expected failure #4, in the test fixture d'tor.";
}
};		};
TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {		TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {
FAIL() << "Expected failure #2, in the test function.";		FAIL() << "Expected failure #2, in the test function.";
}		}
// Tests fatal failures in SetUp().		// Tests fatal failures in SetUp().
class FatalFailureInSetUpTest : public testing::Test {		class FatalFailureInSetUpTest : public testing::Test {
protected:		protected:
~FatalFailureInSetUpTest() override { Deinit(); }		~FatalFailureInSetUpTest() override { Deinit(); }
void SetUp() override {		void SetUp() override {
printf("(expecting 3 failures)\n");		printf("(expecting 3 failures)\n");
FAIL() << "Expected failure #1, in SetUp().";		FAIL() << "Expected failure #1, in SetUp().";
}		}
void TearDown() override { FAIL() << "Expected failure #2, in TearDown()."; }		void TearDown() override { FAIL() << "Expected failure #2, in TearDown()."; }
private:		private:
void Deinit() {		void Deinit() { FAIL() << "Expected failure #3, in the test fixture d'tor."; }
FAIL() << "Expected failure #3, in the test fixture d'tor.";
}
};		};
TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {		TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {
FAIL() << "UNEXPECTED failure in the test function. "		FAIL() << "UNEXPECTED failure in the test function. "
<< "We should never get here, as SetUp() failed.";		<< "We should never get here, as SetUp() failed.";
}		}
TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {		TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {
ADD_FAILURE_AT("foo.cc", 42) << "Expected nonfatal failure in foo.cc";		ADD_FAILURE_AT("foo.cc", 42) << "Expected nonfatal failure in foo.cc";
}		}
skipping to change at line 491		skipping to change at line 472
// the same test case use. It deliberately contains two fixture		// the same test case use. It deliberately contains two fixture
// classes with the same name but defined in different namespaces.		// classes with the same name but defined in different namespaces.
// The MixedUpTestSuiteWithSameTestNameTest test case verifies that		// The MixedUpTestSuiteWithSameTestNameTest test case verifies that
// when the user defines two tests with the same test case name AND		// when the user defines two tests with the same test case name AND
// same test name (but in different namespaces), the second test will		// same test name (but in different namespaces), the second test will
// fail.		// fail.
namespace foo {		namespace foo {
class MixedUpTestSuiteTest : public testing::Test {		class MixedUpTestSuiteTest : public testing::Test {};
};
TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {}		TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {}
TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {}		TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {}
class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {		class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {};
};
TEST_F(MixedUpTestSuiteWithSameTestNameTest,		TEST_F(MixedUpTestSuiteWithSameTestNameTest,
TheSecondTestWithThisNameShouldFail) {}		TheSecondTestWithThisNameShouldFail) {}
} // namespace foo		} // namespace foo
namespace bar {		namespace bar {
class MixedUpTestSuiteTest : public testing::Test {		class MixedUpTestSuiteTest : public testing::Test {};
};
// The following two tests are expected to fail. We rely on the		// The following two tests are expected to fail. We rely on the
// golden file to check that Google Test generates the right error message.		// golden file to check that Google Test generates the right error message.
TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {}		TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {}
TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {}		TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {}
class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {		class MixedUpTestSuiteWithSameTestNameTest : public testing::Test {};
};
// Expected to fail. We rely on the golden file to check that Google Test		// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.		// generates the right error message.
TEST_F(MixedUpTestSuiteWithSameTestNameTest,		TEST_F(MixedUpTestSuiteWithSameTestNameTest,
TheSecondTestWithThisNameShouldFail) {}		TheSecondTestWithThisNameShouldFail) {}
} // namespace bar		} // namespace bar
// The following two test cases verify that Google Test catches the user		// The following two test cases verify that Google Test catches the user
// error of mixing TEST and TEST_F in the same test case. The first		// error of mixing TEST and TEST_F in the same test case. The first
// test case checks the scenario where TEST_F appears before TEST, and		// test case checks the scenario where TEST_F appears before TEST, and
// the second one checks where TEST appears before TEST_F.		// the second one checks where TEST appears before TEST_F.
class TEST_F_before_TEST_in_same_test_case : public testing::Test {		class TEST_F_before_TEST_in_same_test_case : public testing::Test {};
};
TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}		TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {}
// Expected to fail. We rely on the golden file to check that Google Test		// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.		// generates the right error message.
TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}		TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}
class TEST_before_TEST_F_in_same_test_case : public testing::Test {		class TEST_before_TEST_F_in_same_test_case : public testing::Test {};
};
TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}		TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}
// Expected to fail. We rely on the golden file to check that Google Test		// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.		// generates the right error message.
TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {		TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {}
}
// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().		// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
int global_integer = 0;		int global_integer = 0;
// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.		// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {		TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
global_integer = 0;		global_integer = 0;
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE(
EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";		{ EXPECT_EQ(1, global_integer) << "Expected non-fatal failure."; },
}, "Expected non-fatal failure.");		"Expected non-fatal failure.");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables		// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
// (static or not).		// (static or not).
TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {		TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {
int m = 0;		int m = 0;
static int n;		static int n;
n = 1;		n = 1;
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({ EXPECT_EQ(m, n) << "Expected non-fatal failure."; },
EXPECT_EQ(m, n) << "Expected non-fatal failure.";		"Expected non-fatal failure.");
}, "Expected non-fatal failure.");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly		// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
// one non-fatal failure and no fatal failure.		// one non-fatal failure and no fatal failure.
TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {		TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({ ADD_FAILURE() << "Expected non-fatal failure."; },
ADD_FAILURE() << "Expected non-fatal failure.";		"Expected non-fatal failure.");
}, "Expected non-fatal failure.");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no		// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
// non-fatal failure.		// non-fatal failure.
TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {		TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({}, "");
}, "");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two		// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
// non-fatal failures.		// non-fatal failures.
TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {		TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE(
ADD_FAILURE() << "Expected non-fatal failure 1.";		{
ADD_FAILURE() << "Expected non-fatal failure 2.";		ADD_FAILURE() << "Expected non-fatal failure 1.";
}, "");		ADD_FAILURE() << "Expected non-fatal failure 2.";
		},
		"");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal		// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
// failure.		// failure.
TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {		TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({ FAIL() << "Expected fatal failure."; }, "");
FAIL() << "Expected fatal failure.";
}, "");
}		}
// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being		// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
// tested returns.		// tested returns.
TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {		TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({ return; }, "");
return;
}, "");
}		}
#if GTEST_HAS_EXCEPTIONS		#if GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being		// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
// tested throws.		// tested throws.
TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {		TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
try {		try {
EXPECT_NONFATAL_FAILURE({		EXPECT_NONFATAL_FAILURE({ throw 0; }, "");
throw 0;		} catch (int) { // NOLINT
}, "");
} catch(int) { // NOLINT
}		}
}		}
#endif // GTEST_HAS_EXCEPTIONS		#endif // GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_FATAL_FAILURE() can reference global variables.		// Tests that EXPECT_FATAL_FAILURE() can reference global variables.
TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {		TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {
global_integer = 0;		global_integer = 0;
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE(
ASSERT_EQ(1, global_integer) << "Expected fatal failure.";		{ ASSERT_EQ(1, global_integer) << "Expected fatal failure."; },
}, "Expected fatal failure.");		"Expected fatal failure.");
}		}
// Tests that EXPECT_FATAL_FAILURE() can reference local static		// Tests that EXPECT_FATAL_FAILURE() can reference local static
// variables.		// variables.
TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {		TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {
static int n;		static int n;
n = 1;		n = 1;
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({ ASSERT_EQ(0, n) << "Expected fatal failure."; },
ASSERT_EQ(0, n) << "Expected fatal failure.";		"Expected fatal failure.");
}, "Expected fatal failure.");
}		}
// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly		// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
// one fatal failure and no non-fatal failure.		// one fatal failure and no non-fatal failure.
TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {		TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({ FAIL() << "Expected fatal failure."; },
FAIL() << "Expected fatal failure.";		"Expected fatal failure.");
}, "Expected fatal failure.");
}		}
// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal		// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
// failure.		// failure.
TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {		TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({}, "");
}, "");
}		}
// A helper for generating a fatal failure.		// A helper for generating a fatal failure.
void FatalFailure() {		void FatalFailure() { FAIL() << "Expected fatal failure."; }
FAIL() << "Expected fatal failure.";
}
// Tests that EXPECT_FATAL_FAILURE() fails when there are two		// Tests that EXPECT_FATAL_FAILURE() fails when there are two
// fatal failures.		// fatal failures.
TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {		TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE(
FatalFailure();		{
FatalFailure();		FatalFailure();
}, "");		FatalFailure();
		},
		"");
}		}
// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal		// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
// failure.		// failure.
TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {		TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({ ADD_FAILURE() << "Expected non-fatal failure."; }, "");
ADD_FAILURE() << "Expected non-fatal failure.";
}, "");
}		}
// Tests that EXPECT_FATAL_FAILURE() fails when the statement being		// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
// tested returns.		// tested returns.
TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {		TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({ return; }, "");
return;
}, "");
}		}
#if GTEST_HAS_EXCEPTIONS		#if GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_FATAL_FAILURE() fails when the statement being		// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
// tested throws.		// tested throws.
TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {		TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {
printf("(expecting a failure)\n");		printf("(expecting a failure)\n");
try {		try {
EXPECT_FATAL_FAILURE({		EXPECT_FATAL_FAILURE({ throw 0; }, "");
throw 0;		} catch (int) { // NOLINT
}, "");
} catch(int) { // NOLINT
}		}
}		}
#endif // GTEST_HAS_EXCEPTIONS		#endif // GTEST_HAS_EXCEPTIONS
// This #ifdef block tests the output of value-parameterized tests.		// This #ifdef block tests the output of value-parameterized tests.
std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {		std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {
return info.param;		return info.param;
}		}
class ParamTest : public testing::TestWithParam<std::string> {		class ParamTest : public testing::TestWithParam<std::string> {};
};
TEST_P(ParamTest, Success) {		TEST_P(ParamTest, Success) { EXPECT_EQ("a", GetParam()); }
EXPECT_EQ("a", GetParam());
}
TEST_P(ParamTest, Failure) {		TEST_P(ParamTest, Failure) { EXPECT_EQ("b", GetParam()) << "Expected failure"; }
EXPECT_EQ("b", GetParam()) << "Expected failure";
}
INSTANTIATE_TEST_SUITE_P(PrintingStrings,		INSTANTIATE_TEST_SUITE_P(PrintingStrings, ParamTest,
ParamTest,		testing::Values(std::string("a")), ParamNameFunc);
testing::Values(std::string("a")),
ParamNameFunc);
// The case where a suite has INSTANTIATE_TEST_SUITE_P but not TEST_P.		// The case where a suite has INSTANTIATE_TEST_SUITE_P but not TEST_P.
using NoTests = ParamTest;		using NoTests = ParamTest;
INSTANTIATE_TEST_SUITE_P(ThisIsOdd, NoTests, ::testing::Values("Hello"));		INSTANTIATE_TEST_SUITE_P(ThisIsOdd, NoTests, ::testing::Values("Hello"));
// fails under kErrorOnUninstantiatedParameterizedTest=true		// fails under kErrorOnUninstantiatedParameterizedTest=true
class DetectNotInstantiatedTest : public testing::TestWithParam<int> {};		class DetectNotInstantiatedTest : public testing::TestWithParam<int> {};
TEST_P(DetectNotInstantiatedTest, Used) { }		TEST_P(DetectNotInstantiatedTest, Used) {}
// This would make the test failure from the above go away.		// This would make the test failure from the above go away.
// INSTANTIATE_TEST_SUITE_P(Fix, DetectNotInstantiatedTest, testing::Values(1));		// INSTANTIATE_TEST_SUITE_P(Fix, DetectNotInstantiatedTest, testing::Values(1));
template <typename T>		template <typename T>
class TypedTest : public testing::Test {		class TypedTest : public testing::Test {};
};
TYPED_TEST_SUITE(TypedTest, testing::Types<int>);		TYPED_TEST_SUITE(TypedTest, testing::Types<int>);
TYPED_TEST(TypedTest, Success) {		TYPED_TEST(TypedTest, Success) { EXPECT_EQ(0, TypeParam()); }
EXPECT_EQ(0, TypeParam());
}
TYPED_TEST(TypedTest, Failure) {		TYPED_TEST(TypedTest, Failure) {
EXPECT_EQ(1, TypeParam()) << "Expected failure";		EXPECT_EQ(1, TypeParam()) << "Expected failure";
}		}
typedef testing::Types<char, int> TypesForTestWithNames;		typedef testing::Types<char, int> TypesForTestWithNames;
template <typename T>		template <typename T>
class TypedTestWithNames : public testing::Test {};		class TypedTestWithNames : public testing::Test {};
skipping to change at line 784		skipping to change at line 732
}		}
};		};
TYPED_TEST_SUITE(TypedTestWithNames, TypesForTestWithNames, TypedTestNames);		TYPED_TEST_SUITE(TypedTestWithNames, TypesForTestWithNames, TypedTestNames);
TYPED_TEST(TypedTestWithNames, Success) {}		TYPED_TEST(TypedTestWithNames, Success) {}
TYPED_TEST(TypedTestWithNames, Failure) { FAIL(); }		TYPED_TEST(TypedTestWithNames, Failure) { FAIL(); }
template <typename T>		template <typename T>
class TypedTestP : public testing::Test {		class TypedTestP : public testing::Test {};
};
TYPED_TEST_SUITE_P(TypedTestP);		TYPED_TEST_SUITE_P(TypedTestP);
TYPED_TEST_P(TypedTestP, Success) {		TYPED_TEST_P(TypedTestP, Success) { EXPECT_EQ(0U, TypeParam()); }
EXPECT_EQ(0U, TypeParam());
}
TYPED_TEST_P(TypedTestP, Failure) {		TYPED_TEST_P(TypedTestP, Failure) {
EXPECT_EQ(1U, TypeParam()) << "Expected failure";		EXPECT_EQ(1U, TypeParam()) << "Expected failure";
}		}
REGISTER_TYPED_TEST_SUITE_P(TypedTestP, Success, Failure);		REGISTER_TYPED_TEST_SUITE_P(TypedTestP, Success, Failure);
typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;		typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(Unsigned, TypedTestP, UnsignedTypes);		INSTANTIATE_TYPED_TEST_SUITE_P(Unsigned, TypedTestP, UnsignedTypes);
skipping to change at line 816		skipping to change at line 761
if (std::is_same<T, unsigned char>::value) {		if (std::is_same<T, unsigned char>::value) {
return std::string("unsignedChar") + ::testing::PrintToString(i);		return std::string("unsignedChar") + ::testing::PrintToString(i);
}		}
if (std::is_same<T, unsigned int>::value) {		if (std::is_same<T, unsigned int>::value) {
return std::string("unsignedInt") + ::testing::PrintToString(i);		return std::string("unsignedInt") + ::testing::PrintToString(i);
}		}
}		}
};		};
INSTANTIATE_TYPED_TEST_SUITE_P(UnsignedCustomName, TypedTestP, UnsignedTypes,		INSTANTIATE_TYPED_TEST_SUITE_P(UnsignedCustomName, TypedTestP, UnsignedTypes,
TypedTestPNames);		TypedTestPNames);
template <typename T>		template <typename T>
class DetectNotInstantiatedTypesTest : public testing::Test {};		class DetectNotInstantiatedTypesTest : public testing::Test {};
TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest);		TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest);
TYPED_TEST_P(DetectNotInstantiatedTypesTest, Used) {		TYPED_TEST_P(DetectNotInstantiatedTypesTest, Used) {
TypeParam instantiate;		TypeParam instantiate;
(void)instantiate;		(void)instantiate;
}		}
REGISTER_TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest, Used);		REGISTER_TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest, Used);
skipping to change at line 838		skipping to change at line 783
// Adding the following would make that test failure go away.		// Adding the following would make that test failure go away.
//		//
// typedef ::testing::Types<char, int, unsigned int> MyTypes;		// typedef ::testing::Types<char, int, unsigned int> MyTypes;
// INSTANTIATE_TYPED_TEST_SUITE_P(All, DetectNotInstantiatedTypesTest, MyTypes);		// INSTANTIATE_TYPED_TEST_SUITE_P(All, DetectNotInstantiatedTypesTest, MyTypes);
#if GTEST_HAS_DEATH_TEST		#if GTEST_HAS_DEATH_TEST
// We rely on the golden file to verify that tests whose test case		// We rely on the golden file to verify that tests whose test case
// name ends with DeathTest are run first.		// name ends with DeathTest are run first.
TEST(ADeathTest, ShouldRunFirst) {		TEST(ADeathTest, ShouldRunFirst) {}
}
// We rely on the golden file to verify that typed tests whose test		// We rely on the golden file to verify that typed tests whose test
// case name ends with DeathTest are run first.		// case name ends with DeathTest are run first.
template <typename T>		template <typename T>
class ATypedDeathTest : public testing::Test {		class ATypedDeathTest : public testing::Test {};
};
typedef testing::Types<int, double> NumericTypes;		typedef testing::Types<int, double> NumericTypes;
TYPED_TEST_SUITE(ATypedDeathTest, NumericTypes);		TYPED_TEST_SUITE(ATypedDeathTest, NumericTypes);
TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {		TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {}
}
// We rely on the golden file to verify that type-parameterized tests		// We rely on the golden file to verify that type-parameterized tests
// whose test case name ends with DeathTest are run first.		// whose test case name ends with DeathTest are run first.
template <typename T>		template <typename T>
class ATypeParamDeathTest : public testing::Test {		class ATypeParamDeathTest : public testing::Test {};
};
TYPED_TEST_SUITE_P(ATypeParamDeathTest);		TYPED_TEST_SUITE_P(ATypeParamDeathTest);
TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {		TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {}
}
REGISTER_TYPED_TEST_SUITE_P(ATypeParamDeathTest, ShouldRunFirst);		REGISTER_TYPED_TEST_SUITE_P(ATypeParamDeathTest, ShouldRunFirst);
INSTANTIATE_TYPED_TEST_SUITE_P(My, ATypeParamDeathTest, NumericTypes);		INSTANTIATE_TYPED_TEST_SUITE_P(My, ATypeParamDeathTest, NumericTypes);
#endif // GTEST_HAS_DEATH_TEST		#endif // GTEST_HAS_DEATH_TEST
// Tests various failure conditions of		// Tests various failure conditions of
// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.		// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
class ExpectFailureTest : public testing::Test {		class ExpectFailureTest : public testing::Test {
public: // Must be public and not protected due to a bug in g++ 3.4.2.		public: // Must be public and not protected due to a bug in g++ 3.4.2.
enum FailureMode {		enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE };
FATAL_FAILURE,
NONFATAL_FAILURE
};
static void AddFailure(FailureMode failure) {		static void AddFailure(FailureMode failure) {
if (failure == FATAL_FAILURE) {		if (failure == FATAL_FAILURE) {
FAIL() << "Expected fatal failure.";		FAIL() << "Expected fatal failure.";
} else {		} else {
ADD_FAILURE() << "Expected non-fatal failure.";		ADD_FAILURE() << "Expected non-fatal failure.";
}		}
}		}
};		};
TEST_F(ExpectFailureTest, ExpectFatalFailure) {		TEST_F(ExpectFailureTest, ExpectFatalFailure) {
// Expected fatal failure, but succeeds.		// Expected fatal failure, but succeeds.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");		EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
// Expected fatal failure, but got a non-fatal failure.		// Expected fatal failure, but got a non-fatal failure.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "		EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE),
		"Expected non-fatal "
"failure.");		"failure.");
// Wrong message.		// Wrong message.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "		EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE),
		"Some other fatal failure "
"expected.");		"expected.");
}		}
TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {		TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
// Expected non-fatal failure, but succeeds.		// Expected non-fatal failure, but succeeds.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");		EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
// Expected non-fatal failure, but got a fatal failure.		// Expected non-fatal failure, but got a fatal failure.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");		EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
// Wrong message.		// Wrong message.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "		EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE),
		"Some other non-fatal "
"failure.");		"failure.");
}		}
#if GTEST_IS_THREADSAFE		#if GTEST_IS_THREADSAFE
class ExpectFailureWithThreadsTest : public ExpectFailureTest {		class ExpectFailureWithThreadsTest : public ExpectFailureTest {
protected:		protected:
static void AddFailureInOtherThread(FailureMode failure) {		static void AddFailureInOtherThread(FailureMode failure) {
ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);		ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);
thread.Join();		thread.Join();
skipping to change at line 977		skipping to change at line 917
"Expected non-fatal failure.");		"Expected non-fatal failure.");
// Wrong message.		// Wrong message.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),		EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
"Some other fatal failure expected.");		"Some other fatal failure expected.");
}		}
TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {		TEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) {
// Expected non-fatal failure, but succeeds.		// Expected non-fatal failure, but succeeds.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "		EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(),
		"Expected non-fatal "
"failure.");		"failure.");
// Expected non-fatal failure, but got a fatal failure.		// Expected non-fatal failure, but got a fatal failure.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),		EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
"Expected fatal failure.");		"Expected fatal failure.");
// Wrong message.		// Wrong message.
printf("(expecting 1 failure)\n");		printf("(expecting 1 failure)\n");
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),		EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
"Some other non-fatal failure.");		"Some other non-fatal failure.");
}		}
skipping to change at line 1062		skipping to change at line 1003
class BarEnvironment : public testing::Environment {		class BarEnvironment : public testing::Environment {
public:		public:
void SetUp() override { printf("%s", "BarEnvironment::SetUp() called.\n"); }		void SetUp() override { printf("%s", "BarEnvironment::SetUp() called.\n"); }
void TearDown() override {		void TearDown() override {
printf("%s", "BarEnvironment::TearDown() called.\n");		printf("%s", "BarEnvironment::TearDown() called.\n");
ADD_FAILURE() << "Expected non-fatal failure.";		ADD_FAILURE() << "Expected non-fatal failure.";
}		}
};		};
		class TestSuiteThatFailsToSetUp : public testing::Test {
		public:
		static void SetUpTestSuite() { EXPECT_TRUE(false); }
		};
		TEST_F(TestSuiteThatFailsToSetUp, ShouldNotRun) { std::abort(); }
// The main function.		// The main function.
//		//
// The idea is to use Google Test to run all the tests we have defined (some		// The idea is to use Google Test to run all the tests we have defined (some
// of them are intended to fail), and then compare the test results		// of them are intended to fail), and then compare the test results
// with the "golden" file.		// with the "golden" file.
int main(int argc, char **argv) {		int main(int argc, char** argv) {
testing::GTEST_FLAG(print_time) = false;		GTEST_FLAG_SET(print_time, false);
// We just run the tests, knowing some of them are intended to fail.		// We just run the tests, knowing some of them are intended to fail.
// We will use a separate Python script to compare the output of		// We will use a separate Python script to compare the output of
// this program with the golden file.		// this program with the golden file.
// It's hard to test InitGoogleTest() directly, as it has many		// It's hard to test InitGoogleTest() directly, as it has many
// global side effects. The following line serves as a sanity test		// global side effects. The following line serves as a test
// for it.		// for it.
testing::InitGoogleTest(&argc, argv);		testing::InitGoogleTest(&argc, argv);
bool internal_skip_environment_and_ad_hoc_tests =		bool internal_skip_environment_and_ad_hoc_tests =
std::count(argv, argv + argc,		std::count(argv, argv + argc,
std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;		std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
#if GTEST_HAS_DEATH_TEST		#if GTEST_HAS_DEATH_TEST
if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {		if (GTEST_FLAG_GET(internal_run_death_test) != "") {
// Skip the usual output capturing if we're running as the child		// Skip the usual output capturing if we're running as the child
// process of an threadsafe-style death test.		// process of an threadsafe-style death test.
# if GTEST_OS_WINDOWS		#if GTEST_OS_WINDOWS
posix::FReopen("nul:", "w", stdout);		posix::FReopen("nul:", "w", stdout);
# else		#else
posix::FReopen("/dev/null", "w", stdout);		posix::FReopen("/dev/null", "w", stdout);
# endif // GTEST_OS_WINDOWS		#endif // GTEST_OS_WINDOWS
return RUN_ALL_TESTS();		return RUN_ALL_TESTS();
}		}
#endif // GTEST_HAS_DEATH_TEST		#endif // GTEST_HAS_DEATH_TEST
if (internal_skip_environment_and_ad_hoc_tests)		if (internal_skip_environment_and_ad_hoc_tests) return RUN_ALL_TESTS();
return RUN_ALL_TESTS();
// Registers two global test environments.		// Registers two global test environments.
// The golden file verifies that they are set up in the order they		// The golden file verifies that they are set up in the order they
// are registered, and torn down in the reverse order.		// are registered, and torn down in the reverse order.
testing::AddGlobalTestEnvironment(new FooEnvironment);		testing::AddGlobalTestEnvironment(new FooEnvironment);
testing::AddGlobalTestEnvironment(new BarEnvironment);		testing::AddGlobalTestEnvironment(new BarEnvironment);
#if _MSC_VER		#if _MSC_VER
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4127		GTEST_DISABLE_MSC_WARNINGS_POP_() // 4127
#endif // _MSC_VER		#endif // _MSC_VER
return RunAllTests();		return RunAllTests();
}		}
End of changes. 70 change blocks.
156 lines changed or deleted		102 lines changed or added

---