gtest_output_test_.cc File Reference

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

Include dependency graph for gtest_output_test_.cc:

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	ParamTest
class	ExpectFailureTest
class	FooEnvironment
class	BarEnvironment

Namespaces
namespace	foo
namespace	bar

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, AcceptedValues)
	TEST (SCOPED_TRACETest, ObeysScopes)
	TEST (SCOPED_TRACETest, WorksInLoop)
	TEST (SCOPED_TRACETest, WorksInSubroutine)
	TEST (SCOPED_TRACETest, CanBeNested)
	TEST (SCOPED_TRACETest, CanBeRepeated)
	TEST (ScopedTraceTest, WithExplicitFileAndLine)
	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)
std::string	ParamNameFunc (const testing::TestParamInfo< std::string > &info)
	TEST_P (ParamTest, Success)
	TEST_P (ParamTest, Failure)
	INSTANTIATE_TEST_CASE_P (PrintingStrings, ParamTest, testing::Values(std::string("a")), ParamNameFunc)
	TEST_F (ExpectFailureTest, ExpectFatalFailure)
	TEST_F (ExpectFailureTest, ExpectNonFatalFailure)
	TEST_F (ExpectFailureTest, ExpectFatalFailureOnAllThreads)
	TEST_F (ExpectFailureTest, ExpectNonFatalFailureOnAllThreads)
int	main (int argc, char **argv)

Variables
int	global_integer = 0

Function Documentation

AdHocTest()

void AdHocTest

(

)

Definition at line 346 of file gtest_output_test_.cc.

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

Here is the caller graph for this function:

FatalFailure()

void FatalFailure

(

)

Definition at line 719 of file gtest_output_test_.cc.

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

Here is the caller graph for this function:

INSTANTIATE_TEST_CASE_P() [1/2]

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

INSTANTIATE_TEST_CASE_P() [2/2]

INSTANTIATE_TEST_CASE_P	(	PrintingStrings	,
		ParamTest	,
		testing::Values(std::string("a"))	,
		ParamNameFunc	)

main()

int main	(	int	argc,
		char **	argv )

Definition at line 1029 of file gtest_output_test_.cc.

                                {
  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();
}

Here is the call graph for this function:

ParamNameFunc()

std::string ParamNameFunc

(

const testing::TestParamInfo< std::string > &

info

)

Definition at line 769 of file gtest_output_test_.cc.

                                                                     {
  return info.param;
}

RunAllTests()

int RunAllTests

(

)

Definition at line 353 of file gtest_output_test_.cc.

                  {
  AdHocTest();
  return RUN_ALL_TESTS();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SubWithoutTrace()

void SubWithoutTrace

(

int

n

)

Definition at line 159 of file gtest_output_test_.cc.

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

Here is the caller graph for this function:

SubWithTrace()

void SubWithTrace

(

int

n

)

Definition at line 165 of file gtest_output_test_.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

TEST() [1/33]

TEST	(	AddFailureAtTest	,
		MessageContainsSpecifiedFileAndLineNumber	)

Definition at line 470 of file gtest_output_test_.cc.

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

TEST() [2/33]

TEST	(	DisabledTestsWarningTest	,
		DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning	)

Definition at line 335 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() [3/33]

TEST	(	ExpectFatalFailureTest	,
		CanReferenceGlobalVariables	)

Definition at line 685 of file gtest_output_test_.cc.

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

TEST() [4/33]

TEST	(	ExpectFatalFailureTest	,
		CanReferenceLocalStaticVariables	)

Definition at line 694 of file gtest_output_test_.cc.

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

TEST() [5/33]

TEST	(	ExpectFatalFailureTest	,
		FailsWhenStatementReturns	)

Definition at line 744 of file gtest_output_test_.cc.

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

TEST() [6/33]

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereAreTwoFatalFailures	)

Definition at line 725 of file gtest_output_test_.cc.

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

Here is the call graph for this function:

TEST() [7/33]

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereIsNoFatalFailure	)

Definition at line 712 of file gtest_output_test_.cc.

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

TEST() [8/33]

TEST	(	ExpectFatalFailureTest	,
		FailsWhenThereIsOneNonfatalFailure	)

Definition at line 735 of file gtest_output_test_.cc.

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

TEST() [9/33]

TEST	(	ExpectFatalFailureTest	,
		SucceedsWhenThereIsOneFatalFailure	)

