// Copyright 2005, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// The purpose of this file is to generate Google Test output under

// various conditions.  The output will then be verified by

// gtest_output_test.py to ensure that Google Test generates the

// desired messages.  Therefore, most tests in this file are MEANT TO

// FAIL.

//

// Author: wan@google.com (Zhanyong Wan)

#include "gtest/gtest-spi.h"

#include "gtest/gtest.h"

// Indicates that this translation unit is part of Google Test's

// implementation.  It must come before gtest-internal-inl.h is

// included, or there will be a compiler error.  This trick is to

// prevent a user from accidentally including gtest-internal-inl.h in

// his code.

#define GTEST_IMPLEMENTATION_ 1

#include "src/gtest-internal-inl.h"

#undef GTEST_IMPLEMENTATION_

#include <stdlib.h>

#if GTEST_IS_THREADSAFE

using testing::ScopedFakeTestPartResultReporter;

using testing::TestPartResultArray;

using testing::internal::Notification;

using testing::internal::ThreadWithParam;

#endif

namespace posix = ::testing::internal::posix;

// Tests catching fatal failures.

// A subroutine used by the following test.

void TestEq1(int x) {

  ASSERT_EQ(1, x);

}

// This function calls a test subroutine, catches the fatal failure it

// generates, and then returns early.

void TryTestSubroutine() {

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

}

TEST(PassingTest, PassingTest1) {

}

TEST(PassingTest, PassingTest2) {

}

// Tests that parameters of failing parameterized tests are printed in the

// failing test summary.

class FailingParamTest : public testing::TestWithParam<int> {};

TEST_P(FailingParamTest, Fails) {

  EXPECT_EQ(1, GetParam());

}

// This generates a test which will fail. Google Test is expected to print

// its parameter when it outputs the list of all failed tests.

INSTANTIATE_TEST_CASE_P(PrintingFailingParams,

                        FailingParamTest,

                        testing::Values(2));

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

TEST(NonfatalFailureTest, EscapesStringOperands) {

  std::string actual = "actual \"string\"";

  EXPECT_EQ(kGoldenString, actual);

  const char* golden = kGoldenString;

  EXPECT_EQ(golden, actual);

}

TEST(NonfatalFailureTest, DiffForLongStrings) {

  std::string golden_str(kGoldenString, sizeof(kGoldenString) - 1);

  EXPECT_EQ(golden_str, "Line 2");

}

// Tests catching a fatal failure in a subroutine.

TEST(FatalFailureTest, FatalFailureInSubroutine) {

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

  TryTestSubroutine();

}

// Tests catching a fatal failure in a nested subroutine.

TEST(FatalFailureTest, FatalFailureInNestedSubroutine) {

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

}

// Tests HasFatalFailure() after a failed EXPECT check.

TEST(FatalFailureTest, NonfatalFailureInSubroutine) {

  printf("(expecting a failure on false)\n");

  EXPECT_TRUE(false);  // Generates a nonfatal failure

  ASSERT_FALSE(HasFatalFailure());  // This should succeed.

}

// Tests interleaving user logging and Google Test assertions.

TEST(LoggingTest, InterleavingLoggingAndAssertions) {

  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]);

  }

}

// Tests the SCOPED_TRACE macro.

// A helper function for testing SCOPED_TRACE.

void SubWithoutTrace(int n) {

  EXPECT_EQ(1, n);

  ASSERT_EQ(2, n);

}

// Another helper function for testing SCOPED_TRACE.

void SubWithTrace(int n) {

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

  SubWithoutTrace(n);

}

// Tests that SCOPED_TRACE() obeys lexical scopes.

TEST(SCOPED_TRACETest, ObeysScopes) {

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

}

// Tests that SCOPED_TRACE works inside a loop.

TEST(SCOPED_TRACETest, WorksInLoop) {

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

  for (int i = 1; i <= 2; i++) {

    SCOPED_TRACE(testing::Message() << "i = " << i);

    SubWithoutTrace(i);

  }

}

// Tests that SCOPED_TRACE works in a subroutine.

TEST(SCOPED_TRACETest, WorksInSubroutine) {

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

  SubWithTrace(1);

  SubWithTrace(2);

}

