gtest_output_test_.cc File Reference

#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"
#include "src/gtest-internal-inl.h"
#include <stdlib.h>

Go to the source code of this file.

Classes
class	FailingParamTest
class	NonFatalFailureInFixtureConstructorTest
class	FatalFailureInFixtureConstructorTest
class	NonFatalFailureInSetUpTest
class	FatalFailureInSetUpTest
class	foo::MixedUpTestCaseTest
class	foo::MixedUpTestCaseWithSameTestNameTest
class	bar::MixedUpTestCaseTest
class	bar::MixedUpTestCaseWithSameTestNameTest
class	TEST_F_before_TEST_in_same_test_case
class	TEST_before_TEST_F_in_same_test_case
class	ExpectFailureTest
class	FooEnvironment
class	BarEnvironment

Namespaces
	foo
	bar

Macros
#define	GTEST_IMPLEMENTATION_   1

Functions
void	TestEq1 (int x)
void	TryTestSubroutine ()
	TEST (PassingTest, PassingTest1)
	TEST (PassingTest, PassingTest2)
	TEST_P (FailingParamTest, Fails)
	INSTANTIATE_TEST_CASE_P (PrintingFailingParams, FailingParamTest, testing::Values(2))
	TEST (NonfatalFailureTest, EscapesStringOperands)
	TEST (NonfatalFailureTest, DiffForLongStrings)
	TEST (FatalFailureTest, FatalFailureInSubroutine)
	TEST (FatalFailureTest, FatalFailureInNestedSubroutine)
	TEST (FatalFailureTest, NonfatalFailureInSubroutine)
	TEST (LoggingTest, InterleavingLoggingAndAssertions)
void	SubWithoutTrace (int n)
void	SubWithTrace (int n)
	TEST (SCOPED_TRACETest, ObeysScopes)
	TEST (SCOPED_TRACETest, WorksInLoop)
	TEST (SCOPED_TRACETest, WorksInSubroutine)
	TEST (SCOPED_TRACETest, CanBeNested)
	TEST (SCOPED_TRACETest, CanBeRepeated)
	TEST (DisabledTestsWarningTest, DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning)
void	AdHocTest ()
int	RunAllTests ()
	TEST_F (NonFatalFailureInFixtureConstructorTest, FailureInConstructor)
	TEST_F (FatalFailureInFixtureConstructorTest, FailureInConstructor)
	TEST_F (NonFatalFailureInSetUpTest, FailureInSetUp)
	TEST_F (FatalFailureInSetUpTest, FailureInSetUp)
	TEST (AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber)
	foo::TEST_F (MixedUpTestCaseTest, FirstTestFromNamespaceFoo)
	foo::TEST_F (MixedUpTestCaseTest, SecondTestFromNamespaceFoo)
	foo::TEST_F (MixedUpTestCaseWithSameTestNameTest, TheSecondTestWithThisNameShouldFail)
	bar::TEST_F (MixedUpTestCaseTest, ThisShouldFail)
	bar::TEST_F (MixedUpTestCaseTest, ThisShouldFailToo)
	bar::TEST_F (MixedUpTestCaseWithSameTestNameTest, TheSecondTestWithThisNameShouldFail)
	TEST_F (TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F)
	TEST (TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail)
	TEST (TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST)
	TEST_F (TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail)
	TEST (ExpectNonfatalFailureTest, CanReferenceGlobalVariables)
	TEST (ExpectNonfatalFailureTest, CanReferenceLocalVariables)
	TEST (ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure)
	TEST (ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure)
	TEST (ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures)
	TEST (ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure)
	TEST (ExpectNonfatalFailureTest, FailsWhenStatementReturns)
	TEST (ExpectFatalFailureTest, CanReferenceGlobalVariables)
	TEST (ExpectFatalFailureTest, CanReferenceLocalStaticVariables)
	TEST (ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure)
	TEST (ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure)