Definition at line 704 of file gtest_output_test_.cc.

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

TEST() [10/33]

TEST	(	ExpectNonfatalFailureTest	,
		CanReferenceGlobalVariables	)

Definition at line 606 of file gtest_output_test_.cc.

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

TEST() [11/33]

TEST	(	ExpectNonfatalFailureTest	,
		CanReferenceLocalVariables	)

Definition at line 615 of file gtest_output_test_.cc.

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

TEST() [12/33]

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenStatementReturns	)

Definition at line 661 of file gtest_output_test_.cc.

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

TEST() [13/33]

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereAreTwoNonfatalFailures	)

Definition at line 642 of file gtest_output_test_.cc.

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

TEST() [14/33]

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereIsNoNonfatalFailure	)

Definition at line 634 of file gtest_output_test_.cc.

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

TEST() [15/33]

TEST	(	ExpectNonfatalFailureTest	,
		FailsWhenThereIsOneFatalFailure	)

Definition at line 652 of file gtest_output_test_.cc.

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

TEST() [16/33]

TEST	(	ExpectNonfatalFailureTest	,
		SucceedsWhenThereIsOneNonfatalFailure	)

Definition at line 626 of file gtest_output_test_.cc.

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

TEST() [17/33]

TEST	(	FatalFailureTest	,
		FatalFailureInNestedSubroutine	)

Definition at line 120 of file gtest_output_test_.cc.

                                                       {
  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.";
}

Here is the call graph for this function:

TEST() [18/33]

TEST	(	FatalFailureTest	,
		FatalFailureInSubroutine	)

Definition at line 113 of file gtest_output_test_.cc.

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

Here is the call graph for this function:

TEST() [19/33]

TEST	(	FatalFailureTest	,
		NonfatalFailureInSubroutine	)

Definition at line 137 of file gtest_output_test_.cc.

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

TEST() [20/33]

TEST	(	LoggingTest	,
		InterleavingLoggingAndAssertions	)