// Tests that SCOPED_TRACE can be nested.

TEST(SCOPED_TRACETest, CanBeNested) {

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

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

  SubWithTrace(2);

}

// Tests that multiple SCOPED_TRACEs can be used in the same scope.

TEST(SCOPED_TRACETest, CanBeRepeated) {

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

}

#if GTEST_IS_THREADSAFE

// Tests that SCOPED_TRACE()s can be used concurrently from multiple

// threads.  Namely, an assertion should be affected by

// SCOPED_TRACE()s in its own thread only.

// Here's the sequence of actions that happen in the test:

//

//   Thread A (main)                | Thread B (spawned)

//   ===============================|================================

//   spawns thread B                |

//   -------------------------------+--------------------------------

//   waits for n1                   | SCOPED_TRACE("Trace B");

//                                  | generates failure #1

//                                  | notifies n1

//   -------------------------------+--------------------------------

//   SCOPED_TRACE("Trace A");       | waits for n2

//   generates failure #2           |

//   notifies n2                    |

//   -------------------------------|--------------------------------

//   waits for n3                   | generates failure #3

//                                  | trace B dies

//                                  | generates failure #4

//                                  | notifies n3

//   -------------------------------|--------------------------------

//   generates failure #5           | finishes

//   trace A dies                   |

//   generates failure #6           |

//   -------------------------------|--------------------------------

//   waits for thread B to finish   |

struct CheckPoints {

  Notification n1;

  Notification n2;

  Notification n3;

};

static void ThreadWithScopedTrace(CheckPoints* check_points) {

  {

    SCOPED_TRACE("Trace B");

    ADD_FAILURE()

        << "Expected failure #1 (in thread B, only trace B alive).";

    check_points->n1.Notify();

    check_points->n2.WaitForNotification();

    ADD_FAILURE()

        << "Expected failure #3 (in thread B, trace A & B both alive).";

  }  // Trace B dies here.

  ADD_FAILURE()

      << "Expected failure #4 (in thread B, only trace A alive).";

  check_points->n3.Notify();

}

TEST(SCOPED_TRACETest, WorksConcurrently) {

  printf("(expecting 6 failures)\n");

  CheckPoints check_points;

  ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace,

                                       &check_points,

                                       NULL);

  check_points.n1.WaitForNotification();

  {

    SCOPED_TRACE("Trace A");

    ADD_FAILURE()

        << "Expected failure #2 (in thread A, trace A & B both alive).";

    check_points.n2.Notify();

    check_points.n3.WaitForNotification();

    ADD_FAILURE()

        << "Expected failure #5 (in thread A, only trace A alive).";

  }  // Trace A dies here.

  ADD_FAILURE()

      << "Expected failure #6 (in thread A, no trace alive).";

  thread.Join();

}

#endif  // GTEST_IS_THREADSAFE

TEST(DisabledTestsWarningTest,

     DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) {

  // 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.

}

// Tests using assertions outside of TEST and TEST_F.

//

// This function creates two failures intentionally.

void AdHocTest() {

  printf("The non-test part of the code is expected to have 2 failures.\n\n");

  EXPECT_TRUE(false);

  EXPECT_EQ(2, 3);

}

// Runs all TESTs, all TEST_Fs, and the ad hoc test.

int RunAllTests() {

  AdHocTest();

  return RUN_ALL_TESTS();

}

// Tests non-fatal failures in the fixture constructor.

class NonFatalFailureInFixtureConstructorTest : public testing::Test {

 protected:

  NonFatalFailureInFixtureConstructorTest() {

    printf("(expecting 5 failures)\n");

    ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";

  }

  ~NonFatalFailureInFixtureConstructorTest() {

    ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";

  }

  virtual void SetUp() {

    ADD_FAILURE() << "Expected failure #2, in SetUp().";

  }

  virtual void TearDown() {

    ADD_FAILURE() << "Expected failure #4, in TearDown.";

  }

};

TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) {

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

}

// Tests fatal failures in the fixture constructor.

class FatalFailureInFixtureConstructorTest : public testing::Test {

 protected:

  FatalFailureInFixtureConstructorTest() {

    printf("(expecting 2 failures)\n");

    Init();

  }