void	FatalFailure ()
	TEST (ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures)
	TEST (ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure)
	TEST (ExpectFatalFailureTest, FailsWhenStatementReturns)
	TEST_F (ExpectFailureTest, ExpectFatalFailure)
	TEST_F (ExpectFailureTest, ExpectNonFatalFailure)
	TEST_F (ExpectFailureTest, ExpectFatalFailureOnAllThreads)
	TEST_F (ExpectFailureTest, ExpectNonFatalFailureOnAllThreads)
int	main (int argc, char **argv)

Variables
static const char	kGoldenString [] = "\"Line\0 1\"\nLine 2"
int	global_integer = 0

Macro Definition Documentation

#define GTEST_IMPLEMENTATION_   1

Definition at line 46 of file gtest_output_test_.cc.

Function Documentation

void AdHocTest

(

)

Definition at line 337 of file gtest_output_test_.cc.

References EXPECT_EQ, and EXPECT_TRUE.

                 {
  printf("The non-test part of the code is expected to have 2 failures.\n\n");
  EXPECT_TRUE(false);
  EXPECT_EQ(2, 3);
}

void FatalFailure

(

)

Definition at line 710 of file gtest_output_test_.cc.

References FAIL.

                    {
  FAIL() << "Expected fatal failure.";
}

INSTANTIATE_TEST_CASE_P	(	PrintingFailingParams	,
		FailingParamTest	,
		testing::Values(2)
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 1024 of file gtest_output_test_.cc.

References testing::AddGlobalTestEnvironment(), count, testing::internal::posix::FReopen(), GTEST_FLAG, testing::InitGoogleTest(), RUN_ALL_TESTS(), RunAllTests(), and string.

                                {
  testing::GTEST_FLAG(print_time) = false;

  // 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
  // this program with the golden file.

  // It's hard to test InitGoogleTest() directly, as it has many
  // global side effects.  The following line serves as a sanity test
  // for it.
  testing::InitGoogleTest(&argc, argv);
  bool internal_skip_environment_and_ad_hoc_tests =
      std::count(argv, argv + argc,
                 std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;

#if GTEST_HAS_DEATH_TEST
  if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") {
    // Skip the usual output capturing if we're running as the child
    // process of an threadsafe-style death test.
# if GTEST_OS_WINDOWS
    posix::FReopen("nul:", "w", stdout);
# else
    posix::FReopen("/dev/null", "w", stdout);
# endif  // GTEST_OS_WINDOWS
    return RUN_ALL_TESTS();
  }
#endif  // GTEST_HAS_DEATH_TEST

  if (internal_skip_environment_and_ad_hoc_tests)
    return RUN_ALL_TESTS();

  // Registers two global test environments.
  // The golden file verifies that they are set up in the order they
  // are registered, and torn down in the reverse order.
  testing::AddGlobalTestEnvironment(new FooEnvironment);
  testing::AddGlobalTestEnvironment(new BarEnvironment);

  return RunAllTests();
}

int RunAllTests

(

)

Definition at line 344 of file gtest_output_test_.cc.

References AdHocTest(), and RUN_ALL_TESTS().

                  {
  AdHocTest();
  return RUN_ALL_TESTS();
}

void SubWithoutTrace

(

int

n

)

Definition at line 167 of file gtest_output_test_.cc.

References ASSERT_EQ, and EXPECT_EQ.

                            {
  EXPECT_EQ(1, n);
  ASSERT_EQ(2, n);
}

void SubWithTrace

(

int

n

)

Definition at line 173 of file gtest_output_test_.cc.

References SCOPED_TRACE, and SubWithoutTrace().

                         {
  SCOPED_TRACE(testing::Message() << "n = " << n);

  SubWithoutTrace(n);
}

TEST	(	PassingTest	,
		PassingTest1
	)

Definition at line 85 of file gtest_output_test_.cc.

                                {
}

TEST	(	PassingTest	,
		PassingTest2
	)

Definition at line 88 of file gtest_output_test_.cc.

                                {
}

TEST	(	NonfatalFailureTest	,
		EscapesStringOperands
	)

Definition at line 107 of file gtest_output_test_.cc.

References EXPECT_EQ, kGoldenString, and string.

                                                 {
  std::string actual = "actual \"string\"";
  EXPECT_EQ(kGoldenString, actual);

  const char* golden = kGoldenString;
  EXPECT_EQ(golden, actual);
}

TEST	(	NonfatalFailureTest	,
		DiffForLongStrings
	)

Definition at line 115 of file gtest_output_test_.cc.

References EXPECT_EQ, kGoldenString, and string.

                                              {
  std::string golden_str(kGoldenString, sizeof(kGoldenString) - 1);
  EXPECT_EQ(golden_str, "Line 2");
}

TEST	(	FatalFailureTest	,
		FatalFailureInSubroutine
	)

Definition at line 121 of file gtest_output_test_.cc.

References TryTestSubroutine().

                                                 {
  printf("(expecting a failure that x should be 1)\n");

  TryTestSubroutine();
}

TEST	(	FatalFailureTest	,
		FatalFailureInNestedSubroutine
	)

Definition at line 128 of file gtest_output_test_.cc.

References FAIL, and TryTestSubroutine().

                                                       {
  printf("(expecting a failure that x should be 1)\n");

  // Calls a subrountine that yields a fatal failure.
  TryTestSubroutine();

  // Catches the fatal failure and aborts the test.
  //
  // When calling HasFatalFailure() inside a TEST, TEST_F, or test
  // fixture, the testing::Test:: prefix is not needed.
  if (HasFatalFailure()) return;

  // If we get here, something is wrong.
  FAIL() << "This should never be reached.";
}

TEST	(	FatalFailureTest	,
		NonfatalFailureInSubroutine
	)

Definition at line 145 of file gtest_output_test_.cc.

References ASSERT_FALSE, and EXPECT_TRUE.

                                                    {
  printf("(expecting a failure on false)\n");
  EXPECT_TRUE(false);  // Generates a nonfatal failure
  ASSERT_FALSE(HasFatalFailure());  // This should succeed.
}

TEST	(	LoggingTest	,
		InterleavingLoggingAndAssertions
	)

Definition at line 152 of file gtest_output_test_.cc.

References a, EXPECT_GE, and i.

                                                    {
  static const int a[4] = {
    3, 9, 2, 6
  };

  printf("(expecting 2 failures on (3) >= (a[i]))\n");
  for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) {
    printf("i == %d\n", i);
    EXPECT_GE(3, a[i]);
  }
}