Definition at line 144 of file gtest_output_test_.cc.

                                                    {
  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() [21/33]

TEST	(	NonfatalFailureTest	,
		DiffForLongStrings	)

Definition at line 107 of file gtest_output_test_.cc.

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

TEST() [22/33]

TEST	(	NonfatalFailureTest	,
		EscapesStringOperands	)

Definition at line 99 of file gtest_output_test_.cc.

                                                 {
  std::string actual = "actual \"string\"";
  EXPECT_EQ(kGoldenString, actual);
 
  const char* golden = kGoldenString;
  EXPECT_EQ(golden, actual);
}

TEST() [23/33]

TEST	(	PassingTest	,
		PassingTest1	)

Definition at line 77 of file gtest_output_test_.cc.

                                {
}

TEST() [24/33]

TEST	(	PassingTest	,
		PassingTest2	)

Definition at line 80 of file gtest_output_test_.cc.

                                {
}

TEST() [25/33]

TEST	(	SCOPED_TRACETest	,
		AcceptedValues	)

Definition at line 171 of file gtest_output_test_.cc.

                                       {
  SCOPED_TRACE("literal string");
  SCOPED_TRACE(std::string("std::string"));
  SCOPED_TRACE(1337);  // streamable type
  const char* null_value = NULL;
  SCOPED_TRACE(null_value);
 
  ADD_FAILURE() << "Just checking that all these values work fine.";
}

TEST() [26/33]

TEST	(	SCOPED_TRACETest	,
		CanBeNested	)

Definition at line 220 of file gtest_output_test_.cc.

                                    {
  printf("(expected to fail)\n");
 
  SCOPED_TRACE("");  // A trace without a message.
 
  SubWithTrace(2);
}

Here is the call graph for this function:

TEST() [27/33]

TEST	(	SCOPED_TRACETest	,
		CanBeRepeated	)

Definition at line 229 of file gtest_output_test_.cc.

                                      {
  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() [28/33]

TEST	(	SCOPED_TRACETest	,
		ObeysScopes	)

Definition at line 182 of file gtest_output_test_.cc.

                                    {
  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() [29/33]

TEST	(	SCOPED_TRACETest	,
		WorksInLoop	)

Definition at line 201 of file gtest_output_test_.cc.

                                    {
  printf("(expected to fail)\n");
 
  for (int i = 1; i <= 2; i++) {
    SCOPED_TRACE(testing::Message() << "i = " << i);
 
    SubWithoutTrace(i);
  }
}

Here is the call graph for this function:

TEST() [30/33]

TEST	(	SCOPED_TRACETest	,
		WorksInSubroutine	)

Definition at line 212 of file gtest_output_test_.cc.

                                          {
  printf("(expected to fail)\n");
 
  SubWithTrace(1);
  SubWithTrace(2);
}

Here is the call graph for this function:

TEST() [31/33]

TEST	(	ScopedTraceTest	,
		WithExplicitFileAndLine	)

Definition at line 330 of file gtest_output_test_.cc.

                                               {
  testing::ScopedTrace trace("explicit_file.cc", 123, "expected trace message");
  ADD_FAILURE() << "Check that the trace is attached to a particular location.";
}

TEST() [32/33]

TEST	(	TEST_before_TEST_F_in_same_test_case	,
		DefinedUsingTEST	)

Definition at line 595 of file gtest_output_test_.cc.

{}

TEST() [33/33]

TEST	(	TEST_F_before_TEST_in_same_test_case	,
		DefinedUsingTESTAndShouldFail	)

Definition at line 590 of file gtest_output_test_.cc.

{}

TEST_F() [1/10]

TEST_F	(	ExpectFailureTest	,
		ExpectFatalFailure	)

Definition at line 897 of file gtest_output_test_.cc.

                                              {
  // 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() [2/10]

TEST_F	(	ExpectFailureTest	,
		ExpectFatalFailureOnAllThreads	)

Definition at line 968 of file gtest_output_test_.cc.

                                                          {
  // 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() [3/10]

TEST_F	(	ExpectFailureTest	,
		ExpectNonFatalFailure	)

Definition at line 911 of file gtest_output_test_.cc.

                                                 {
  // 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() [4/10]

TEST_F	(	ExpectFailureTest	,
		ExpectNonFatalFailureOnAllThreads	)

Definition at line 982 of file gtest_output_test_.cc.

                                                             {
  // 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_F() [5/10]

TEST_F	(	FatalFailureInFixtureConstructorTest	,
		FailureInConstructor	)

Definition at line 413 of file gtest_output_test_.cc.

                                                                   {
  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() [6/10]

TEST_F	(	FatalFailureInSetUpTest	,
		FailureInSetUp	)

Definition at line 465 of file gtest_output_test_.cc.

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

TEST_F() [7/10]

TEST_F	(	NonFatalFailureInFixtureConstructorTest	,
		FailureInConstructor	)

Definition at line 379 of file gtest_output_test_.cc.

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

TEST_F() [8/10]

TEST_F	(	NonFatalFailureInSetUpTest	,
		FailureInSetUp	)

Definition at line 440 of file gtest_output_test_.cc.

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

TEST_F() [9/10]

TEST_F	(	TEST_before_TEST_F_in_same_test_case	,
		DefinedUsingTEST_FAndShouldFail	)

Definition at line 599 of file gtest_output_test_.cc.

                                                                              {
}

TEST_F() [10/10]

TEST_F	(	TEST_F_before_TEST_in_same_test_case	,
		DefinedUsingTEST_F	)

Definition at line 586 of file gtest_output_test_.cc.

{}

TEST_P() [1/3]

TEST_P	(	FailingParamTest	,
		Fails	)

Definition at line 87 of file gtest_output_test_.cc.

                                {
  EXPECT_EQ(1, GetParam());
}

TEST_P() [2/3]

TEST_P	(	ParamTest	,
		Failure	)

Definition at line 780 of file gtest_output_test_.cc.

                           {
  EXPECT_EQ("b", GetParam()) << "Expected failure";
}

TEST_P() [3/3]

TEST_P	(	ParamTest	,
		Success	)

Definition at line 776 of file gtest_output_test_.cc.

                           {
  EXPECT_EQ("a", GetParam());
}

TestEq1()

void TestEq1

(

int

x

)

Definition at line 57 of file gtest_output_test_.cc.

                    {
  ASSERT_EQ(1, x);
}

Here is the caller graph for this function:

TryTestSubroutine()

void TryTestSubroutine

(

)

Definition at line 63 of file gtest_output_test_.cc.

                         {
  // 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.";
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

global_integer

int global_integer = 0

Definition at line 603 of file gtest_output_test_.cc.