  ~FatalFailureInFixtureConstructorTest() {

    ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";

  }

  virtual void SetUp() {

    ADD_FAILURE() << "UNEXPECTED failure in SetUp().  "

                  << "We should never get here, as the test fixture c'tor "

                  << "had a fatal failure.";

  }

  virtual void TearDown() {

    ADD_FAILURE() << "UNEXPECTED failure in TearDown().  "

                  << "We should never get here, as the test fixture c'tor "

                  << "had a fatal failure.";

  }

 private:

  void Init() {

    FAIL() << "Expected failure #1, in the test fixture c'tor.";

  }

};

TEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) {

  ADD_FAILURE() << "UNEXPECTED failure in the test body.  "

                << "We should never get here, as the test fixture c'tor "

                << "had a fatal failure.";

}

// Tests non-fatal failures in SetUp().

class NonFatalFailureInSetUpTest : public testing::Test {

 protected:

  virtual ~NonFatalFailureInSetUpTest() {

    Deinit();

  }

  virtual void SetUp() {

    printf("(expecting 4 failures)\n");

    ADD_FAILURE() << "Expected failure #1, in SetUp().";

  }

  virtual void TearDown() {

    FAIL() << "Expected failure #3, in TearDown().";

  }

 private:

  void Deinit() {

    FAIL() << "Expected failure #4, in the test fixture d'tor.";

  }

};

TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) {

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

}

// Tests fatal failures in SetUp().

class FatalFailureInSetUpTest : public testing::Test {

 protected:

  virtual ~FatalFailureInSetUpTest() {

    Deinit();

  }

  virtual void SetUp() {

    printf("(expecting 3 failures)\n");

    FAIL() << "Expected failure #1, in SetUp().";

  }

  virtual void TearDown() {

    FAIL() << "Expected failure #2, in TearDown().";

  }

 private:

  void Deinit() {

    FAIL() << "Expected failure #3, in the test fixture d'tor.";

  }

};

TEST_F(FatalFailureInSetUpTest, FailureInSetUp) {

  FAIL() << "UNEXPECTED failure in the test function.  "

         << "We should never get here, as SetUp() failed.";

}

TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) {

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

}

#if GTEST_IS_THREADSAFE

// A unary function that may die.

void DieIf(bool should_die) {

  GTEST_CHECK_(!should_die) << " - death inside DieIf().";

}

// Tests running death tests in a multi-threaded context.

// Used for coordination between the main and the spawn thread.

struct SpawnThreadNotifications {

  SpawnThreadNotifications() {}

  Notification spawn_thread_started;

  Notification spawn_thread_ok_to_terminate;

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications);

};

// The function to be executed in the thread spawn by the

// MultipleThreads test (below).

static void ThreadRoutine(SpawnThreadNotifications* notifications) {

  // Signals the main thread that this thread has started.

  notifications->spawn_thread_started.Notify();

  // Waits for permission to finish from the main thread.

  notifications->spawn_thread_ok_to_terminate.WaitForNotification();

}

// This is a death-test test, but it's not named with a DeathTest

// suffix.  It starts threads which might interfere with later

// death tests, so it must run after all other death tests.

class DeathTestAndMultiThreadsTest : public testing::Test {

 protected:

  // Starts a thread and waits for it to begin.

  virtual void SetUp() {

    thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(

        &ThreadRoutine, &notifications_, NULL));

    notifications_.spawn_thread_started.WaitForNotification();

  }

  // Tells the thread to finish, and reaps it.

  // Depending on the version of the thread library in use,

  // a manager thread might still be left running that will interfere

  // with later death tests.  This is unfortunate, but this class

  // cleans up after itself as best it can.

  virtual void TearDown() {

    notifications_.spawn_thread_ok_to_terminate.Notify();

  }

 private:

  SpawnThreadNotifications notifications_;

  testing::internal::scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> >

      thread_;

};

#endif  // GTEST_IS_THREADSAFE

// The MixedUpTestCaseTest test case verifies that Google Test will fail a

// test if it uses a different fixture class than what other tests in

// the same test case use.  It deliberately contains two fixture

// classes with the same name but defined in different namespaces.

// The MixedUpTestCaseWithSameTestNameTest test case verifies that