TEST	(	SCOPED_TRACETest	,
		ObeysScopes
	)

Definition at line 180 of file gtest_output_test_.cc.

References ADD_FAILURE, and SCOPED_TRACE.

                                    {
  printf("(expected to fail)\n");

  // There should be no trace before SCOPED_TRACE() is invoked.
  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";

  {
    SCOPED_TRACE("Expected trace");
    // After SCOPED_TRACE(), a failure in the current scope should contain
    // the trace.
    ADD_FAILURE() << "This failure is expected, and should have a trace.";
  }

  // Once the control leaves the scope of the SCOPED_TRACE(), there
  // should be no trace again.
  ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
}

TEST	(	SCOPED_TRACETest	,
		WorksInLoop
	)

Definition at line 199 of file gtest_output_test_.cc.

References i, SCOPED_TRACE, and SubWithoutTrace().

                                    {
  printf("(expected to fail)\n");

  for (int i = 1; i <= 2; i++) {
    SCOPED_TRACE(testing::Message() << "i = " << i);

    SubWithoutTrace(i);
  }
}

TEST	(	SCOPED_TRACETest	,
		WorksInSubroutine
	)

Definition at line 210 of file gtest_output_test_.cc.

References SubWithTrace().

                                          {
  printf("(expected to fail)\n");

  SubWithTrace(1);
  SubWithTrace(2);
}

TEST	(	SCOPED_TRACETest	,
		CanBeNested
	)

Definition at line 218 of file gtest_output_test_.cc.

References SCOPED_TRACE, and SubWithTrace().

                                    {
  printf("(expected to fail)\n");

  SCOPED_TRACE("");  // A trace without a message.

  SubWithTrace(2);
}

TEST	(	SCOPED_TRACETest	,
		CanBeRepeated
	)

