LCOV - code coverage report
Current view: top level - usr/src/gtest/src - gtest-death-test.cc (source / functions) Hit Total Coverage
Test: clean.info Lines: 8 315 2.5 %
Date: 2013-05-24 Functions: 1 59 1.7 %
Branches: 1 576 0.2 %

           Branch data     Line data    Source code
       1                 :            : // Copyright 2005, Google Inc.
       2                 :            : // All rights reserved.
       3                 :            : //
       4                 :            : // Redistribution and use in source and binary forms, with or without
       5                 :            : // modification, are permitted provided that the following conditions are
       6                 :            : // met:
       7                 :            : //
       8                 :            : //     * Redistributions of source code must retain the above copyright
       9                 :            : // notice, this list of conditions and the following disclaimer.
      10                 :            : //     * Redistributions in binary form must reproduce the above
      11                 :            : // copyright notice, this list of conditions and the following disclaimer
      12                 :            : // in the documentation and/or other materials provided with the
      13                 :            : // distribution.
      14                 :            : //     * Neither the name of Google Inc. nor the names of its
      15                 :            : // contributors may be used to endorse or promote products derived from
      16                 :            : // this software without specific prior written permission.
      17                 :            : //
      18                 :            : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      19                 :            : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      20                 :            : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      21                 :            : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      22                 :            : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      23                 :            : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      24                 :            : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      25                 :            : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      26                 :            : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      27                 :            : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      28                 :            : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      29                 :            : //
      30                 :            : // Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
      31                 :            : //
      32                 :            : // This file implements death tests.
      33                 :            : 
      34                 :            : #include "gtest/gtest-death-test.h"
      35                 :            : #include "gtest/internal/gtest-port.h"
      36                 :            : 
      37                 :            : #if GTEST_HAS_DEATH_TEST
      38                 :            : 
      39                 :            : # if GTEST_OS_MAC
      40                 :            : #  include <crt_externs.h>
      41                 :            : # endif  // GTEST_OS_MAC
      42                 :            : 
      43                 :            : # include <errno.h>
      44                 :            : # include <fcntl.h>
      45                 :            : # include <limits.h>
      46                 :            : # include <stdarg.h>
      47                 :            : 
      48                 :            : # if GTEST_OS_WINDOWS
      49                 :            : #  include <windows.h>
      50                 :            : # else
      51                 :            : #  include <sys/mman.h>
      52                 :            : #  include <sys/wait.h>
      53                 :            : # endif  // GTEST_OS_WINDOWS
      54                 :            : 
      55                 :            : #endif  // GTEST_HAS_DEATH_TEST
      56                 :            : 
      57                 :            : #include "gtest/gtest-message.h"
      58                 :            : #include "gtest/internal/gtest-string.h"
      59                 :            : 
      60                 :            : // Indicates that this translation unit is part of Google Test's
      61                 :            : // implementation.  It must come before gtest-internal-inl.h is
      62                 :            : // included, or there will be a compiler error.  This trick is to
      63                 :            : // prevent a user from accidentally including gtest-internal-inl.h in
      64                 :            : // his code.
      65                 :            : #define GTEST_IMPLEMENTATION_ 1
      66                 :            : #include "src/gtest-internal-inl.h"
      67                 :            : #undef GTEST_IMPLEMENTATION_
      68                 :            : 
      69                 :            : namespace testing {
      70                 :            : 
      71                 :            : // Constants.
      72                 :            : 
      73                 :            : // The default death test style.
      74                 :            : static const char kDefaultDeathTestStyle[] = "fast";
      75                 :            : 
      76                 :            : GTEST_DEFINE_string_(
      77                 :            :     death_test_style,
      78                 :            :     internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
      79                 :            :     "Indicates how to run a death test in a forked child process: "
      80                 :            :     "\"threadsafe\" (child process re-executes the test binary "
      81                 :            :     "from the beginning, running only the specific death test) or "
      82                 :            :     "\"fast\" (child process runs the death test immediately "
      83                 :          4 :     "after forking).");
      84                 :            : 
      85                 :          4 : GTEST_DEFINE_bool_(
      86                 :            :     death_test_use_fork,
      87                 :            :     internal::BoolFromGTestEnv("death_test_use_fork", false),
      88                 :            :     "Instructs to use fork()/_exit() instead of clone() in death tests. "
      89                 :            :     "Ignored and always uses fork() on POSIX systems where clone() is not "
      90                 :            :     "implemented. Useful when running under valgrind or similar tools if "
      91                 :            :     "those do not support clone(). Valgrind 3.3.1 will just fail if "
      92                 :            :     "it sees an unsupported combination of clone() flags. "
      93                 :            :     "It is not recommended to use this flag w/o valgrind though it will "
      94                 :            :     "work in 99% of the cases. Once valgrind is fixed, this flag will "
      95                 :          4 :     "most likely be removed.");
      96                 :            : 
      97                 :            : namespace internal {
      98                 :            : GTEST_DEFINE_string_(
      99                 :            :     internal_run_death_test, "",
     100                 :            :     "Indicates the file, line number, temporal index of "
     101                 :            :     "the single death test to run, and a file descriptor to "
     102                 :            :     "which a success code may be sent, all separated by "
     103                 :            :     "colons.  This flag is specified if and only if the current "
     104                 :            :     "process is a sub-process launched for running a thread-safe "
     105                 :          4 :     "death test.  FOR INTERNAL USE ONLY.");
     106                 :            : }  // namespace internal
     107                 :            : 
     108                 :            : #if GTEST_HAS_DEATH_TEST
     109                 :            : 
     110                 :            : // ExitedWithCode constructor.
     111                 :          0 : ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
     112                 :          0 : }
     113                 :            : 
     114                 :            : // ExitedWithCode function-call operator.
     115                 :          0 : bool ExitedWithCode::operator()(int exit_status) const {
     116                 :            : # if GTEST_OS_WINDOWS
     117                 :            : 
     118                 :            :   return exit_status == exit_code_;
     119                 :            : 
     120                 :            : # else
     121                 :            : 
     122 [ #  # ][ #  # ]:          0 :   return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
     123                 :            : 
     124                 :            : # endif  // GTEST_OS_WINDOWS
     125                 :            : }
     126                 :            : 
     127                 :            : # if !GTEST_OS_WINDOWS
     128                 :            : // KilledBySignal constructor.
     129                 :          0 : KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
     130                 :          0 : }
     131                 :            : 
     132                 :            : // KilledBySignal function-call operator.
     133                 :          0 : bool KilledBySignal::operator()(int exit_status) const {
     134 [ #  # ][ #  # ]:          0 :   return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
     135                 :            : }
     136                 :            : # endif  // !GTEST_OS_WINDOWS
     137                 :            : 
     138                 :            : namespace internal {
     139                 :            : 
     140                 :            : // Utilities needed for death tests.
     141                 :            : 
     142                 :            : // Generates a textual description of a given exit code, in the format
     143                 :            : // specified by wait(2).
     144                 :          0 : static String ExitSummary(int exit_code) {
     145                 :          0 :   Message m;
     146                 :            : 
     147                 :            : # if GTEST_OS_WINDOWS
     148                 :            : 
     149                 :            :   m << "Exited with exit status " << exit_code;
     150                 :            : 
     151                 :            : # else
     152                 :            : 
     153         [ #  # ]:          0 :   if (WIFEXITED(exit_code)) {
     154 [ #  # ][ #  # ]:          0 :     m << "Exited with exit status " << WEXITSTATUS(exit_code);
     155         [ #  # ]:          0 :   } else if (WIFSIGNALED(exit_code)) {
     156 [ #  # ][ #  # ]:          0 :     m << "Terminated by signal " << WTERMSIG(exit_code);
     157                 :            :   }
     158                 :            : #  ifdef WCOREDUMP
     159         [ #  # ]:          0 :   if (WCOREDUMP(exit_code)) {
     160         [ #  # ]:          0 :     m << " (core dumped)";
     161                 :            :   }
     162                 :            : #  endif
     163                 :            : # endif  // GTEST_OS_WINDOWS
     164                 :            : 
     165         [ #  # ]:          0 :   return m.GetString();
     166                 :            : }
     167                 :            : 
     168                 :            : // Returns true if exit_status describes a process that was terminated
     169                 :            : // by a signal, or exited normally with a nonzero exit code.
     170                 :          0 : bool ExitedUnsuccessfully(int exit_status) {
     171                 :          0 :   return !ExitedWithCode(0)(exit_status);
     172                 :            : }
     173                 :            : 
     174                 :            : # if !GTEST_OS_WINDOWS
     175                 :            : // Generates a textual failure message when a death test finds more than
     176                 :            : // one thread running, or cannot determine the number of threads, prior
     177                 :            : // to executing the given statement.  It is the responsibility of the
     178                 :            : // caller not to pass a thread_count of 1.
     179                 :          0 : static String DeathTestThreadWarning(size_t thread_count) {
     180                 :          0 :   Message msg;
     181         [ #  # ]:          0 :   msg << "Death tests use fork(), which is unsafe particularly"
     182 [ #  # ][ #  # ]:          0 :       << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
                 [ #  # ]
     183         [ #  # ]:          0 :   if (thread_count == 0)
     184         [ #  # ]:          0 :     msg << "couldn't detect the number of threads.";
     185                 :            :   else
     186 [ #  # ][ #  # ]:          0 :     msg << "detected " << thread_count << " threads.";
                 [ #  # ]
     187         [ #  # ]:          0 :   return msg.GetString();
     188                 :            : }
     189                 :            : # endif  // !GTEST_OS_WINDOWS
     190                 :            : 
     191                 :            : // Flag characters for reporting a death test that did not die.
     192                 :            : static const char kDeathTestLived = 'L';
     193                 :            : static const char kDeathTestReturned = 'R';
     194                 :            : static const char kDeathTestThrew = 'T';
     195                 :            : static const char kDeathTestInternalError = 'I';
     196                 :            : 
     197                 :            : // An enumeration describing all of the possible ways that a death test can
     198                 :            : // conclude.  DIED means that the process died while executing the test
     199                 :            : // code; LIVED means that process lived beyond the end of the test code;
     200                 :            : // RETURNED means that the test statement attempted to execute a return
     201                 :            : // statement, which is not allowed; THREW means that the test statement
     202                 :            : // returned control by throwing an exception.  IN_PROGRESS means the test
     203                 :            : // has not yet concluded.
     204                 :            : // TODO(vladl@google.com): Unify names and possibly values for
     205                 :            : // AbortReason, DeathTestOutcome, and flag characters above.
     206                 :            : enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
     207                 :            : 
     208                 :            : // Routine for aborting the program which is safe to call from an
     209                 :            : // exec-style death test child process, in which case the error
     210                 :            : // message is propagated back to the parent process.  Otherwise, the
     211                 :            : // message is simply printed to stderr.  In either case, the program
     212                 :            : // then exits with status 1.
     213                 :          0 : void DeathTestAbort(const String& message) {
     214                 :            :   // On a POSIX system, this function may be called from a threadsafe-style
     215                 :            :   // death test child process, which operates on a very small stack.  Use
     216                 :            :   // the heap for any additional non-minuscule memory requirements.
     217                 :            :   const InternalRunDeathTestFlag* const flag =
     218                 :          0 :       GetUnitTestImpl()->internal_run_death_test_flag();
     219         [ #  # ]:          0 :   if (flag != NULL) {
     220                 :          0 :     FILE* parent = posix::FDOpen(flag->write_fd(), "w");
     221                 :          0 :     fputc(kDeathTestInternalError, parent);
     222                 :          0 :     fprintf(parent, "%s", message.c_str());
     223                 :          0 :     fflush(parent);
     224                 :          0 :     _exit(1);
     225                 :            :   } else {
     226                 :          0 :     fprintf(stderr, "%s", message.c_str());
     227                 :          0 :     fflush(stderr);
     228                 :          0 :     posix::Abort();
     229                 :            :   }
     230                 :          0 : }
     231                 :            : 
     232                 :            : // A replacement for CHECK that calls DeathTestAbort if the assertion
     233                 :            : // fails.
     234                 :            : # define GTEST_DEATH_TEST_CHECK_(expression) \
     235                 :            :   do { \
     236                 :            :     if (!::testing::internal::IsTrue(expression)) { \
     237                 :            :       DeathTestAbort(::testing::internal::String::Format( \
     238                 :            :           "CHECK failed: File %s, line %d: %s", \
     239                 :            :           __FILE__, __LINE__, #expression)); \
     240                 :            :     } \
     241                 :            :   } while (::testing::internal::AlwaysFalse())
     242                 :            : 
     243                 :            : // This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
     244                 :            : // evaluating any system call that fulfills two conditions: it must return
     245                 :            : // -1 on failure, and set errno to EINTR when it is interrupted and
     246                 :            : // should be tried again.  The macro expands to a loop that repeatedly
     247                 :            : // evaluates the expression as long as it evaluates to -1 and sets
     248                 :            : // errno to EINTR.  If the expression evaluates to -1 but errno is
     249                 :            : // something other than EINTR, DeathTestAbort is called.
     250                 :            : # define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
     251                 :            :   do { \
     252                 :            :     int gtest_retval; \
     253                 :            :     do { \
     254                 :            :       gtest_retval = (expression); \
     255                 :            :     } while (gtest_retval == -1 && errno == EINTR); \
     256                 :            :     if (gtest_retval == -1) { \
     257                 :            :       DeathTestAbort(::testing::internal::String::Format( \
     258                 :            :           "CHECK failed: File %s, line %d: %s != -1", \
     259                 :            :           __FILE__, __LINE__, #expression)); \
     260                 :            :     } \
     261                 :            :   } while (::testing::internal::AlwaysFalse())
     262                 :            : 
     263                 :            : // Returns the message describing the last system error in errno.
     264                 :          0 : String GetLastErrnoDescription() {
     265         [ #  # ]:          0 :     return String(errno == 0 ? "" : posix::StrError(errno));
     266                 :            : }
     267                 :            : 
     268                 :            : // This is called from a death test parent process to read a failure
     269                 :            : // message from the death test child process and log it with the FATAL
     270                 :            : // severity. On Windows, the message is read from a pipe handle. On other
     271                 :            : // platforms, it is read from a file descriptor.
     272                 :          0 : static void FailFromInternalError(int fd) {
     273                 :          0 :   Message error;
     274                 :            :   char buffer[256];
     275                 :            :   int num_read;
     276                 :            : 
     277   [ #  #  #  # ]:          0 :   do {
                 [ #  # ]
     278 [ #  # ][ #  # ]:          0 :     while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
     279                 :          0 :       buffer[num_read] = '\0';
     280         [ #  # ]:          0 :       error << buffer;
     281                 :            :     }
     282                 :          0 :   } while (num_read == -1 && errno == EINTR);
     283                 :            : 
     284         [ #  # ]:          0 :   if (num_read == 0) {
     285 [ #  # ][ #  # ]:          0 :     GTEST_LOG_(FATAL) << error.GetString();
         [ #  # ][ #  # ]
     286                 :            :   } else {
     287                 :          0 :     const int last_error = errno;
     288 [ #  # ][ #  # ]:          0 :     GTEST_LOG_(FATAL) << "Error while reading death test internal: "
                 [ #  # ]
     289 [ #  # ][ #  # ]:          0 :                       << GetLastErrnoDescription() << " [" << last_error << "]";
         [ #  # ][ #  # ]
                 [ #  # ]
     290                 :          0 :   }
     291                 :          0 : }
     292                 :            : 
     293                 :            : // Death test constructor.  Increments the running death test count
     294                 :            : // for the current test.
     295                 :          0 : DeathTest::DeathTest() {
     296                 :          0 :   TestInfo* const info = GetUnitTestImpl()->current_test_info();
     297         [ #  # ]:          0 :   if (info == NULL) {
     298                 :            :     DeathTestAbort("Cannot run a death test outside of a TEST or "
     299         [ #  # ]:          0 :                    "TEST_F construct");
     300                 :            :   }
     301                 :          0 : }
     302                 :            : 
     303                 :            : // Creates and returns a death test by dispatching to the current
     304                 :            : // death test factory.
     305                 :          0 : bool DeathTest::Create(const char* statement, const RE* regex,
     306                 :            :                        const char* file, int line, DeathTest** test) {
     307                 :          0 :   return GetUnitTestImpl()->death_test_factory()->Create(
     308                 :          0 :       statement, regex, file, line, test);
     309                 :            : }
     310                 :            : 
     311                 :          0 : const char* DeathTest::LastMessage() {
     312                 :          0 :   return last_death_test_message_.c_str();
     313                 :            : }
     314                 :            : 
     315                 :          0 : void DeathTest::set_last_death_test_message(const String& message) {
     316                 :          0 :   last_death_test_message_ = message;
     317                 :          0 : }
     318                 :            : 
     319                 :          4 : String DeathTest::last_death_test_message_;
     320                 :            : 
     321                 :            : // Provides cross platform implementation for some death functionality.
     322                 :            : class DeathTestImpl : public DeathTest {
     323                 :            :  protected:
     324                 :          0 :   DeathTestImpl(const char* a_statement, const RE* a_regex)
     325                 :            :       : statement_(a_statement),
     326                 :            :         regex_(a_regex),
     327                 :            :         spawned_(false),
     328                 :            :         status_(-1),
     329                 :            :         outcome_(IN_PROGRESS),
     330                 :            :         read_fd_(-1),
     331                 :          0 :         write_fd_(-1) {}
     332                 :            : 
     333                 :            :   // read_fd_ is expected to be closed and cleared by a derived class.
     334 [ #  # ][ #  # ]:          0 :   ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     335                 :            : 
     336                 :            :   void Abort(AbortReason reason);
     337                 :            :   virtual bool Passed(bool status_ok);
     338                 :            : 
     339                 :          0 :   const char* statement() const { return statement_; }
     340                 :          0 :   const RE* regex() const { return regex_; }
     341                 :          0 :   bool spawned() const { return spawned_; }
     342                 :          0 :   void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
     343                 :          0 :   int status() const { return status_; }
     344                 :          0 :   void set_status(int a_status) { status_ = a_status; }
     345                 :          0 :   DeathTestOutcome outcome() const { return outcome_; }
     346                 :          0 :   void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
     347                 :          0 :   int read_fd() const { return read_fd_; }
     348                 :          0 :   void set_read_fd(int fd) { read_fd_ = fd; }
     349                 :          0 :   int write_fd() const { return write_fd_; }
     350                 :          0 :   void set_write_fd(int fd) { write_fd_ = fd; }
     351                 :            : 
     352                 :            :   // Called in the parent process only. Reads the result code of the death
     353                 :            :   // test child process via a pipe, interprets it to set the outcome_
     354                 :            :   // member, and closes read_fd_.  Outputs diagnostics and terminates in
     355                 :            :   // case of unexpected codes.
     356                 :            :   void ReadAndInterpretStatusByte();
     357                 :            : 
     358                 :            :  private:
     359                 :            :   // The textual content of the code this object is testing.  This class
     360                 :            :   // doesn't own this string and should not attempt to delete it.
     361                 :            :   const char* const statement_;
     362                 :            :   // The regular expression which test output must match.  DeathTestImpl
     363                 :            :   // doesn't own this object and should not attempt to delete it.
     364                 :            :   const RE* const regex_;
     365                 :            :   // True if the death test child process has been successfully spawned.
     366                 :            :   bool spawned_;
     367                 :            :   // The exit status of the child process.
     368                 :            :   int status_;
     369                 :            :   // How the death test concluded.
     370                 :            :   DeathTestOutcome outcome_;
     371                 :            :   // Descriptor to the read end of the pipe to the child process.  It is
     372                 :            :   // always -1 in the child process.  The child keeps its write end of the
     373                 :            :   // pipe in write_fd_.
     374                 :            :   int read_fd_;
     375                 :            :   // Descriptor to the child's write end of the pipe to the parent process.
     376                 :            :   // It is always -1 in the parent process.  The parent keeps its end of the
     377                 :            :   // pipe in read_fd_.
     378                 :            :   int write_fd_;
     379                 :            : };
     380                 :            : 
     381                 :            : // Called in the parent process only. Reads the result code of the death
     382                 :            : // test child process via a pipe, interprets it to set the outcome_
     383                 :            : // member, and closes read_fd_.  Outputs diagnostics and terminates in
     384                 :            : // case of unexpected codes.
     385                 :          0 : void DeathTestImpl::ReadAndInterpretStatusByte() {
     386                 :            :   char flag;
     387                 :            :   int bytes_read;
     388                 :            : 
     389                 :            :   // The read() here blocks until data is available (signifying the
     390                 :            :   // failure of the death test) or until the pipe is closed (signifying
     391                 :            :   // its success), so it's okay to call this in the parent before
     392                 :            :   // the child process has exited.
     393   [ #  #  #  # ]:          0 :   do {
                 [ #  # ]
     394                 :          0 :     bytes_read = posix::Read(read_fd(), &flag, 1);
     395                 :          0 :   } while (bytes_read == -1 && errno == EINTR);
     396                 :            : 
     397         [ #  # ]:          0 :   if (bytes_read == 0) {
     398                 :          0 :     set_outcome(DIED);
     399         [ #  # ]:          0 :   } else if (bytes_read == 1) {
     400   [ #  #  #  #  :          0 :     switch (flag) {
                      # ]
     401                 :            :       case kDeathTestReturned:
     402                 :          0 :         set_outcome(RETURNED);
     403                 :          0 :         break;
     404                 :            :       case kDeathTestThrew:
     405                 :          0 :         set_outcome(THREW);
     406                 :          0 :         break;
     407                 :            :       case kDeathTestLived:
     408                 :          0 :         set_outcome(LIVED);
     409                 :          0 :         break;
     410                 :            :       case kDeathTestInternalError:
     411                 :          0 :         FailFromInternalError(read_fd());  // Does not return.
     412                 :          0 :         break;
     413                 :            :       default:
     414         [ #  # ]:          0 :         GTEST_LOG_(FATAL) << "Death test child process reported "
     415         [ #  # ]:          0 :                           << "unexpected status byte ("
     416 [ #  # ][ #  # ]:          0 :                           << static_cast<unsigned int>(flag) << ")";
     417                 :            :     }
     418                 :            :   } else {
     419 [ #  # ][ #  # ]:          0 :     GTEST_LOG_(FATAL) << "Read from death test child process failed: "
                 [ #  # ]
     420         [ #  # ]:          0 :                       << GetLastErrnoDescription();
     421                 :            :   }
     422 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     423                 :          0 :   set_read_fd(-1);
     424                 :          0 : }
     425                 :            : 
     426                 :            : // Signals that the death test code which should have exited, didn't.
     427                 :            : // Should be called only in a death test child process.
     428                 :            : // Writes a status byte to the child's status file descriptor, then
     429                 :            : // calls _exit(1).
     430                 :          0 : void DeathTestImpl::Abort(AbortReason reason) {
     431                 :            :   // The parent process considers the death test to be a failure if
     432                 :            :   // it finds any data in our pipe.  So, here we write a single flag byte
     433                 :            :   // to the pipe, then exit.
     434                 :            :   const char status_ch =
     435                 :            :       reason == TEST_DID_NOT_DIE ? kDeathTestLived :
     436 [ #  # ][ #  # ]:          0 :       reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
     437                 :            : 
     438 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     439                 :            :   // We are leaking the descriptor here because on some platforms (i.e.,
     440                 :            :   // when built as Windows DLL), destructors of global objects will still
     441                 :            :   // run after calling _exit(). On such systems, write_fd_ will be
     442                 :            :   // indirectly closed from the destructor of UnitTestImpl, causing double
     443                 :            :   // close if it is also closed here. On debug configurations, double close
     444                 :            :   // may assert. As there are no in-process buffers to flush here, we are
     445                 :            :   // relying on the OS to close the descriptor after the process terminates
     446                 :            :   // when the destructors are not run.
     447                 :          0 :   _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
     448                 :            : }
     449                 :            : 
     450                 :            : // Returns an indented copy of stderr output for a death test.
     451                 :            : // This makes distinguishing death test output lines from regular log lines
     452                 :            : // much easier.
     453                 :          0 : static ::std::string FormatDeathTestOutput(const ::std::string& output) {
     454                 :          0 :   ::std::string ret;
     455                 :          0 :   for (size_t at = 0; ; ) {
     456         [ #  # ]:          0 :     const size_t line_end = output.find('\n', at);
     457         [ #  # ]:          0 :     ret += "[  DEATH   ] ";
     458         [ #  # ]:          0 :     if (line_end == ::std::string::npos) {
     459 [ #  # ][ #  # ]:          0 :       ret += output.substr(at);
                 [ #  # ]
     460                 :          0 :       break;
     461                 :            :     }
     462 [ #  # ][ #  # ]:          0 :     ret += output.substr(at, line_end + 1 - at);
                 [ #  # ]
     463                 :          0 :     at = line_end + 1;
     464                 :            :   }
     465                 :          0 :   return ret;
     466                 :            : }
     467                 :            : 
     468                 :            : // Assesses the success or failure of a death test, using both private
     469                 :            : // members which have previously been set, and one argument:
     470                 :            : //
     471                 :            : // Private data members:
     472                 :            : //   outcome:  An enumeration describing how the death test
     473                 :            : //             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
     474                 :            : //             fails in the latter three cases.
     475                 :            : //   status:   The exit status of the child process. On *nix, it is in the
     476                 :            : //             in the format specified by wait(2). On Windows, this is the
     477                 :            : //             value supplied to the ExitProcess() API or a numeric code
     478                 :            : //             of the exception that terminated the program.
     479                 :            : //   regex:    A regular expression object to be applied to
     480                 :            : //             the test's captured standard error output; the death test
     481                 :            : //             fails if it does not match.
     482                 :            : //
     483                 :            : // Argument:
     484                 :            : //   status_ok: true if exit_status is acceptable in the context of
     485                 :            : //              this particular death test, which fails if it is false
     486                 :            : //
     487                 :            : // Returns true iff all of the above conditions are met.  Otherwise, the
     488                 :            : // first failing condition, in the order given above, is the one that is
     489                 :            : // reported. Also sets the last death test message string.
     490                 :          0 : bool DeathTestImpl::Passed(bool status_ok) {
     491         [ #  # ]:          0 :   if (!spawned())
     492                 :          0 :     return false;
     493                 :            : 
     494                 :          0 :   const String error_message = GetCapturedStderr();
     495                 :            : 
     496                 :          0 :   bool success = false;
     497         [ #  # ]:          0 :   Message buffer;
     498                 :            : 
     499 [ #  # ][ #  # ]:          0 :   buffer << "Death test: " << statement() << "\n";
                 [ #  # ]
     500   [ #  #  #  #  :          0 :   switch (outcome()) {
                      # ]
     501                 :            :     case LIVED:
     502         [ #  # ]:          0 :       buffer << "    Result: failed to die.\n"
     503 [ #  # ][ #  # ]:          0 :              << " Error msg:\n" << FormatDeathTestOutput(error_message);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     504                 :          0 :       break;
     505                 :            :     case THREW:
     506         [ #  # ]:          0 :       buffer << "    Result: threw an exception.\n"
     507 [ #  # ][ #  # ]:          0 :              << " Error msg:\n" << FormatDeathTestOutput(error_message);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     508                 :          0 :       break;
     509                 :            :     case RETURNED:
     510         [ #  # ]:          0 :       buffer << "    Result: illegal return in test statement.\n"
     511 [ #  # ][ #  # ]:          0 :              << " Error msg:\n" << FormatDeathTestOutput(error_message);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     512                 :          0 :       break;
     513                 :            :     case DIED:
     514         [ #  # ]:          0 :       if (status_ok) {
     515         [ #  # ]:          0 :         const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
     516         [ #  # ]:          0 :         if (matched) {
     517                 :          0 :           success = true;
     518                 :            :         } else {
     519         [ #  # ]:          0 :           buffer << "    Result: died but not with expected error.\n"
     520 [ #  # ][ #  # ]:          0 :                  << "  Expected: " << regex()->pattern() << "\n"
                 [ #  # ]
     521 [ #  # ][ #  # ]:          0 :                  << "Actual msg:\n" << FormatDeathTestOutput(error_message);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     522                 :            :         }
     523                 :            :       } else {
     524         [ #  # ]:          0 :         buffer << "    Result: died but not with expected exit code:\n"
     525 [ #  # ][ #  # ]:          0 :                << "            " << ExitSummary(status()) << "\n"
         [ #  # ][ #  # ]
     526 [ #  # ][ #  # ]:          0 :                << "Actual msg:\n" << FormatDeathTestOutput(error_message);
                 [ #  # ]
           [ #  #  #  # ]
                 [ #  # ]
     527                 :            :       }
     528                 :          0 :       break;
     529                 :            :     case IN_PROGRESS:
     530                 :            :     default:
     531 [ #  # ][ #  # ]:          0 :       GTEST_LOG_(FATAL)
     532         [ #  # ]:          0 :           << "DeathTest::Passed somehow called before conclusion of test";
     533                 :            :   }
     534                 :            : 
     535 [ #  # ][ #  # ]:          0 :   DeathTest::set_last_death_test_message(buffer.GetString());
     536         [ #  # ]:          0 :   return success;
     537                 :            : }
     538                 :            : 
     539                 :            : # if GTEST_OS_WINDOWS
     540                 :            : // WindowsDeathTest implements death tests on Windows. Due to the
     541                 :            : // specifics of starting new processes on Windows, death tests there are
     542                 :            : // always threadsafe, and Google Test considers the
     543                 :            : // --gtest_death_test_style=fast setting to be equivalent to
     544                 :            : // --gtest_death_test_style=threadsafe there.
     545                 :            : //
     546                 :            : // A few implementation notes:  Like the Linux version, the Windows
     547                 :            : // implementation uses pipes for child-to-parent communication. But due to
     548                 :            : // the specifics of pipes on Windows, some extra steps are required:
     549                 :            : //
     550                 :            : // 1. The parent creates a communication pipe and stores handles to both
     551                 :            : //    ends of it.
     552                 :            : // 2. The parent starts the child and provides it with the information
     553                 :            : //    necessary to acquire the handle to the write end of the pipe.
     554                 :            : // 3. The child acquires the write end of the pipe and signals the parent
     555                 :            : //    using a Windows event.
     556                 :            : // 4. Now the parent can release the write end of the pipe on its side. If
     557                 :            : //    this is done before step 3, the object's reference count goes down to
     558                 :            : //    0 and it is destroyed, preventing the child from acquiring it. The
     559                 :            : //    parent now has to release it, or read operations on the read end of
     560                 :            : //    the pipe will not return when the child terminates.
     561                 :            : // 5. The parent reads child's output through the pipe (outcome code and
     562                 :            : //    any possible error messages) from the pipe, and its stderr and then
     563                 :            : //    determines whether to fail the test.
     564                 :            : //
     565                 :            : // Note: to distinguish Win32 API calls from the local method and function
     566                 :            : // calls, the former are explicitly resolved in the global namespace.
     567                 :            : //
     568                 :            : class WindowsDeathTest : public DeathTestImpl {
     569                 :            :  public:
     570                 :            :   WindowsDeathTest(const char* a_statement,
     571                 :            :                    const RE* a_regex,
     572                 :            :                    const char* file,
     573                 :            :                    int line)
     574                 :            :       : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
     575                 :            : 
     576                 :            :   // All of these virtual functions are inherited from DeathTest.
     577                 :            :   virtual int Wait();
     578                 :            :   virtual TestRole AssumeRole();
     579                 :            : 
     580                 :            :  private:
     581                 :            :   // The name of the file in which the death test is located.
     582                 :            :   const char* const file_;
     583                 :            :   // The line number on which the death test is located.
     584                 :            :   const int line_;
     585                 :            :   // Handle to the write end of the pipe to the child process.
     586                 :            :   AutoHandle write_handle_;
     587                 :            :   // Child process handle.
     588                 :            :   AutoHandle child_handle_;
     589                 :            :   // Event the child process uses to signal the parent that it has
     590                 :            :   // acquired the handle to the write end of the pipe. After seeing this
     591                 :            :   // event the parent can release its own handles to make sure its
     592                 :            :   // ReadFile() calls return when the child terminates.
     593                 :            :   AutoHandle event_handle_;
     594                 :            : };
     595                 :            : 
     596                 :            : // Waits for the child in a death test to exit, returning its exit
     597                 :            : // status, or 0 if no child process exists.  As a side effect, sets the
     598                 :            : // outcome data member.
     599                 :            : int WindowsDeathTest::Wait() {
     600                 :            :   if (!spawned())
     601                 :            :     return 0;
     602                 :            : 
     603                 :            :   // Wait until the child either signals that it has acquired the write end
     604                 :            :   // of the pipe or it dies.
     605                 :            :   const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
     606                 :            :   switch (::WaitForMultipleObjects(2,
     607                 :            :                                    wait_handles,
     608                 :            :                                    FALSE,  // Waits for any of the handles.
     609                 :            :                                    INFINITE)) {
     610                 :            :     case WAIT_OBJECT_0:
     611                 :            :     case WAIT_OBJECT_0 + 1:
     612                 :            :       break;
     613                 :            :     default:
     614                 :            :       GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
     615                 :            :   }
     616                 :            : 
     617                 :            :   // The child has acquired the write end of the pipe or exited.
     618                 :            :   // We release the handle on our side and continue.
     619                 :            :   write_handle_.Reset();
     620                 :            :   event_handle_.Reset();
     621                 :            : 
     622                 :            :   ReadAndInterpretStatusByte();
     623                 :            : 
     624                 :            :   // Waits for the child process to exit if it haven't already. This
     625                 :            :   // returns immediately if the child has already exited, regardless of
     626                 :            :   // whether previous calls to WaitForMultipleObjects synchronized on this
     627                 :            :   // handle or not.
     628                 :            :   GTEST_DEATH_TEST_CHECK_(
     629                 :            :       WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
     630                 :            :                                              INFINITE));
     631                 :            :   DWORD status_code;
     632                 :            :   GTEST_DEATH_TEST_CHECK_(
     633                 :            :       ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
     634                 :            :   child_handle_.Reset();
     635                 :            :   set_status(static_cast<int>(status_code));
     636                 :            :   return status();
     637                 :            : }
     638                 :            : 
     639                 :            : // The AssumeRole process for a Windows death test.  It creates a child
     640                 :            : // process with the same executable as the current process to run the
     641                 :            : // death test.  The child process is given the --gtest_filter and
     642                 :            : // --gtest_internal_run_death_test flags such that it knows to run the
     643                 :            : // current death test only.
     644                 :            : DeathTest::TestRole WindowsDeathTest::AssumeRole() {
     645                 :            :   const UnitTestImpl* const impl = GetUnitTestImpl();
     646                 :            :   const InternalRunDeathTestFlag* const flag =
     647                 :            :       impl->internal_run_death_test_flag();
     648                 :            :   const TestInfo* const info = impl->current_test_info();
     649                 :            :   const int death_test_index = info->result()->death_test_count();
     650                 :            : 
     651                 :            :   if (flag != NULL) {
     652                 :            :     // ParseInternalRunDeathTestFlag() has performed all the necessary
     653                 :            :     // processing.
     654                 :            :     set_write_fd(flag->write_fd());
     655                 :            :     return EXECUTE_TEST;
     656                 :            :   }
     657                 :            : 
     658                 :            :   // WindowsDeathTest uses an anonymous pipe to communicate results of
     659                 :            :   // a death test.
     660                 :            :   SECURITY_ATTRIBUTES handles_are_inheritable = {
     661                 :            :     sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
     662                 :            :   HANDLE read_handle, write_handle;
     663                 :            :   GTEST_DEATH_TEST_CHECK_(
     664                 :            :       ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
     665                 :            :                    0)  // Default buffer size.
     666                 :            :       != FALSE);
     667                 :            :   set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
     668                 :            :                                 O_RDONLY));
     669                 :            :   write_handle_.Reset(write_handle);
     670                 :            :   event_handle_.Reset(::CreateEvent(
     671                 :            :       &handles_are_inheritable,
     672                 :            :       TRUE,    // The event will automatically reset to non-signaled state.
     673                 :            :       FALSE,   // The initial state is non-signalled.
     674                 :            :       NULL));  // The even is unnamed.
     675                 :            :   GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
     676                 :            :   const String filter_flag = String::Format("--%s%s=%s.%s",
     677                 :            :                                             GTEST_FLAG_PREFIX_, kFilterFlag,
     678                 :            :                                             info->test_case_name(),
     679                 :            :                                             info->name());
     680                 :            :   const String internal_flag = String::Format(
     681                 :            :     "--%s%s=%s|%d|%d|%u|%Iu|%Iu",
     682                 :            :       GTEST_FLAG_PREFIX_,
     683                 :            :       kInternalRunDeathTestFlag,
     684                 :            :       file_, line_,
     685                 :            :       death_test_index,
     686                 :            :       static_cast<unsigned int>(::GetCurrentProcessId()),
     687                 :            :       // size_t has the same with as pointers on both 32-bit and 64-bit
     688                 :            :       // Windows platforms.
     689                 :            :       // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
     690                 :            :       reinterpret_cast<size_t>(write_handle),
     691                 :            :       reinterpret_cast<size_t>(event_handle_.Get()));
     692                 :            : 
     693                 :            :   char executable_path[_MAX_PATH + 1];  // NOLINT
     694                 :            :   GTEST_DEATH_TEST_CHECK_(
     695                 :            :       _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
     696                 :            :                                             executable_path,
     697                 :            :                                             _MAX_PATH));
     698                 :            : 
     699                 :            :   String command_line = String::Format("%s %s \"%s\"",
     700                 :            :                                        ::GetCommandLineA(),
     701                 :            :                                        filter_flag.c_str(),
     702                 :            :                                        internal_flag.c_str());
     703                 :            : 
     704                 :            :   DeathTest::set_last_death_test_message("");
     705                 :            : 
     706                 :            :   CaptureStderr();
     707                 :            :   // Flush the log buffers since the log streams are shared with the child.
     708                 :            :   FlushInfoLog();
     709                 :            : 
     710                 :            :   // The child process will share the standard handles with the parent.
     711                 :            :   STARTUPINFOA startup_info;
     712                 :            :   memset(&startup_info, 0, sizeof(STARTUPINFO));
     713                 :            :   startup_info.dwFlags = STARTF_USESTDHANDLES;
     714                 :            :   startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
     715                 :            :   startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
     716                 :            :   startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
     717                 :            : 
     718                 :            :   PROCESS_INFORMATION process_info;
     719                 :            :   GTEST_DEATH_TEST_CHECK_(::CreateProcessA(
     720                 :            :       executable_path,
     721                 :            :       const_cast<char*>(command_line.c_str()),
     722                 :            :       NULL,   // Retuned process handle is not inheritable.
     723                 :            :       NULL,   // Retuned thread handle is not inheritable.
     724                 :            :       TRUE,   // Child inherits all inheritable handles (for write_handle_).
     725                 :            :       0x0,    // Default creation flags.
     726                 :            :       NULL,   // Inherit the parent's environment.
     727                 :            :       UnitTest::GetInstance()->original_working_dir(),
     728                 :            :       &startup_info,
     729                 :            :       &process_info) != FALSE);
     730                 :            :   child_handle_.Reset(process_info.hProcess);
     731                 :            :   ::CloseHandle(process_info.hThread);
     732                 :            :   set_spawned(true);
     733                 :            :   return OVERSEE_TEST;
     734                 :            : }
     735                 :            : # else  // We are not on Windows.
     736                 :            : 
     737                 :            : // ForkingDeathTest provides implementations for most of the abstract
     738                 :            : // methods of the DeathTest interface.  Only the AssumeRole method is
     739                 :            : // left undefined.
     740         [ #  # ]:          0 : class ForkingDeathTest : public DeathTestImpl {
     741                 :            :  public:
     742                 :            :   ForkingDeathTest(const char* statement, const RE* regex);
     743                 :            : 
     744                 :            :   // All of these virtual functions are inherited from DeathTest.
     745                 :            :   virtual int Wait();
     746                 :            : 
     747                 :            :  protected:
     748                 :          0 :   void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
     749                 :            : 
     750                 :            :  private:
     751                 :            :   // PID of child process during death test; 0 in the child process itself.
     752                 :            :   pid_t child_pid_;
     753                 :            : };
     754                 :            : 
     755                 :            : // Constructs a ForkingDeathTest.
     756                 :          0 : ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
     757                 :            :     : DeathTestImpl(a_statement, a_regex),
     758                 :          0 :       child_pid_(-1) {}
     759                 :            : 
     760                 :            : // Waits for the child in a death test to exit, returning its exit
     761                 :            : // status, or 0 if no child process exists.  As a side effect, sets the
     762                 :            : // outcome data member.
     763                 :          0 : int ForkingDeathTest::Wait() {
     764         [ #  # ]:          0 :   if (!spawned())
     765                 :          0 :     return 0;
     766                 :            : 
     767                 :          0 :   ReadAndInterpretStatusByte();
     768                 :            : 
     769                 :            :   int status_value;
     770 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     771                 :          0 :   set_status(status_value);
     772                 :          0 :   return status_value;
     773                 :            : }
     774                 :            : 
     775                 :            : // A concrete death test class that forks, then immediately runs the test
     776                 :            : // in the child process.
     777         [ #  # ]:          0 : class NoExecDeathTest : public ForkingDeathTest {
     778                 :            :  public:
     779                 :          0 :   NoExecDeathTest(const char* a_statement, const RE* a_regex) :
     780                 :          0 :       ForkingDeathTest(a_statement, a_regex) { }
     781                 :            :   virtual TestRole AssumeRole();
     782                 :            : };
     783                 :            : 
     784                 :            : // The AssumeRole process for a fork-and-run death test.  It implements a
     785                 :            : // straightforward fork, with a simple pipe to transmit the status byte.
     786                 :          0 : DeathTest::TestRole NoExecDeathTest::AssumeRole() {
     787                 :          0 :   const size_t thread_count = GetThreadCount();
     788         [ #  # ]:          0 :   if (thread_count != 1) {
     789 [ #  # ][ #  # ]:          0 :     GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
                 [ #  # ]
     790                 :            :   }
     791                 :            : 
     792                 :            :   int pipe_fd[2];
     793 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
                 [ #  # ]
     794                 :            : 
     795         [ #  # ]:          0 :   DeathTest::set_last_death_test_message("");
     796                 :          0 :   CaptureStderr();
     797                 :            :   // When we fork the process below, the log file buffers are copied, but the
     798                 :            :   // file descriptors are shared.  We flush all log files here so that closing
     799                 :            :   // the file descriptors in the child process doesn't throw off the
     800                 :            :   // synchronization between descriptors and buffers in the parent process.
     801                 :            :   // This is as close to the fork as possible to avoid a race condition in case
     802                 :            :   // there are multiple threads running before the death test, and another
     803                 :            :   // thread writes to the log file.
     804                 :          0 :   FlushInfoLog();
     805                 :            : 
     806                 :          0 :   const pid_t child_pid = fork();
     807 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
                 [ #  # ]
     808                 :          0 :   set_child_pid(child_pid);
     809         [ #  # ]:          0 :   if (child_pid == 0) {
     810 [ #  # ][ #  # ]:          0 :     GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     811                 :          0 :     set_write_fd(pipe_fd[1]);
     812                 :            :     // Redirects all logging to stderr in the child process to prevent
     813                 :            :     // concurrent writes to the log files.  We capture stderr in the parent
     814                 :            :     // process and append the child process' output to a log.
     815                 :          0 :     LogToStderr();
     816                 :            :     // Event forwarding to the listeners of event listener API mush be shut
     817                 :            :     // down in death test subprocesses.
     818                 :          0 :     GetUnitTestImpl()->listeners()->SuppressEventForwarding();
     819                 :          0 :     return EXECUTE_TEST;
     820                 :            :   } else {
     821 [ #  # ][ #  # ]:          0 :     GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     822                 :          0 :     set_read_fd(pipe_fd[0]);
     823                 :          0 :     set_spawned(true);
     824                 :          0 :     return OVERSEE_TEST;
     825                 :            :   }
     826                 :            : }
     827                 :            : 
     828                 :            : // A concrete death test class that forks and re-executes the main
     829                 :            : // program from the beginning, with command-line flags set that cause
     830                 :            : // only this specific death test to be run.
     831         [ #  # ]:          0 : class ExecDeathTest : public ForkingDeathTest {
     832                 :            :  public:
     833                 :          0 :   ExecDeathTest(const char* a_statement, const RE* a_regex,
     834                 :            :                 const char* file, int line) :
     835                 :          0 :       ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
     836                 :            :   virtual TestRole AssumeRole();
     837                 :            :  private:
     838                 :            :   // The name of the file in which the death test is located.
     839                 :            :   const char* const file_;
     840                 :            :   // The line number on which the death test is located.
     841                 :            :   const int line_;
     842                 :            : };
     843                 :            : 
     844                 :            : // Utility class for accumulating command-line arguments.
     845                 :            : class Arguments {
     846                 :            :  public:
     847                 :          0 :   Arguments() {
     848         [ #  # ]:          0 :     args_.push_back(NULL);
     849                 :          0 :   }
     850                 :            : 
     851                 :          0 :   ~Arguments() {
     852 [ #  # ][ #  # ]:          0 :     for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
         [ #  # ][ #  # ]
     853                 :            :          ++i) {
     854                 :          0 :       free(*i);
     855                 :            :     }
     856                 :          0 :   }
     857                 :          0 :   void AddArgument(const char* argument) {
     858                 :          0 :     args_.insert(args_.end() - 1, posix::StrDup(argument));
     859                 :          0 :   }
     860                 :            : 
     861                 :            :   template <typename Str>
     862                 :          0 :   void AddArguments(const ::std::vector<Str>& arguments) {
     863         [ #  # ]:          0 :     for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
     864                 :            :          i != arguments.end();
     865                 :            :          ++i) {
     866                 :          0 :       args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
     867                 :            :     }
     868                 :          0 :   }
     869                 :          0 :   char* const* Argv() {
     870                 :          0 :     return &args_[0];
     871                 :            :   }
     872                 :            :  private:
     873                 :            :   std::vector<char*> args_;
     874                 :            : };
     875                 :            : 
     876                 :            : // A struct that encompasses the arguments to the child process of a
     877                 :            : // threadsafe-style death test process.
     878                 :            : struct ExecDeathTestArgs {
     879                 :            :   char* const* argv;  // Command-line arguments for the child's call to exec
     880                 :            :   int close_fd;       // File descriptor to close; the read end of a pipe
     881                 :            : };
     882                 :            : 
     883                 :            : #  if GTEST_OS_MAC
     884                 :            : inline char** GetEnviron() {
     885                 :            :   // When Google Test is built as a framework on MacOS X, the environ variable
     886                 :            :   // is unavailable. Apple's documentation (man environ) recommends using
     887                 :            :   // _NSGetEnviron() instead.
     888                 :            :   return *_NSGetEnviron();
     889                 :            : }
     890                 :            : #  else
     891                 :            : // Some POSIX platforms expect you to declare environ. extern "C" makes
     892                 :            : // it reside in the global namespace.
     893                 :            : extern "C" char** environ;
     894                 :          0 : inline char** GetEnviron() { return environ; }
     895                 :            : #  endif  // GTEST_OS_MAC
     896                 :            : 
     897                 :            : // The main function for a threadsafe-style death test child process.
     898                 :            : // This function is called in a clone()-ed process and thus must avoid
     899                 :            : // any potentially unsafe operations like malloc or libc functions.
     900                 :          0 : static int ExecDeathTestChildMain(void* child_arg) {
     901                 :          0 :   ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
     902 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     903                 :            : 
     904                 :            :   // We need to execute the test program in the same environment where
     905                 :            :   // it was originally invoked.  Therefore we change to the original
     906                 :            :   // working directory first.
     907                 :            :   const char* const original_dir =
     908                 :          0 :       UnitTest::GetInstance()->original_working_dir();
     909                 :            :   // We can safely call chdir() as it's a direct system call.
     910         [ #  # ]:          0 :   if (chdir(original_dir) != 0) {
     911                 :            :     DeathTestAbort(String::Format("chdir(\"%s\") failed: %s",
     912                 :            :                                   original_dir,
     913 [ #  # ][ #  # ]:          0 :                                   GetLastErrnoDescription().c_str()));
     914                 :          0 :     return EXIT_FAILURE;
     915                 :            :   }
     916                 :            : 
     917                 :            :   // We can safely call execve() as it's a direct system call.  We
     918                 :            :   // cannot use execvp() as it's a libc function and thus potentially
     919                 :            :   // unsafe.  Since execve() doesn't search the PATH, the user must
     920                 :            :   // invoke the test program via a valid path that contains at least
     921                 :            :   // one path separator.
     922                 :          0 :   execve(args->argv[0], args->argv, GetEnviron());
     923                 :            :   DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s",
     924                 :          0 :                                 args->argv[0],
     925                 :            :                                 original_dir,
     926 [ #  # ][ #  # ]:          0 :                                 GetLastErrnoDescription().c_str()));
     927                 :          0 :   return EXIT_FAILURE;
     928                 :            : }
     929                 :            : 
     930                 :            : // Two utility routines that together determine the direction the stack
     931                 :            : // grows.
     932                 :            : // This could be accomplished more elegantly by a single recursive
     933                 :            : // function, but we want to guard against the unlikely possibility of
     934                 :            : // a smart compiler optimizing the recursion away.
     935                 :            : //
     936                 :            : // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
     937                 :            : // StackLowerThanAddress into StackGrowsDown, which then doesn't give
     938                 :            : // correct answer.
     939                 :            : bool StackLowerThanAddress(const void* ptr) GTEST_NO_INLINE_;
     940                 :          0 : bool StackLowerThanAddress(const void* ptr) {
     941                 :            :   int dummy;
     942                 :          0 :   return &dummy < ptr;
     943                 :            : }
     944                 :            : 
     945                 :          0 : bool StackGrowsDown() {
     946                 :            :   int dummy;
     947                 :          0 :   return StackLowerThanAddress(&dummy);
     948                 :            : }
     949                 :            : 
     950                 :            : // A threadsafe implementation of fork(2) for threadsafe-style death tests
     951                 :            : // that uses clone(2).  It dies with an error message if anything goes
     952                 :            : // wrong.
     953                 :          0 : static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
     954                 :          0 :   ExecDeathTestArgs args = { argv, close_fd };
     955                 :          0 :   pid_t child_pid = -1;
     956                 :            : 
     957                 :            : #  if GTEST_HAS_CLONE
     958                 :          0 :   const bool use_fork = GTEST_FLAG(death_test_use_fork);
     959                 :            : 
     960         [ #  # ]:          0 :   if (!use_fork) {
     961 [ #  # ][ #  # ]:          0 :     static const bool stack_grows_down = StackGrowsDown();
     962                 :          0 :     const size_t stack_size = getpagesize();
     963                 :            :     // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
     964                 :            :     void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
     965                 :          0 :                              MAP_ANON | MAP_PRIVATE, -1, 0);
     966 [ #  # ][ #  # ]:          0 :     GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
                 [ #  # ]
     967                 :            :     void* const stack_top =
     968         [ #  # ]:          0 :         static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0);
     969                 :            : 
     970                 :          0 :     child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
     971                 :            : 
     972 [ #  # ][ #  # ]:          0 :     GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
                 [ #  # ]
     973                 :            :   }
     974                 :            : #  else
     975                 :            :   const bool use_fork = true;
     976                 :            : #  endif  // GTEST_HAS_CLONE
     977                 :            : 
     978 [ #  # ][ #  # ]:          0 :   if (use_fork && (child_pid = fork()) == 0) {
                 [ #  # ]
     979                 :          0 :       ExecDeathTestChildMain(&args);
     980                 :          0 :       _exit(0);
     981                 :            :   }
     982                 :            : 
     983 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
                 [ #  # ]
     984                 :          0 :   return child_pid;
     985                 :            : }
     986                 :            : 
     987                 :            : // The AssumeRole process for a fork-and-exec death test.  It re-executes the
     988                 :            : // main program from the beginning, setting the --gtest_filter
     989                 :            : // and --gtest_internal_run_death_test flags to cause only the current
     990                 :            : // death test to be re-run.
     991                 :          0 : DeathTest::TestRole ExecDeathTest::AssumeRole() {
     992                 :          0 :   const UnitTestImpl* const impl = GetUnitTestImpl();
     993                 :            :   const InternalRunDeathTestFlag* const flag =
     994                 :          0 :       impl->internal_run_death_test_flag();
     995                 :          0 :   const TestInfo* const info = impl->current_test_info();
     996                 :          0 :   const int death_test_index = info->result()->death_test_count();
     997                 :            : 
     998         [ #  # ]:          0 :   if (flag != NULL) {
     999                 :          0 :     set_write_fd(flag->write_fd());
    1000                 :          0 :     return EXECUTE_TEST;
    1001                 :            :   }
    1002                 :            : 
    1003                 :            :   int pipe_fd[2];
    1004 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
                 [ #  # ]
    1005                 :            :   // Clear the close-on-exec flag on the write end of the pipe, lest
    1006                 :            :   // it be closed when the child process does an exec:
    1007 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
                 [ #  # ]
    1008                 :            : 
    1009                 :            :   const String filter_flag =
    1010                 :            :       String::Format("--%s%s=%s.%s",
    1011                 :            :                      GTEST_FLAG_PREFIX_, kFilterFlag,
    1012                 :          0 :                      info->test_case_name(), info->name());
    1013                 :            :   const String internal_flag =
    1014                 :            :       String::Format("--%s%s=%s|%d|%d|%d",
    1015                 :            :                      GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag,
    1016         [ #  # ]:          0 :                      file_, line_, death_test_index, pipe_fd[1]);
    1017         [ #  # ]:          0 :   Arguments args;
    1018         [ #  # ]:          0 :   args.AddArguments(GetArgvs());
    1019         [ #  # ]:          0 :   args.AddArgument(filter_flag.c_str());
    1020         [ #  # ]:          0 :   args.AddArgument(internal_flag.c_str());
    1021                 :            : 
    1022 [ #  # ][ #  # ]:          0 :   DeathTest::set_last_death_test_message("");
    1023                 :            : 
    1024         [ #  # ]:          0 :   CaptureStderr();
    1025                 :            :   // See the comment in NoExecDeathTest::AssumeRole for why the next line
    1026                 :            :   // is necessary.
    1027         [ #  # ]:          0 :   FlushInfoLog();
    1028                 :            : 
    1029 [ #  # ][ #  # ]:          0 :   const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]);
    1030 [ #  # ][ #  # ]:          0 :   GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
    1031                 :          0 :   set_child_pid(child_pid);
    1032                 :          0 :   set_read_fd(pipe_fd[0]);
    1033                 :          0 :   set_spawned(true);
    1034         [ #  # ]:          0 :   return OVERSEE_TEST;
    1035                 :            : }
    1036                 :            : 
    1037                 :            : # endif  // !GTEST_OS_WINDOWS
    1038                 :            : 
    1039                 :            : // Creates a concrete DeathTest-derived class that depends on the
    1040                 :            : // --gtest_death_test_style flag, and sets the pointer pointed to
    1041                 :            : // by the "test" argument to its address.  If the test should be
    1042                 :            : // skipped, sets that pointer to NULL.  Returns true, unless the
    1043                 :            : // flag is set to an invalid value.
    1044                 :          0 : bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
    1045                 :            :                                      const char* file, int line,
    1046                 :            :                                      DeathTest** test) {
    1047                 :          0 :   UnitTestImpl* const impl = GetUnitTestImpl();
    1048                 :            :   const InternalRunDeathTestFlag* const flag =
    1049                 :          0 :       impl->internal_run_death_test_flag();
    1050                 :            :   const int death_test_index = impl->current_test_info()
    1051                 :          0 :       ->increment_death_test_count();
    1052                 :            : 
    1053         [ #  # ]:          0 :   if (flag != NULL) {
    1054         [ #  # ]:          0 :     if (death_test_index > flag->index()) {
    1055                 :            :       DeathTest::set_last_death_test_message(String::Format(
    1056                 :            :           "Death test count (%d) somehow exceeded expected maximum (%d)",
    1057         [ #  # ]:          0 :           death_test_index, flag->index()));
    1058                 :          0 :       return false;
    1059                 :            :     }
    1060                 :            : 
    1061 [ #  # ][ #  # ]:          0 :     if (!(flag->file() == file && flag->line() == line &&
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1062 [ #  # ][ #  # ]:          0 :           flag->index() == death_test_index)) {
    1063                 :          0 :       *test = NULL;
    1064                 :          0 :       return true;
    1065                 :            :     }
    1066                 :            :   }
    1067                 :            : 
    1068                 :            : # if GTEST_OS_WINDOWS
    1069                 :            : 
    1070                 :            :   if (GTEST_FLAG(death_test_style) == "threadsafe" ||
    1071                 :            :       GTEST_FLAG(death_test_style) == "fast") {
    1072                 :            :     *test = new WindowsDeathTest(statement, regex, file, line);
    1073                 :            :   }
    1074                 :            : 
    1075                 :            : # else
    1076                 :            : 
    1077         [ #  # ]:          0 :   if (GTEST_FLAG(death_test_style) == "threadsafe") {
    1078         [ #  # ]:          0 :     *test = new ExecDeathTest(statement, regex, file, line);
    1079         [ #  # ]:          0 :   } else if (GTEST_FLAG(death_test_style) == "fast") {
    1080         [ #  # ]:          0 :     *test = new NoExecDeathTest(statement, regex);
    1081                 :            :   }
    1082                 :            : 
    1083                 :            : # endif  // GTEST_OS_WINDOWS
    1084                 :            : 
    1085                 :            :   else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
    1086                 :            :     DeathTest::set_last_death_test_message(String::Format(
    1087                 :            :         "Unknown death test style \"%s\" encountered",
    1088         [ #  # ]:          0 :         GTEST_FLAG(death_test_style).c_str()));
    1089                 :          0 :     return false;
    1090                 :            :   }
    1091                 :            : 
    1092                 :          0 :   return true;
    1093                 :            : }
    1094                 :            : 
    1095                 :            : // Splits a given string on a given delimiter, populating a given
    1096                 :            : // vector with the fields.  GTEST_HAS_DEATH_TEST implies that we have
    1097                 :            : // ::std::string, so we can use it here.
    1098                 :          0 : static void SplitString(const ::std::string& str, char delimiter,
    1099                 :            :                         ::std::vector< ::std::string>* dest) {
    1100                 :          0 :   ::std::vector< ::std::string> parsed;
    1101                 :          0 :   ::std::string::size_type pos = 0;
    1102 [ #  # ][ #  # ]:          0 :   while (::testing::internal::AlwaysTrue()) {
    1103         [ #  # ]:          0 :     const ::std::string::size_type colon = str.find(delimiter, pos);
    1104         [ #  # ]:          0 :     if (colon == ::std::string::npos) {
    1105 [ #  # ][ #  # ]:          0 :       parsed.push_back(str.substr(pos));
                 [ #  # ]
    1106                 :          0 :       break;
    1107                 :            :     } else {
    1108 [ #  # ][ #  # ]:          0 :       parsed.push_back(str.substr(pos, colon - pos));
                 [ #  # ]
    1109                 :          0 :       pos = colon + 1;
    1110                 :            :     }
    1111                 :            :   }
    1112         [ #  # ]:          0 :   dest->swap(parsed);
    1113                 :          0 : }
    1114                 :            : 
    1115                 :            : # if GTEST_OS_WINDOWS
    1116                 :            : // Recreates the pipe and event handles from the provided parameters,
    1117                 :            : // signals the event, and returns a file descriptor wrapped around the pipe
    1118                 :            : // handle. This function is called in the child process only.
    1119                 :            : int GetStatusFileDescriptor(unsigned int parent_process_id,
    1120                 :            :                             size_t write_handle_as_size_t,
    1121                 :            :                             size_t event_handle_as_size_t) {
    1122                 :            :   AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
    1123                 :            :                                                    FALSE,  // Non-inheritable.
    1124                 :            :                                                    parent_process_id));
    1125                 :            :   if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
    1126                 :            :     DeathTestAbort(String::Format("Unable to open parent process %u",
    1127                 :            :                                   parent_process_id));
    1128                 :            :   }
    1129                 :            : 
    1130                 :            :   // TODO(vladl@google.com): Replace the following check with a
    1131                 :            :   // compile-time assertion when available.
    1132                 :            :   GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
    1133                 :            : 
    1134                 :            :   const HANDLE write_handle =
    1135                 :            :       reinterpret_cast<HANDLE>(write_handle_as_size_t);
    1136                 :            :   HANDLE dup_write_handle;
    1137                 :            : 
    1138                 :            :   // The newly initialized handle is accessible only in in the parent
    1139                 :            :   // process. To obtain one accessible within the child, we need to use
    1140                 :            :   // DuplicateHandle.
    1141                 :            :   if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
    1142                 :            :                          ::GetCurrentProcess(), &dup_write_handle,
    1143                 :            :                          0x0,    // Requested privileges ignored since
    1144                 :            :                                  // DUPLICATE_SAME_ACCESS is used.
    1145                 :            :                          FALSE,  // Request non-inheritable handler.
    1146                 :            :                          DUPLICATE_SAME_ACCESS)) {
    1147                 :            :     DeathTestAbort(String::Format(
    1148                 :            :         "Unable to duplicate the pipe handle %Iu from the parent process %u",
    1149                 :            :         write_handle_as_size_t, parent_process_id));
    1150                 :            :   }
    1151                 :            : 
    1152                 :            :   const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
    1153                 :            :   HANDLE dup_event_handle;
    1154                 :            : 
    1155                 :            :   if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
    1156                 :            :                          ::GetCurrentProcess(), &dup_event_handle,
    1157                 :            :                          0x0,
    1158                 :            :                          FALSE,
    1159                 :            :                          DUPLICATE_SAME_ACCESS)) {
    1160                 :            :     DeathTestAbort(String::Format(
    1161                 :            :         "Unable to duplicate the event handle %Iu from the parent process %u",
    1162                 :            :         event_handle_as_size_t, parent_process_id));
    1163                 :            :   }
    1164                 :            : 
    1165                 :            :   const int write_fd =
    1166                 :            :       ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
    1167                 :            :   if (write_fd == -1) {
    1168                 :            :     DeathTestAbort(String::Format(
    1169                 :            :         "Unable to convert pipe handle %Iu to a file descriptor",
    1170                 :            :         write_handle_as_size_t));
    1171                 :            :   }
    1172                 :            : 
    1173                 :            :   // Signals the parent that the write end of the pipe has been acquired
    1174                 :            :   // so the parent can release its own write end.
    1175                 :            :   ::SetEvent(dup_event_handle);
    1176                 :            : 
    1177                 :            :   return write_fd;
    1178                 :            : }
    1179                 :            : # endif  // GTEST_OS_WINDOWS
    1180                 :            : 
    1181                 :            : // Returns a newly created InternalRunDeathTestFlag object with fields
    1182                 :            : // initialized from the GTEST_FLAG(internal_run_death_test) flag if
    1183                 :            : // the flag is specified; otherwise returns NULL.
    1184                 :          4 : InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    1185         [ +  - ]:          4 :   if (GTEST_FLAG(internal_run_death_test) == "") return NULL;
    1186                 :            : 
    1187                 :            :   // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
    1188                 :            :   // can use it here.
    1189                 :          0 :   int line = -1;
    1190                 :          0 :   int index = -1;
    1191                 :          0 :   ::std::vector< ::std::string> fields;
    1192 [ #  # ][ #  # ]:          0 :   SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
                 [ #  # ]
    1193                 :          0 :   int write_fd = -1;
    1194                 :            : 
    1195                 :            : # if GTEST_OS_WINDOWS
    1196                 :            : 
    1197                 :            :   unsigned int parent_process_id = 0;
    1198                 :            :   size_t write_handle_as_size_t = 0;
    1199                 :            :   size_t event_handle_as_size_t = 0;
    1200                 :            : 
    1201                 :            :   if (fields.size() != 6
    1202                 :            :       || !ParseNaturalNumber(fields[1], &line)
    1203                 :            :       || !ParseNaturalNumber(fields[2], &index)
    1204                 :            :       || !ParseNaturalNumber(fields[3], &parent_process_id)
    1205                 :            :       || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
    1206                 :            :       || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
    1207                 :            :     DeathTestAbort(String::Format(
    1208                 :            :         "Bad --gtest_internal_run_death_test flag: %s",
    1209                 :            :         GTEST_FLAG(internal_run_death_test).c_str()));
    1210                 :            :   }
    1211                 :            :   write_fd = GetStatusFileDescriptor(parent_process_id,
    1212                 :            :                                      write_handle_as_size_t,
    1213                 :            :                                      event_handle_as_size_t);
    1214                 :            : # else
    1215                 :            : 
    1216 [ #  # ][ #  # ]:          0 :   if (fields.size() != 4
         [ #  # ][ #  # ]
                 [ #  # ]
    1217         [ #  # ]:          0 :       || !ParseNaturalNumber(fields[1], &line)
    1218         [ #  # ]:          0 :       || !ParseNaturalNumber(fields[2], &index)
    1219         [ #  # ]:          0 :       || !ParseNaturalNumber(fields[3], &write_fd)) {
    1220                 :            :     DeathTestAbort(String::Format(
    1221                 :            :         "Bad --gtest_internal_run_death_test flag: %s",
    1222 [ #  # ][ #  # ]:          0 :         GTEST_FLAG(internal_run_death_test).c_str()));
    1223                 :            :   }
    1224                 :            : 
    1225                 :            : # endif  // GTEST_OS_WINDOWS
    1226                 :            : 
    1227 [ #  # ][ #  # ]:          4 :   return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
                 [ #  # ]
    1228                 :            : }
    1229                 :            : 
    1230                 :            : }  // namespace internal
    1231                 :            : 
    1232                 :            : #endif  // GTEST_HAS_DEATH_TEST
    1233                 :            : 
    1234                 :            : }  // namespace testing

Generated by: LCOV version 1.9