// when the user defines two tests with the same test case name AND

// same test name (but in different namespaces), the second test will

// fail.

namespace foo {

class MixedUpTestCaseTest : public testing::Test {

};

TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}

TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}

class MixedUpTestCaseWithSameTestNameTest : public testing::Test {

};

TEST_F(MixedUpTestCaseWithSameTestNameTest,

       TheSecondTestWithThisNameShouldFail) {}

}  // namespace foo

namespace bar {

class MixedUpTestCaseTest : public testing::Test {

};

// The following two tests are expected to fail.  We rely on the

// golden file to check that Google Test generates the right error message.

TEST_F(MixedUpTestCaseTest, ThisShouldFail) {}

TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {}

class MixedUpTestCaseWithSameTestNameTest : public testing::Test {

};

// Expected to fail.  We rely on the golden file to check that Google Test

// generates the right error message.

TEST_F(MixedUpTestCaseWithSameTestNameTest,

       TheSecondTestWithThisNameShouldFail) {}

}  // namespace bar

// 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

// test case checks the scenario where TEST_F appears before TEST, and

// the second one checks where TEST appears before TEST_F.

class TEST_F_before_TEST_in_same_test_case : public testing::Test {

};

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

// generates the right error message.

TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {}

class TEST_before_TEST_F_in_same_test_case : public testing::Test {

};

TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {}

// Expected to fail.  We rely on the golden file to check that Google Test

// generates the right error message.

TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) {

}

// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().

int global_integer = 0;

// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.

TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {

  global_integer = 0;

  EXPECT_NONFATAL_FAILURE({

    EXPECT_EQ(1, global_integer) << "Expected non-fatal failure.";

  }, "Expected non-fatal failure.");

}

// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables

// (static or not).

TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) {

  int m = 0;

  static int n;

  n = 1;

  EXPECT_NONFATAL_FAILURE({

    EXPECT_EQ(m, n) << "Expected non-fatal failure.";

  }, "Expected non-fatal failure.");

}

// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly

// one non-fatal failure and no fatal failure.

TEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) {

  EXPECT_NONFATAL_FAILURE({

    ADD_FAILURE() << "Expected non-fatal failure.";

  }, "Expected non-fatal failure.");

}

// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no

// non-fatal failure.

TEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) {

  printf("(expecting a failure)\n");

  EXPECT_NONFATAL_FAILURE({

  }, "");

}

// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two

// non-fatal failures.

TEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) {

  printf("(expecting a failure)\n");

  EXPECT_NONFATAL_FAILURE({

    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

// failure.

TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) {

  printf("(expecting a failure)\n");

  EXPECT_NONFATAL_FAILURE({

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

  }, "");

}

// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being

// tested returns.

TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) {

  printf("(expecting a failure)\n");

  EXPECT_NONFATAL_FAILURE({

    return;

  }, "");

}

#if GTEST_HAS_EXCEPTIONS

// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being

// tested throws.

TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) {

  printf("(expecting a failure)\n");

  try {

    EXPECT_NONFATAL_FAILURE({

      throw 0;

    }, "");

  } catch(int) {  // NOLINT

  }

}

#endif  // GTEST_HAS_EXCEPTIONS

// Tests that EXPECT_FATAL_FAILURE() can reference global variables.

TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) {

  global_integer = 0;

  EXPECT_FATAL_FAILURE({

    ASSERT_EQ(1, global_integer) << "Expected fatal failure.";

  }, "Expected fatal failure.");

}

// Tests that EXPECT_FATAL_FAILURE() can reference local static

// variables.

TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) {

  static int n;

  n = 1;

  EXPECT_FATAL_FAILURE({

    ASSERT_EQ(0, n) << "Expected fatal failure.";

  }, "Expected fatal failure.");

}

// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly

// one fatal failure and no non-fatal failure.

TEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) {

  EXPECT_FATAL_FAILURE({

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

  }, "Expected fatal failure.");

}

// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal

// failure.

TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) {

  printf("(expecting a failure)\n");

  EXPECT_FATAL_FAILURE({

  }, "");

}

// A helper for generating a fatal failure.

void FatalFailure() {

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

}

// Tests that EXPECT_FATAL_FAILURE() fails when there are two