Definition at line 227 of file gtest_output_test_.cc.

References ADD_FAILURE, SCOPED_TRACE, and TEST().

                                      {
  printf("(expected to fail)\n");

  SCOPED_TRACE("A");
  ADD_FAILURE()
      << "This failure is expected, and should contain trace point A.";

  SCOPED_TRACE("B");
  ADD_FAILURE()
      << "This failure is expected, and should contain trace point A and B.";

  {
    SCOPED_TRACE("C");
    ADD_FAILURE() << "This failure is expected, and should "
                  << "contain trace point A, B, and C.";
  }

  SCOPED_TRACE("D");
  ADD_FAILURE() << "This failure is expected, and should "
                << "contain trace point A, B, and D.";
}

TEST	(	DisabledTestsWarningTest	,
		DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
	)

Definition at line 326 of file gtest_output_test_.cc.

                                                         {
  // This test body is intentionally empty.  Its sole purpose is for
  // verifying that the --gtest_also_run_disabled_tests flag
  // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
  // the test output.
}

TEST	(	AddFailureAtTest	,
		MessageContainsSpecifiedFileAndLineNumber
	)

Definition at line 461 of file gtest_output_test_.cc.

References ADD_FAILURE_AT, GTEST_CHECK_, GTEST_DISALLOW_COPY_AND_ASSIGN_, and TEST_F().

                                                                  {
  ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
}

TEST	(	TEST_F_before_TEST_in_same_test_case	,
		DefinedUsingTESTAndShouldFail
	)

Definition at line 581 of file gtest_output_test_.cc.

{}

TEST	(	TEST_before_TEST_F_in_same_test_case	,
		DefinedUsingTEST
	)

Definition at line 586 of file gtest_output_test_.cc.

{}

TEST	(	ExpectNonfatalFailureTest	,
		CanReferenceGlobalVariables
	)

Definition at line 597 of file gtest_output_test_.cc.

References EXPECT_EQ, EXPECT_NONFATAL_FAILURE, and global_integer.

                                                             {
  global_integer = 0;
  EXPECT_NONFATAL_FAILURE({
    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";
  }, "Expected non-fatal failure.");
}

TEST	(	ExpectNonfatalFailureTest	,
		CanReferenceLocalVariables
	)

Definition at line 606 of file gtest_output_test_.cc.

References EXPECT_EQ, EXPECT_NONFATAL_FAILURE, and m.

                                                            {
  int m = 0;
  static int n;
  n = 1;
  EXPECT_NONFATAL_FAILURE({
    EXPECT_EQ(m, n) << "Expected non-fatal failure.";
  }, "Expected non-fatal failure.");
}

TEST	(	ExpectNonfatalFailureTest	,
		SucceedsWhenThereIsOneNonfatalFailure
	)

Definition at line 617 of file gtest_output_test_.cc.

References ADD_FAILURE, and EXPECT_NONFATAL_FAILURE.

                                                                       {
  EXPECT_NONFATAL_FAILURE({
    ADD_FAILURE() << "Expected non-fatal failure.";
  }, "Expected non-fatal failure.");
}

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereIsNoNonfatalFailure
	)

Definition at line 625 of file gtest_output_test_.cc.

References EXPECT_NONFATAL_FAILURE.

                                                                   {
  printf("(expecting a failure)\n");
  EXPECT_NONFATAL_FAILURE({
  }, "");
}

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereAreTwoNonfatalFailures
	)

Definition at line 633 of file gtest_output_test_.cc.

References ADD_FAILURE, and EXPECT_NONFATAL_FAILURE.

                                                                      {
  printf("(expecting a failure)\n");
  EXPECT_NONFATAL_FAILURE({
    ADD_FAILURE() << "Expected non-fatal failure 1.";
    ADD_FAILURE() << "Expected non-fatal failure 2.";
  }, "");
}

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereIsOneFatalFailure
	)

Definition at line 643 of file gtest_output_test_.cc.

