The Tor Browser: media/webrtc/trunk/testing/gtest/test/gtest-death-test

media/webrtc/trunk/testing/gtest/test/gtest-death-test_test.cc@4ab42b5ab56c (annotated)

media/webrtc/trunk/testing/gtest/test/gtest-death-test_test.cc

Wed, 31 Dec 2014 07:53:36 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:53:36 +0100
branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c
permissions: -rw-r--r--

Correct small whitespace inconsistency, lost while renaming variables.

 // 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.
 //
 // Author: wan@google.com (Zhanyong Wan)
 //
 // Tests for death tests.
 #include "gtest/gtest-death-test.h"
 #include "gtest/gtest.h"
 #include "gtest/internal/gtest-filepath.h"
 using testing::internal::AlwaysFalse;
 using testing::internal::AlwaysTrue;
 #if GTEST_HAS_DEATH_TEST
 # if GTEST_OS_WINDOWS
 #  include <direct.h>          // For chdir().
 # else
 #  include <unistd.h>
 #  include <sys/wait.h>        // For waitpid.
 #  include <limits>            // For std::numeric_limits.
 # endif  // GTEST_OS_WINDOWS
 # include <limits.h>
 # include <signal.h>
 # include <stdio.h>
 # if GTEST_OS_LINUX
 #  include <sys/time.h>
 # endif  // GTEST_OS_LINUX
 # include "gtest/gtest-spi.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_
 namespace posix = ::testing::internal::posix;
 using testing::Message;
 using testing::internal::DeathTest;
 using testing::internal::DeathTestFactory;
 using testing::internal::FilePath;
 using testing::internal::GetLastErrnoDescription;
 using testing::internal::GetUnitTestImpl;
 using testing::internal::InDeathTestChild;
 using testing::internal::ParseNaturalNumber;
 using testing::internal::String;
 namespace testing {
 namespace internal {
 // A helper class whose objects replace the death test factory for a
 // single UnitTest object during their lifetimes.
 class ReplaceDeathTestFactory {
  public:
   explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
       : unit_test_impl_(GetUnitTestImpl()) {
     old_factory_ = unit_test_impl_->death_test_factory_.release();
     unit_test_impl_->death_test_factory_.reset(new_factory);
   }
   ~ReplaceDeathTestFactory() {
     unit_test_impl_->death_test_factory_.release();
     unit_test_impl_->death_test_factory_.reset(old_factory_);
   }
  private:
   // Prevents copying ReplaceDeathTestFactory objects.
   ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
   void operator=(const ReplaceDeathTestFactory&);
   UnitTestImpl* unit_test_impl_;
   DeathTestFactory* old_factory_;
 };
 }  // namespace internal
 }  // namespace testing
 void DieWithMessage(const ::std::string& message) {
   fprintf(stderr, "%s", message.c_str());
   fflush(stderr);  // Make sure the text is printed before the process exits.
   // We call _exit() instead of exit(), as the former is a direct
   // system call and thus safer in the presence of threads.  exit()
   // will invoke user-defined exit-hooks, which may do dangerous
   // things that conflict with death tests.
   //
   // Some compilers can recognize that _exit() never returns and issue the
   // 'unreachable code' warning for code following this function, unless
   // fooled by a fake condition.
   if (AlwaysTrue())
     _exit(1);
 }
 void DieInside(const ::std::string& function) {
   DieWithMessage("death inside " + function + "().");
 }
 // Tests that death tests work.
 class TestForDeathTest : public testing::Test {
  protected:
   TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
   virtual ~TestForDeathTest() {
     posix::ChDir(original_dir_.c_str());
   }
   // A static member function that's expected to die.
   static void StaticMemberFunction() { DieInside("StaticMemberFunction"); }
   // A method of the test fixture that may die.
   void MemberFunction() {
     if (should_die_)
       DieInside("MemberFunction");
   }
   // True iff MemberFunction() should die.
   bool should_die_;
   const FilePath original_dir_;
 };
 // A class with a member function that may die.
 class MayDie {
  public:
   explicit MayDie(bool should_die) : should_die_(should_die) {}
   // A member function that may die.
   void MemberFunction() const {
     if (should_die_)
       DieInside("MayDie::MemberFunction");
   }
  private:
   // True iff MemberFunction() should die.
   bool should_die_;
 };
 // A global function that's expected to die.
 void GlobalFunction() { DieInside("GlobalFunction"); }
 // A non-void function that's expected to die.
 int NonVoidFunction() {
   DieInside("NonVoidFunction");
   return 1;
 }
 // A unary function that may die.
 void DieIf(bool should_die) {
   if (should_die)
     DieInside("DieIf");
 }
 // A binary function that may die.
 bool DieIfLessThan(int x, int y) {
   if (x < y) {
     DieInside("DieIfLessThan");
   }
   return true;
 }
 // Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
 void DeathTestSubroutine() {
   EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");
   ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");
 }
 // Death in dbg, not opt.
 int DieInDebugElse12(int* sideeffect) {
   if (sideeffect) *sideeffect = 12;
 # ifndef NDEBUG
   DieInside("DieInDebugElse12");
 # endif  // NDEBUG
   return 12;
 }
 # if GTEST_OS_WINDOWS
 // Tests the ExitedWithCode predicate.
 TEST(ExitStatusPredicateTest, ExitedWithCode) {
   // On Windows, the process's exit code is the same as its exit status,
   // so the predicate just compares the its input with its parameter.
   EXPECT_TRUE(testing::ExitedWithCode(0)(0));
   EXPECT_TRUE(testing::ExitedWithCode(1)(1));
   EXPECT_TRUE(testing::ExitedWithCode(42)(42));
   EXPECT_FALSE(testing::ExitedWithCode(0)(1));
   EXPECT_FALSE(testing::ExitedWithCode(1)(0));
 }
 # else
 // Returns the exit status of a process that calls _exit(2) with a
 // given exit code.  This is a helper function for the
 // ExitStatusPredicateTest test suite.
 static int NormalExitStatus(int exit_code) {
   pid_t child_pid = fork();
   if (child_pid == 0) {
     _exit(exit_code);
   }
   int status;
   waitpid(child_pid, &status, 0);
   return status;
 }
 // Returns the exit status of a process that raises a given signal.
 // If the signal does not cause the process to die, then it returns
 // instead the exit status of a process that exits normally with exit
 // code 1.  This is a helper function for the ExitStatusPredicateTest
 // test suite.
 static int KilledExitStatus(int signum) {
   pid_t child_pid = fork();
   if (child_pid == 0) {
     raise(signum);
     _exit(1);
   }
   int status;
   waitpid(child_pid, &status, 0);
   return status;
 }
 // Tests the ExitedWithCode predicate.
 TEST(ExitStatusPredicateTest, ExitedWithCode) {
   const int status0  = NormalExitStatus(0);
   const int status1  = NormalExitStatus(1);
   const int status42 = NormalExitStatus(42);
   const testing::ExitedWithCode pred0(0);
   const testing::ExitedWithCode pred1(1);
   const testing::ExitedWithCode pred42(42);
   EXPECT_PRED1(pred0,  status0);
   EXPECT_PRED1(pred1,  status1);
   EXPECT_PRED1(pred42, status42);
   EXPECT_FALSE(pred0(status1));
   EXPECT_FALSE(pred42(status0));
   EXPECT_FALSE(pred1(status42));
 }
 // Tests the KilledBySignal predicate.
 TEST(ExitStatusPredicateTest, KilledBySignal) {
   const int status_segv = KilledExitStatus(SIGSEGV);
   const int status_kill = KilledExitStatus(SIGKILL);
   const testing::KilledBySignal pred_segv(SIGSEGV);
   const testing::KilledBySignal pred_kill(SIGKILL);
   EXPECT_PRED1(pred_segv, status_segv);
   EXPECT_PRED1(pred_kill, status_kill);
   EXPECT_FALSE(pred_segv(status_kill));
   EXPECT_FALSE(pred_kill(status_segv));
 }
 # endif  // GTEST_OS_WINDOWS
 // Tests that the death test macros expand to code which may or may not
 // be followed by operator<<, and that in either case the complete text
 // comprises only a single C++ statement.
 TEST_F(TestForDeathTest, SingleStatement) {
   if (AlwaysFalse())
     // This would fail if executed; this is a compilation test only
     ASSERT_DEATH(return, "");
   if (AlwaysTrue())
     EXPECT_DEATH(_exit(1), "");
   else
     // This empty "else" branch is meant to ensure that EXPECT_DEATH
     // doesn't expand into an "if" statement without an "else"
     ;
   if (AlwaysFalse())
     ASSERT_DEATH(return, "") << "did not die";
   if (AlwaysFalse())
     ;
   else
     EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
 }
 void DieWithEmbeddedNul() {
   fprintf(stderr, "Hello%cmy null world.\n", '\0');
   fflush(stderr);
   _exit(1);
 }
 # if GTEST_USES_PCRE
 // Tests that EXPECT_DEATH and ASSERT_DEATH work when the error
 // message has a NUL character in it.
 TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
   // TODO(wan@google.com): <regex.h> doesn't support matching strings
   // with embedded NUL characters - find a way to workaround it.
   EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");
   ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
 }
 # endif  // GTEST_USES_PCRE
 // Tests that death test macros expand to code which interacts well with switch
 // statements.
 TEST_F(TestForDeathTest, SwitchStatement) {
 // Microsoft compiler usually complains about switch statements without
 // case labels. We suppress that warning for this test.
 # ifdef _MSC_VER
 #  pragma warning(push)
 #  pragma warning(disable: 4065)
 # endif  // _MSC_VER
   switch (0)
     default:
       ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
   switch (0)
     case 0:
       EXPECT_DEATH(_exit(1), "") << "exit in switch case";
 # ifdef _MSC_VER
 #  pragma warning(pop)
 # endif  // _MSC_VER
 }
 // Tests that a static member function can be used in a "fast" style
 // death test.
 TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
 }
 // Tests that a method of the test fixture can be used in a "fast"
 // style death test.
 TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   should_die_ = true;
   EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
 }
 void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
 // Tests that death tests work even if the current directory has been
 // changed.
 TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
   ChangeToRootDir();
   ASSERT_DEATH(_exit(1), "");
 }
 # if GTEST_OS_LINUX
 void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
 // Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
 void SetSigprofActionAndTimer() {
   struct itimerval timer;
   timer.it_interval.tv_sec = 0;
   timer.it_interval.tv_usec = 1;
   timer.it_value = timer.it_interval;
   ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
   struct sigaction signal_action;
   memset(&signal_action, 0, sizeof(signal_action));
   sigemptyset(&signal_action.sa_mask);
   signal_action.sa_sigaction = SigprofAction;
   signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
   ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
 }
 // Disables ITIMER_PROF timer and ignores SIGPROF signal.
 void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
   struct itimerval timer;
   timer.it_interval.tv_sec = 0;
   timer.it_interval.tv_usec = 0;
   timer.it_value = timer.it_interval;
   ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
   struct sigaction signal_action;
   memset(&signal_action, 0, sizeof(signal_action));
   sigemptyset(&signal_action.sa_mask);
   signal_action.sa_handler = SIG_IGN;
   ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
 }
 // Tests that death tests work when SIGPROF handler and timer are set.
 TEST_F(TestForDeathTest, FastSigprofActionSet) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   SetSigprofActionAndTimer();
   EXPECT_DEATH(_exit(1), "");
   struct sigaction old_signal_action;
   DisableSigprofActionAndTimer(&old_signal_action);
   EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
 }
 TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   SetSigprofActionAndTimer();
   EXPECT_DEATH(_exit(1), "");
   struct sigaction old_signal_action;
   DisableSigprofActionAndTimer(&old_signal_action);
   EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
 }
 # endif  // GTEST_OS_LINUX
 // Repeats a representative sample of death tests in the "threadsafe" style:
 TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
 }
 TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   should_die_ = true;
   EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
 }
 TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   for (int i = 0; i < 3; ++i)
     EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
 }
 TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   ChangeToRootDir();
   EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
   ChangeToRootDir();
   ASSERT_DEATH(_exit(1), "");
 }
 TEST_F(TestForDeathTest, MixedStyles) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   EXPECT_DEATH(_exit(1), "");
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_DEATH(_exit(1), "");
 }
 namespace {
 bool pthread_flag;
 void SetPthreadFlag() {
   pthread_flag = true;
 }
 }  // namespace
 # if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
 TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
   if (!testing::GTEST_FLAG(death_test_use_fork)) {
     testing::GTEST_FLAG(death_test_style) = "threadsafe";
     pthread_flag = false;
     ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
     ASSERT_DEATH(_exit(1), "");
     ASSERT_FALSE(pthread_flag);
   }
 }
 # endif  // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
 // Tests that a method of another class can be used in a death test.
 TEST_F(TestForDeathTest, MethodOfAnotherClass) {
   const MayDie x(true);
   ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");
 }
 // Tests that a global function can be used in a death test.
 TEST_F(TestForDeathTest, GlobalFunction) {
   EXPECT_DEATH(GlobalFunction(), "GlobalFunction");
 }
 // Tests that any value convertible to an RE works as a second
 // argument to EXPECT_DEATH.
 TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
   static const char regex_c_str[] = "GlobalFunction";
   EXPECT_DEATH(GlobalFunction(), regex_c_str);
   const testing::internal::RE regex(regex_c_str);
   EXPECT_DEATH(GlobalFunction(), regex);
 # if GTEST_HAS_GLOBAL_STRING
   const string regex_str(regex_c_str);
   EXPECT_DEATH(GlobalFunction(), regex_str);
 # endif  // GTEST_HAS_GLOBAL_STRING
   const ::std::string regex_std_str(regex_c_str);
   EXPECT_DEATH(GlobalFunction(), regex_std_str);
 }
 // Tests that a non-void function can be used in a death test.
 TEST_F(TestForDeathTest, NonVoidFunction) {
   ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");
 }
 // Tests that functions that take parameter(s) can be used in a death test.
 TEST_F(TestForDeathTest, FunctionWithParameter) {
   EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");
   EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");
 }
 // Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
 TEST_F(TestForDeathTest, OutsideFixture) {
   DeathTestSubroutine();
 }
 // Tests that death tests can be done inside a loop.
 TEST_F(TestForDeathTest, InsideLoop) {
   for (int i = 0; i < 5; i++) {
     EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;
   }
 }
 // Tests that a compound statement can be used in a death test.
 TEST_F(TestForDeathTest, CompoundStatement) {
   EXPECT_DEATH({  // NOLINT
     const int x = 2;
     const int y = x + 1;
     DieIfLessThan(x, y);
   },
   "DieIfLessThan");
 }
 // Tests that code that doesn't die causes a death test to fail.
 TEST_F(TestForDeathTest, DoesNotDie) {
   EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
                           "failed to die");
 }
 // Tests that a death test fails when the error message isn't expected.
 TEST_F(TestForDeathTest, ErrorMessageMismatch) {
   EXPECT_NONFATAL_FAILURE({  // NOLINT
     EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
   }, "died but not with expected error");
 }
 // On exit, *aborted will be true iff the EXPECT_DEATH() statement
 // aborted the function.
 void ExpectDeathTestHelper(bool* aborted) {
   *aborted = true;
   EXPECT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
   *aborted = false;
 }
 // Tests that EXPECT_DEATH doesn't abort the test on failure.
 TEST_F(TestForDeathTest, EXPECT_DEATH) {
   bool aborted = true;
   EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
                           "failed to die");
   EXPECT_FALSE(aborted);
 }
 // Tests that ASSERT_DEATH does abort the test on failure.
 TEST_F(TestForDeathTest, ASSERT_DEATH) {
   static bool aborted;
   EXPECT_FATAL_FAILURE({  // NOLINT
     aborted = true;
     ASSERT_DEATH(DieIf(false), "DieIf");  // This assertion should fail.
     aborted = false;
   }, "failed to die");
   EXPECT_TRUE(aborted);
 }
 // Tests that EXPECT_DEATH evaluates the arguments exactly once.
 TEST_F(TestForDeathTest, SingleEvaluation) {
   int x = 3;
   EXPECT_DEATH(DieIf((++x) == 4), "DieIf");
   const char* regex = "DieIf";
   const char* regex_save = regex;
   EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
   EXPECT_EQ(regex_save + 1, regex);
 }
 // Tests that run-away death tests are reported as failures.
 TEST_F(TestForDeathTest, RunawayIsFailure) {
   EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),
                           "failed to die.");
 }
 // Tests that death tests report executing 'return' in the statement as
 // failure.
 TEST_F(TestForDeathTest, ReturnIsFailure) {
   EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),
                        "illegal return in test statement.");
 }
 // Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a
 // message to it, and in debug mode it:
 // 1. Asserts on death.
 // 2. Has no side effect.
 //
 // And in opt mode, it:
 // 1.  Has side effects but does not assert.
 TEST_F(TestForDeathTest, TestExpectDebugDeath) {
   int sideeffect = 0;
   EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
       << "Must accept a streamed message";
 # ifdef NDEBUG
   // Checks that the assignment occurs in opt mode (sideeffect).
   EXPECT_EQ(12, sideeffect);
 # else
   // Checks that the assignment does not occur in dbg mode (no sideeffect).
   EXPECT_EQ(0, sideeffect);
 # endif
 }
 // Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
 // message to it, and in debug mode it:
 // 1. Asserts on death.
 // 2. Has no side effect.
 //
 // And in opt mode, it:
 // 1.  Has side effects but does not assert.
 TEST_F(TestForDeathTest, TestAssertDebugDeath) {
   int sideeffect = 0;
   ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
       << "Must accept a streamed message";
 # ifdef NDEBUG
   // Checks that the assignment occurs in opt mode (sideeffect).
   EXPECT_EQ(12, sideeffect);
 # else
   // Checks that the assignment does not occur in dbg mode (no sideeffect).
   EXPECT_EQ(0, sideeffect);
 # endif
 }
 # ifndef NDEBUG
 void ExpectDebugDeathHelper(bool* aborted) {
   *aborted = true;
   EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";
   *aborted = false;
 }
 #  if GTEST_OS_WINDOWS
 TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
   printf("This test should be considered failing if it shows "
          "any pop-up dialogs.\n");
   fflush(stdout);
   EXPECT_DEATH({
     testing::GTEST_FLAG(catch_exceptions) = false;
     abort();
   }, "");
 }
 #  endif  // GTEST_OS_WINDOWS
 // Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
 // the function.
 TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
   bool aborted = true;
   EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");
   EXPECT_FALSE(aborted);
 }
 void AssertDebugDeathHelper(bool* aborted) {
   *aborted = true;
   ASSERT_DEBUG_DEATH(return, "") << "This is expected to fail.";
   *aborted = false;
 }
 // Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on
 // failure.
 TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
   static bool aborted;
   aborted = false;
   EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
   EXPECT_TRUE(aborted);
 }
 # endif  // _NDEBUG
 // Tests the *_EXIT family of macros, using a variety of predicates.
 static void TestExitMacros() {
   EXPECT_EXIT(_exit(1),  testing::ExitedWithCode(1),  "");
   ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
 # if GTEST_OS_WINDOWS
   // Of all signals effects on the process exit code, only those of SIGABRT
   // are documented on Windows.
   // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
   EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
 # else
   EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
   ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
   EXPECT_FATAL_FAILURE({  // NOLINT
     ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
       << "This failure is expected, too.";
   }, "This failure is expected, too.");
 # endif  // GTEST_OS_WINDOWS
   EXPECT_NONFATAL_FAILURE({  // NOLINT
     EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
       << "This failure is expected.";
   }, "This failure is expected.");
 }
 TEST_F(TestForDeathTest, ExitMacros) {
   TestExitMacros();
 }
 TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
   testing::GTEST_FLAG(death_test_use_fork) = true;
   TestExitMacros();
 }
 TEST_F(TestForDeathTest, InvalidStyle) {
   testing::GTEST_FLAG(death_test_style) = "rococo";
   EXPECT_NONFATAL_FAILURE({  // NOLINT
     EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
   }, "This failure is expected.");
 }
 TEST_F(TestForDeathTest, DeathTestFailedOutput) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_NONFATAL_FAILURE(
       EXPECT_DEATH(DieWithMessage("death\n"),
                    "expected message"),
       "Actual msg:\n"
       "[  DEATH   ] death\n");
 }
 TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_NONFATAL_FAILURE(
       EXPECT_DEATH({
           fprintf(stderr, "returning\n");
           fflush(stderr);
           return;
         }, ""),
       "    Result: illegal return in test statement.\n"
       " Error msg:\n"
       "[  DEATH   ] returning\n");
 }
 TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_NONFATAL_FAILURE(
       EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"),
                   testing::ExitedWithCode(3),
                   "expected message"),
       "    Result: died but not with expected exit code:\n"
       "            Exited with exit status 1\n"
       "Actual msg:\n"
       "[  DEATH   ] exiting with rc 1\n");
 }
 TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_NONFATAL_FAILURE(
       EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
                    "line 1\nxyz\nline 3\n"),
       "Actual msg:\n"
       "[  DEATH   ] line 1\n"
       "[  DEATH   ] line 2\n"
       "[  DEATH   ] line 3\n");
 }
 TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
                "line 1\nline 2\nline 3\n");
 }
 // A DeathTestFactory that returns MockDeathTests.
 class MockDeathTestFactory : public DeathTestFactory {
  public:
   MockDeathTestFactory();
   virtual bool Create(const char* statement,
                       const ::testing::internal::RE* regex,
                       const char* file, int line, DeathTest** test);
   // Sets the parameters for subsequent calls to Create.
   void SetParameters(bool create, DeathTest::TestRole role,
                      int status, bool passed);
   // Accessors.
   int AssumeRoleCalls() const { return assume_role_calls_; }
   int WaitCalls() const { return wait_calls_; }
   int PassedCalls() const { return passed_args_.size(); }
   bool PassedArgument(int n) const { return passed_args_[n]; }
   int AbortCalls() const { return abort_args_.size(); }
   DeathTest::AbortReason AbortArgument(int n) const {
     return abort_args_[n];
   }
   bool TestDeleted() const { return test_deleted_; }
  private:
   friend class MockDeathTest;
   // If true, Create will return a MockDeathTest; otherwise it returns
   // NULL.
   bool create_;
   // The value a MockDeathTest will return from its AssumeRole method.
   DeathTest::TestRole role_;
   // The value a MockDeathTest will return from its Wait method.
   int status_;
   // The value a MockDeathTest will return from its Passed method.
   bool passed_;
   // Number of times AssumeRole was called.
   int assume_role_calls_;
   // Number of times Wait was called.
   int wait_calls_;
   // The arguments to the calls to Passed since the last call to
   // SetParameters.
   std::vector<bool> passed_args_;
   // The arguments to the calls to Abort since the last call to
   // SetParameters.
   std::vector<DeathTest::AbortReason> abort_args_;
   // True if the last MockDeathTest returned by Create has been
   // deleted.
   bool test_deleted_;
 };
 // A DeathTest implementation useful in testing.  It returns values set
 // at its creation from its various inherited DeathTest methods, and
 // reports calls to those methods to its parent MockDeathTestFactory
 // object.
 class MockDeathTest : public DeathTest {
  public:
   MockDeathTest(MockDeathTestFactory *parent,
                 TestRole role, int status, bool passed) :
       parent_(parent), role_(role), status_(status), passed_(passed) {
   }
   virtual ~MockDeathTest() {
     parent_->test_deleted_ = true;
   }
   virtual TestRole AssumeRole() {
     ++parent_->assume_role_calls_;
     return role_;
   }
   virtual int Wait() {
     ++parent_->wait_calls_;
     return status_;
   }
   virtual bool Passed(bool exit_status_ok) {
     parent_->passed_args_.push_back(exit_status_ok);
     return passed_;
   }
   virtual void Abort(AbortReason reason) {
     parent_->abort_args_.push_back(reason);
   }
  private:
   MockDeathTestFactory* const parent_;
   const TestRole role_;
   const int status_;
   const bool passed_;
 };
 // MockDeathTestFactory constructor.
 MockDeathTestFactory::MockDeathTestFactory()
     : create_(true),
       role_(DeathTest::OVERSEE_TEST),
       status_(0),
       passed_(true),
       assume_role_calls_(0),
       wait_calls_(0),
       passed_args_(),
       abort_args_() {
 }
 // Sets the parameters for subsequent calls to Create.
 void MockDeathTestFactory::SetParameters(bool create,
                                          DeathTest::TestRole role,
                                          int status, bool passed) {
   create_ = create;
   role_ = role;
   status_ = status;
   passed_ = passed;
   assume_role_calls_ = 0;
   wait_calls_ = 0;
   passed_args_.clear();
   abort_args_.clear();
 }
 // Sets test to NULL (if create_ is false) or to the address of a new
 // MockDeathTest object with parameters taken from the last call
 // to SetParameters (if create_ is true).  Always returns true.
 bool MockDeathTestFactory::Create(const char* /*statement*/,
                                   const ::testing::internal::RE* /*regex*/,
                                   const char* /*file*/,
                                   int /*line*/,
                                   DeathTest** test) {
   test_deleted_ = false;
   if (create_) {
     *test = new MockDeathTest(this, role_, status_, passed_);
   } else {
     *test = NULL;
   }
   return true;
 }
 // A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.
 // It installs a MockDeathTestFactory that is used for the duration
 // of the test case.
 class MacroLogicDeathTest : public testing::Test {
  protected:
   static testing::internal::ReplaceDeathTestFactory* replacer_;
   static MockDeathTestFactory* factory_;
   static void SetUpTestCase() {
     factory_ = new MockDeathTestFactory;
     replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);
   }
   static void TearDownTestCase() {
     delete replacer_;
     replacer_ = NULL;
     delete factory_;
     factory_ = NULL;
   }
   // Runs a death test that breaks the rules by returning.  Such a death
   // test cannot be run directly from a test routine that uses a
   // MockDeathTest, or the remainder of the routine will not be executed.
   static void RunReturningDeathTest(bool* flag) {
     ASSERT_DEATH({  // NOLINT
       *flag = true;
       return;
     }, "");
   }
 };
 testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
     = NULL;
 MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
 // Test that nothing happens when the factory doesn't return a DeathTest:
 TEST_F(MacroLogicDeathTest, NothingHappens) {
   bool flag = false;
   factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);
   EXPECT_DEATH(flag = true, "");
   EXPECT_FALSE(flag);
   EXPECT_EQ(0, factory_->AssumeRoleCalls());
   EXPECT_EQ(0, factory_->WaitCalls());
   EXPECT_EQ(0, factory_->PassedCalls());
   EXPECT_EQ(0, factory_->AbortCalls());
   EXPECT_FALSE(factory_->TestDeleted());
 }
 // Test that the parent process doesn't run the death test code,
 // and that the Passed method returns false when the (simulated)
 // child process exits with status 0:
 TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
   bool flag = false;
   factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);
   EXPECT_DEATH(flag = true, "");
   EXPECT_FALSE(flag);
   EXPECT_EQ(1, factory_->AssumeRoleCalls());
   EXPECT_EQ(1, factory_->WaitCalls());
   ASSERT_EQ(1, factory_->PassedCalls());
   EXPECT_FALSE(factory_->PassedArgument(0));
   EXPECT_EQ(0, factory_->AbortCalls());
   EXPECT_TRUE(factory_->TestDeleted());
 }
 // Tests that the Passed method was given the argument "true" when
 // the (simulated) child process exits with status 1:
 TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
   bool flag = false;
   factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);
   EXPECT_DEATH(flag = true, "");
   EXPECT_FALSE(flag);
   EXPECT_EQ(1, factory_->AssumeRoleCalls());
   EXPECT_EQ(1, factory_->WaitCalls());
   ASSERT_EQ(1, factory_->PassedCalls());
   EXPECT_TRUE(factory_->PassedArgument(0));
   EXPECT_EQ(0, factory_->AbortCalls());
   EXPECT_TRUE(factory_->TestDeleted());
 }
 // Tests that the (simulated) child process executes the death test
 // code, and is aborted with the correct AbortReason if it
 // executes a return statement.
 TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
   bool flag = false;
   factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
   RunReturningDeathTest(&flag);
   EXPECT_TRUE(flag);
   EXPECT_EQ(1, factory_->AssumeRoleCalls());
   EXPECT_EQ(0, factory_->WaitCalls());
   EXPECT_EQ(0, factory_->PassedCalls());
   EXPECT_EQ(1, factory_->AbortCalls());
   EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
             factory_->AbortArgument(0));
   EXPECT_TRUE(factory_->TestDeleted());
 }
 // Tests that the (simulated) child process is aborted with the
 // correct AbortReason if it does not die.
 TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
   bool flag = false;
   factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
   EXPECT_DEATH(flag = true, "");
   EXPECT_TRUE(flag);
   EXPECT_EQ(1, factory_->AssumeRoleCalls());
   EXPECT_EQ(0, factory_->WaitCalls());
   EXPECT_EQ(0, factory_->PassedCalls());
   // This time there are two calls to Abort: one since the test didn't
   // die, and another from the ReturnSentinel when it's destroyed.  The
   // sentinel normally isn't destroyed if a test doesn't die, since
   // _exit(2) is called in that case by ForkingDeathTest, but not by
   // our MockDeathTest.
   ASSERT_EQ(2, factory_->AbortCalls());
   EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
             factory_->AbortArgument(0));
   EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
             factory_->AbortArgument(1));
   EXPECT_TRUE(factory_->TestDeleted());
 }
 // Tests that a successful death test does not register a successful
 // test part.
 TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
   EXPECT_DEATH(_exit(1), "");
   EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }
 TEST(StreamingAssertionsDeathTest, DeathTest) {
   EXPECT_DEATH(_exit(1), "") << "unexpected failure";
   ASSERT_DEATH(_exit(1), "") << "unexpected failure";
   EXPECT_NONFATAL_FAILURE({  // NOLINT
     EXPECT_DEATH(_exit(0), "") << "expected failure";
   }, "expected failure");
   EXPECT_FATAL_FAILURE({  // NOLINT
     ASSERT_DEATH(_exit(0), "") << "expected failure";
   }, "expected failure");
 }
 // Tests that GetLastErrnoDescription returns an empty string when the
 // last error is 0 and non-empty string when it is non-zero.
 TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
   errno = ENOENT;
   EXPECT_STRNE("", GetLastErrnoDescription().c_str());
   errno = 0;
   EXPECT_STREQ("", GetLastErrnoDescription().c_str());
 }
 # if GTEST_OS_WINDOWS
 TEST(AutoHandleTest, AutoHandleWorks) {
   HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
   ASSERT_NE(INVALID_HANDLE_VALUE, handle);
   // Tests that the AutoHandle is correctly initialized with a handle.
   testing::internal::AutoHandle auto_handle(handle);
   EXPECT_EQ(handle, auto_handle.Get());
   // Tests that Reset assigns INVALID_HANDLE_VALUE.
   // Note that this cannot verify whether the original handle is closed.
   auto_handle.Reset();
   EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
   // Tests that Reset assigns the new handle.
   // Note that this cannot verify whether the original handle is closed.
   handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
   ASSERT_NE(INVALID_HANDLE_VALUE, handle);
   auto_handle.Reset(handle);
   EXPECT_EQ(handle, auto_handle.Get());
   // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default.
   testing::internal::AutoHandle auto_handle2;
   EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
 }
 # endif  // GTEST_OS_WINDOWS
 # if GTEST_OS_WINDOWS
 typedef unsigned __int64 BiggestParsable;
 typedef signed __int64 BiggestSignedParsable;
 const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
 const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
 # else
 typedef unsigned long long BiggestParsable;
 typedef signed long long BiggestSignedParsable;
 const BiggestParsable kBiggestParsableMax =
     ::std::numeric_limits<BiggestParsable>::max();
 const BiggestSignedParsable kBiggestSignedParsableMax =
     ::std::numeric_limits<BiggestSignedParsable>::max();
 # endif  // GTEST_OS_WINDOWS
 TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
   BiggestParsable result = 0;
   // Rejects non-numbers.
   EXPECT_FALSE(ParseNaturalNumber(String("non-number string"), &result));
   // Rejects numbers with whitespace prefix.
   EXPECT_FALSE(ParseNaturalNumber(String(" 123"), &result));
   // Rejects negative numbers.
   EXPECT_FALSE(ParseNaturalNumber(String("-123"), &result));
   // Rejects numbers starting with a plus sign.
   EXPECT_FALSE(ParseNaturalNumber(String("+123"), &result));
   errno = 0;
 }
 TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
   BiggestParsable result = 0;
   EXPECT_FALSE(ParseNaturalNumber(String("99999999999999999999999"), &result));
   signed char char_result = 0;
   EXPECT_FALSE(ParseNaturalNumber(String("200"), &char_result));
   errno = 0;
 }
 TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
   BiggestParsable result = 0;
   result = 0;
   ASSERT_TRUE(ParseNaturalNumber(String("123"), &result));
   EXPECT_EQ(123U, result);
   // Check 0 as an edge case.
   result = 1;
   ASSERT_TRUE(ParseNaturalNumber(String("0"), &result));
   EXPECT_EQ(0U, result);
   result = 1;
   ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result));
   EXPECT_EQ(0U, result);
 }
 TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
   Message msg;
   msg << kBiggestParsableMax;
   BiggestParsable result = 0;
   EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
   EXPECT_EQ(kBiggestParsableMax, result);
   Message msg2;
   msg2 << kBiggestSignedParsableMax;
   BiggestSignedParsable signed_result = 0;
   EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
   EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
   Message msg3;
   msg3 << INT_MAX;
   int int_result = 0;
   EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
   EXPECT_EQ(INT_MAX, int_result);
   Message msg4;
   msg4 << UINT_MAX;
   unsigned int uint_result = 0;
   EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
   EXPECT_EQ(UINT_MAX, uint_result);
 }
 TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
   short short_result = 0;
   ASSERT_TRUE(ParseNaturalNumber(String("123"), &short_result));
   EXPECT_EQ(123, short_result);
   signed char char_result = 0;
   ASSERT_TRUE(ParseNaturalNumber(String("123"), &char_result));
   EXPECT_EQ(123, char_result);
 }
 # if GTEST_OS_WINDOWS
 TEST(EnvironmentTest, HandleFitsIntoSizeT) {
   // TODO(vladl@google.com): Remove this test after this condition is verified
   // in a static assertion in gtest-death-test.cc in the function
   // GetStatusFileDescriptor.
   ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
 }
 # endif  // GTEST_OS_WINDOWS
 // Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
 // failures when death tests are available on the system.
 TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
   EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"),
                             "death inside CondDeathTestExpectMacro");
   ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"),
                             "death inside CondDeathTestAssertMacro");
   // Empty statement will not crash, which must trigger a failure.
   EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");
   EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");
 }
 #else
 using testing::internal::CaptureStderr;
 using testing::internal::GetCapturedStderr;
 using testing::internal::String;
 // Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
 // defined but do not trigger failures when death tests are not available on
 // the system.
 TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
   // Empty statement will not crash, but that should not trigger a failure
   // when death tests are not supported.
   CaptureStderr();
   EXPECT_DEATH_IF_SUPPORTED(;, "");
   String output = GetCapturedStderr();
   ASSERT_TRUE(NULL != strstr(output.c_str(),
                              "Death tests are not supported on this platform"));
   ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
   // The streamed message should not be printed as there is no test failure.
   CaptureStderr();
   EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";
   output = GetCapturedStderr();
   ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
   CaptureStderr();
   ASSERT_DEATH_IF_SUPPORTED(;, "");  // NOLINT
   output = GetCapturedStderr();
   ASSERT_TRUE(NULL != strstr(output.c_str(),
                              "Death tests are not supported on this platform"));
   ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
   CaptureStderr();
   ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message";  // NOLINT
   output = GetCapturedStderr();
   ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
 }
 void FuncWithAssert(int* n) {
   ASSERT_DEATH_IF_SUPPORTED(return;, "");
   (*n)++;
 }
 // Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current
 // function (as ASSERT_DEATH does) if death tests are not supported.
 TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
   int n = 0;
   FuncWithAssert(&n);
   EXPECT_EQ(1, n);
 }
 #endif  // GTEST_HAS_DEATH_TEST
 // Tests that the death test macros expand to code which may or may not
 // be followed by operator<<, and that in either case the complete text
 // comprises only a single C++ statement.
 //
 // The syntax should work whether death tests are available or not.
 TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
   if (AlwaysFalse())
     // This would fail if executed; this is a compilation test only
     ASSERT_DEATH_IF_SUPPORTED(return, "");
   if (AlwaysTrue())
     EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
   else
     // This empty "else" branch is meant to ensure that EXPECT_DEATH
     // doesn't expand into an "if" statement without an "else"
     ;  // NOLINT
   if (AlwaysFalse())
     ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
   if (AlwaysFalse())
     ;  // NOLINT
   else
     EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
 }
 // Tests that conditional death test macros expand to code which interacts
 // well with switch statements.
 TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
 // Microsoft compiler usually complains about switch statements without
 // case labels. We suppress that warning for this test.
 #ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable: 4065)
 #endif  // _MSC_VER
   switch (0)
     default:
       ASSERT_DEATH_IF_SUPPORTED(_exit(1), "")
           << "exit in default switch handler";
   switch (0)
     case 0:
       EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
 #ifdef _MSC_VER
 # pragma warning(pop)
 #endif  // _MSC_VER
 }
 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
   testing::GTEST_FLAG(death_test_style) = "fast";
   EXPECT_FALSE(InDeathTestChild());
   EXPECT_DEATH({
     fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
     fflush(stderr);
     _exit(1);
   }, "Inside");
 }
 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   EXPECT_FALSE(InDeathTestChild());
   EXPECT_DEATH({
     fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
     fflush(stderr);
     _exit(1);
   }, "Inside");
 }
 // Tests that a test case whose name ends with "DeathTest" works fine
 // on Windows.
 TEST(NotADeathTest, Test) {
   SUCCEED();
 }

The Tor Browser / annotate

media/webrtc/trunk/testing/gtest/test/gtest-death-test_test.cc@4ab42b5ab56c (annotated)

media/webrtc/trunk/testing/gtest/test/gtest-death-test_test.cc