// fatal failures.

TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) {

  printf("(expecting a failure)\n");

  EXPECT_FATAL_FAILURE({

    FatalFailure();

    FatalFailure();

  }, "");

}

// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal

// failure.

TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) {

  printf("(expecting a failure)\n");

  EXPECT_FATAL_FAILURE({

    ADD_FAILURE() << "Expected non-fatal failure.";

  }, "");

}

// Tests that EXPECT_FATAL_FAILURE() fails when the statement being

// tested returns.

TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) {

  printf("(expecting a failure)\n");

  EXPECT_FATAL_FAILURE({

    return;

  }, "");

}

#if GTEST_HAS_EXCEPTIONS

// Tests that EXPECT_FATAL_FAILURE() fails when the statement being

// tested throws.

TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) {

  printf("(expecting a failure)\n");

  try {

    EXPECT_FATAL_FAILURE({

      throw 0;

    }, "");

  } catch(int) {  // NOLINT

  }

}

#endif  // GTEST_HAS_EXCEPTIONS

// This #ifdef block tests the output of value-parameterized tests.

#if GTEST_HAS_PARAM_TEST

std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) {

  return info.param;

}

class ParamTest : public testing::TestWithParam<std::string> {

};

TEST_P(ParamTest, Success) {

  EXPECT_EQ("a", GetParam());

}

TEST_P(ParamTest, Failure) {

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

}

INSTANTIATE_TEST_CASE_P(PrintingStrings,

                        ParamTest,

                        testing::Values(std::string("a")),

                        ParamNameFunc);

#endif  // GTEST_HAS_PARAM_TEST

// This #ifdef block tests the output of typed tests.

#if GTEST_HAS_TYPED_TEST

template <typename T>

class TypedTest : public testing::Test {

};

TYPED_TEST_CASE(TypedTest, testing::Types<int>);

TYPED_TEST(TypedTest, Success) {

  EXPECT_EQ(0, TypeParam());

}

TYPED_TEST(TypedTest, Failure) {

  EXPECT_EQ(1, TypeParam()) << "Expected failure";

}

#endif  // GTEST_HAS_TYPED_TEST

// This #ifdef block tests the output of type-parameterized tests.

#if GTEST_HAS_TYPED_TEST_P

template <typename T>

class TypedTestP : public testing::Test {

};

TYPED_TEST_CASE_P(TypedTestP);

TYPED_TEST_P(TypedTestP, Success) {

  EXPECT_EQ(0U, TypeParam());

}

TYPED_TEST_P(TypedTestP, Failure) {

  EXPECT_EQ(1U, TypeParam()) << "Expected failure";

}

REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure);

typedef testing::Types<unsigned char, unsigned int> UnsignedTypes;

INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes);

#endif  // GTEST_HAS_TYPED_TEST_P

#if GTEST_HAS_DEATH_TEST

// We rely on the golden file to verify that tests whose test case

// name ends with DeathTest are run first.

TEST(ADeathTest, ShouldRunFirst) {

}

# if GTEST_HAS_TYPED_TEST

// We rely on the golden file to verify that typed tests whose test

// case name ends with DeathTest are run first.

template <typename T>

class ATypedDeathTest : public testing::Test {

};

typedef testing::Types<int, double> NumericTypes;

TYPED_TEST_CASE(ATypedDeathTest, NumericTypes);

TYPED_TEST(ATypedDeathTest, ShouldRunFirst) {

}

# endif  // GTEST_HAS_TYPED_TEST

# if GTEST_HAS_TYPED_TEST_P

// We rely on the golden file to verify that type-parameterized tests

// whose test case name ends with DeathTest are run first.

template <typename T>

class ATypeParamDeathTest : public testing::Test {

};

TYPED_TEST_CASE_P(ATypeParamDeathTest);

TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) {

}

REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst);

INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes);

# endif  // GTEST_HAS_TYPED_TEST_P

#endif  // GTEST_HAS_DEATH_TEST

// Tests various failure conditions of

// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.

class ExpectFailureTest : public testing::Test {

 public:  // Must be public and not protected due to a bug in g++ 3.4.2.

  enum FailureMode {

    FATAL_FAILURE,