References EXPECT_NONFATAL_FAILURE, and FAIL.

                                                                 {
  printf("(expecting a failure)\n");
  EXPECT_NONFATAL_FAILURE({
    FAIL() << "Expected fatal failure.";
  }, "");
}

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenStatementReturns
	)

Definition at line 652 of file gtest_output_test_.cc.

References EXPECT_NONFATAL_FAILURE, and TEST().

                                                           {
  printf("(expecting a failure)\n");
  EXPECT_NONFATAL_FAILURE({
    return;
  }, "");
}

TEST	(	ExpectFatalFailureTest	,
		CanReferenceGlobalVariables
	)

Definition at line 676 of file gtest_output_test_.cc.

References ASSERT_EQ, EXPECT_FATAL_FAILURE, and global_integer.

                                                          {
  global_integer = 0;
  EXPECT_FATAL_FAILURE({
    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";
  }, "Expected fatal failure.");
}

TEST	(	ExpectFatalFailureTest	,
		CanReferenceLocalStaticVariables
	)

Definition at line 685 of file gtest_output_test_.cc.

References ASSERT_EQ, and EXPECT_FATAL_FAILURE.

                                                               {
  static int n;
  n = 1;
  EXPECT_FATAL_FAILURE({
    ASSERT_EQ(0, n) << "Expected fatal failure.";
  }, "Expected fatal failure.");
}

TEST	(	ExpectFatalFailureTest	,
		SucceedsWhenThereIsOneFatalFailure
	)

Definition at line 695 of file gtest_output_test_.cc.

References EXPECT_FATAL_FAILURE, and FAIL.

                                                                 {
  EXPECT_FATAL_FAILURE({
    FAIL() << "Expected fatal failure.";
  }, "Expected fatal failure.");
}

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereIsNoFatalFailure
	)

Definition at line 703 of file gtest_output_test_.cc.

References EXPECT_FATAL_FAILURE.

                                                             {
  printf("(expecting a failure)\n");
  EXPECT_FATAL_FAILURE({
  }, "");
}

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereAreTwoFatalFailures
	)

Definition at line 716 of file gtest_output_test_.cc.

References EXPECT_FATAL_FAILURE, and FatalFailure().

                                                                {
  printf("(expecting a failure)\n");
  EXPECT_FATAL_FAILURE({
    FatalFailure();
    FatalFailure();
  }, "");
}

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereIsOneNonfatalFailure
	)

Definition at line 726 of file gtest_output_test_.cc.

References ADD_FAILURE, and EXPECT_FATAL_FAILURE.

                                                                 {
  printf("(expecting a failure)\n");
  EXPECT_FATAL_FAILURE({
    ADD_FAILURE() << "Expected non-fatal failure.";
  }, "");
}

TEST	(	ExpectFatalFailureTest	,
		FailsWhenStatementReturns
	)

Definition at line 735 of file gtest_output_test_.cc.

References EXPECT_EQ, EXPECT_FATAL_FAILURE, deadlock::info(), INSTANTIATE_TEST_CASE_P(), INSTANTIATE_TYPED_TEST_CASE_P(), REGISTER_TYPED_TEST_CASE_P(), string, TEST(), TEST_P(), TYPED_TEST(), TYPED_TEST_CASE(), TYPED_TEST_CASE_P(), and TYPED_TEST_P().

                                                        {
  printf("(expecting a failure)\n");
  EXPECT_FATAL_FAILURE({
    return;
  }, "");
}

TEST_F	(	NonFatalFailureInFixtureConstructorTest	,
		FailureInConstructor
	)

Definition at line 370 of file gtest_output_test_.cc.

References ADD_FAILURE.

                                                                      {
  ADD_FAILURE() << "Expected failure #3, in the test body.";
}

TEST_F	(	FatalFailureInFixtureConstructorTest	,
		FailureInConstructor
	)

Definition at line 404 of file gtest_output_test_.cc.

References ADD_FAILURE.

                                                                   {
  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "
                << "We should never get here, as the test fixture c'tor "
                << "had a fatal failure.";
}

TEST_F	(	NonFatalFailureInSetUpTest	,
		FailureInSetUp
	)

Definition at line 431 of file gtest_output_test_.cc.

References FAIL.

                                                   {
  FAIL() << "Expected failure #2, in the test function.";
}

TEST_F	(	FatalFailureInSetUpTest	,
		FailureInSetUp
	)

Definition at line 456 of file gtest_output_test_.cc.

References FAIL.

                                                {
  FAIL() << "UNEXPECTED failure in the test function.  "
         << "We should never get here, as SetUp() failed.";
}

TEST_F	(	TEST_F_before_TEST_in_same_test_case	,
		DefinedUsingTEST_F
	)

Definition at line 577 of file gtest_output_test_.cc.

{}

TEST_F	(	TEST_before_TEST_F_in_same_test_case	,
		DefinedUsingTEST_FAndShouldFail
	)

Definition at line 590 of file gtest_output_test_.cc.

                                                                              {
}

TEST_F	(	ExpectFailureTest	,
		ExpectFatalFailure
	)

Definition at line 892 of file gtest_output_test_.cc.

References EXPECT_FATAL_FAILURE, and SUCCEED.

                                              {
  // Expected fatal failure, but succeeds.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
  // Expected fatal failure, but got a non-fatal failure.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal "
                       "failure.");
  // Wrong message.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure "
                       "expected.");
}

TEST_F	(	ExpectFailureTest	,
		ExpectNonFatalFailure
	)

Definition at line 906 of file gtest_output_test_.cc.

References EXPECT_EQ, EXPECT_FATAL_FAILURE, EXPECT_NONFATAL_FAILURE, SUCCEED, and TEST_F().

                                                 {
  // Expected non-fatal failure, but succeeds.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
  // Expected non-fatal failure, but got a fatal failure.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure.");
  // Wrong message.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal "
                          "failure.");
}

TEST_F	(	ExpectFailureTest	,
		ExpectFatalFailureOnAllThreads
	)

Definition at line 963 of file gtest_output_test_.cc.

References EXPECT_FATAL_FAILURE_ON_ALL_THREADS, and SUCCEED.

                                                          {
  // Expected fatal failure, but succeeds.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");
  // Expected fatal failure, but got a non-fatal failure.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
                                      "Expected non-fatal failure.");
  // Wrong message.
  printf("(expecting 1 failure)\n");
  EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
                                      "Some other fatal failure expected.");
}

TEST_F	(	ExpectFailureTest	,
		ExpectNonFatalFailureOnAllThreads
	)

Definition at line 977 of file gtest_output_test_.cc.

References EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS, and SUCCEED.

                                                             {
  // Expected non-fatal failure, but succeeds.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
                                         "failure.");
  // Expected non-fatal failure, but got a fatal failure.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE),
                                         "Expected fatal failure.");
  // Wrong message.
  printf("(expecting 1 failure)\n");
  EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE),
                                         "Some other non-fatal failure.");
}

TEST_P	(	FailingParamTest	,
		Fails
	)

Definition at line 95 of file gtest_output_test_.cc.

References EXPECT_EQ, and INSTANTIATE_TEST_CASE_P().

                                {
  EXPECT_EQ(1, GetParam());
}

void TestEq1

(

int

x

)

Definition at line 65 of file gtest_output_test_.cc.

References ASSERT_EQ.

                    {
  ASSERT_EQ(1, x);
}

void TryTestSubroutine

(

)

Definition at line 71 of file gtest_output_test_.cc.

References FAIL, testing::Test::HasFatalFailure(), and TestEq1().

                         {
  // Calls a subrountine that yields a fatal failure.
  TestEq1(2);

  // Catches the fatal failure and aborts the test.
  //
  // The testing::Test:: prefix is necessary when calling
  // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
  if (testing::Test::HasFatalFailure()) return;

  // If we get here, something is wrong.
  FAIL() << "This should never be reached.";
}

Variable Documentation

int global_integer = 0

Definition at line 594 of file gtest_output_test_.cc.

const char kGoldenString[] = "\"Line\0 1\"\nLine 2"

static

Definition at line 105 of file gtest_output_test_.cc.

Referenced by TEST().