GCC Code Coverage Report

Directory:	./
File:	googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
Date:	2026-09-03 21:13:48

	Exec	Total	Coverage
Lines:	2	4	50.0%
Functions:	1	3	33.3%
Branches:	2	2	100.0%

  
      Line
      Branch
      Exec
      Source
    
      // Copyright 2005, Google Inc.
    
      // All rights reserved.
    
      //
    
      // Redistribution and use in source and binary forms, with or without
    
      // modification, are permitted provided that the following conditions are
    
      // met:
    
      //
    
      //     * Redistributions of source code must retain the above copyright
    
      // notice, this list of conditions and the following disclaimer.
    
      //     * Redistributions in binary form must reproduce the above
    
      // copyright notice, this list of conditions and the following disclaimer
    
      // in the documentation and/or other materials provided with the
    
      // distribution.
    
      //     * Neither the name of Google Inc. nor the names of its
    
      // contributors may be used to endorse or promote products derived from
    
      // this software without specific prior written permission.
    
      //
    
      // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    
      // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    
      // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    
      // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    
      // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    
      // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    
      // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    
      // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    
      // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    
      // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    
      // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
      // The Google C++ Testing and Mocking Framework (Google Test)
    
      //
    
      // This header file defines internal utilities needed for implementing
    
      // death tests.  They are subject to change without notice.
    
      // IWYU pragma: private, include "gtest/gtest.h"
    
      // IWYU pragma: friend gtest/.*
    
      // IWYU pragma: friend gmock/.*
    
      #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
    
      #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
    
      #include <stdio.h>
    
      #include <memory>
    
      #include "gtest/gtest-matchers.h"
    
      #include "gtest/internal/gtest-internal.h"
    
      GTEST_DECLARE_string_(internal_run_death_test);
    
      namespace testing {
    
      namespace internal {
    
      // Names of the flags (needed for parsing Google Test flags).
    
      const char kDeathTestStyleFlag[] = "death_test_style";
    
      const char kDeathTestUseFork[] = "death_test_use_fork";
    
      const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
    
      #if GTEST_HAS_DEATH_TEST
    
      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
    
      /* class A needs to have dll-interface to be used by clients of class B */)
    
      // DeathTest is a class that hides much of the complexity of the
    
      // GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
    
      // returns a concrete class that depends on the prevailing death test
    
      // style, as defined by the --gtest_death_test_style and/or
    
      // --gtest_internal_run_death_test flags.
    
      // In describing the results of death tests, these terms are used with
    
      // the corresponding definitions:
    
      //
    
      // exit status:  The integer exit information in the format specified
    
      //               by wait(2)
    
      // exit code:    The integer code passed to exit(3), _exit(2), or
    
      //               returned from main()
    
      class GTEST_API_ DeathTest {
    
       public:
    
        // Create returns false if there was an error determining the
    
        // appropriate action to take for the current death test; for example,
    
        // if the gtest_death_test_style flag is set to an invalid value.
    
        // The LastMessage method will return a more detailed message in that
    
        // case.  Otherwise, the DeathTest pointer pointed to by the "test"
    
        // argument is set.  If the death test should be skipped, the pointer
    
        // is set to NULL; otherwise, it is set to the address of a new concrete
    
        // DeathTest object that controls the execution of the current test.
    
        static bool Create(const char* statement, Matcher<const std::string&> matcher,
    
                           const char* file, int line, DeathTest** test);
    
        DeathTest();
    
        virtual ~DeathTest() {}
    
        // A helper class that aborts a death test when it's deleted.
    
        class ReturnSentinel {
    
         public:
    
      ✗
          explicit ReturnSentinel(DeathTest* test) : test_(test) {}
    
      ✗
          ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
    
         private:
    
          DeathTest* const test_;
    
          ReturnSentinel(const ReturnSentinel&) = delete;
    
          ReturnSentinel& operator=(const ReturnSentinel&) = delete;
    
        } GTEST_ATTRIBUTE_UNUSED_;
    
        // An enumeration of possible roles that may be taken when a death
    
        // test is encountered.  EXECUTE means that the death test logic should
    
        // be executed immediately.  OVERSEE means that the program should prepare
    
        // the appropriate environment for a child process to execute the death
    
        // test, then wait for it to complete.
    
        enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
    
        // An enumeration of the three reasons that a test might be aborted.
    
        enum AbortReason {
    
          TEST_ENCOUNTERED_RETURN_STATEMENT,
    
          TEST_THREW_EXCEPTION,
    
          TEST_DID_NOT_DIE
    
        };
    
        // Assumes one of the above roles.
    
        virtual TestRole AssumeRole() = 0;
    
        // Waits for the death test to finish and returns its status.
    
        virtual int Wait() = 0;
    
        // Returns true if the death test passed; that is, the test process
    
        // exited during the test, its exit status matches a user-supplied
    
        // predicate, and its stderr output matches a user-supplied regular
    
        // expression.
    
        // The user-supplied predicate may be a macro expression rather
    
        // than a function pointer or functor, or else Wait and Passed could
    
        // be combined.
    
        virtual bool Passed(bool exit_status_ok) = 0;
    
        // Signals that the death test did not die as expected.
    
        virtual void Abort(AbortReason reason) = 0;
    
        // Returns a human-readable outcome message regarding the outcome of
    
        // the last death test.
    
        static const char* LastMessage();
    
        static void set_last_death_test_message(const std::string& message);
    
       private:
    
        // A string containing a description of the outcome of the last death test.
    
        static std::string last_death_test_message_;
    
        DeathTest(const DeathTest&) = delete;
    
        DeathTest& operator=(const DeathTest&) = delete;
    
      };
    
      GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
    
      // Factory interface for death tests.  May be mocked out for testing.
    
      class DeathTestFactory {
    
       public:
    
        virtual ~DeathTestFactory() {}
    
        virtual bool Create(const char* statement,
    
                            Matcher<const std::string&> matcher, const char* file,
    
                            int line, DeathTest** test) = 0;
    
      };
    
      // A concrete DeathTestFactory implementation for normal use.
    
      class DefaultDeathTestFactory : public DeathTestFactory {
    
       public:
    
        bool Create(const char* statement, Matcher<const std::string&> matcher,
    
                    const char* file, int line, DeathTest** test) override;
    
      };
    
      // Returns true if exit_status describes a process that was terminated
    
      // by a signal, or exited normally with a nonzero exit code.
    
      GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
    
      // A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
    
      // and interpreted as a regex (rather than an Eq matcher) for legacy
    
      // compatibility.
    
      inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    
          ::testing::internal::RE regex) {
    
        return ContainsRegex(regex.pattern());
    
      }
    
      138
      inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
    
        2/2✓ Branch 2 taken 138 times.
✓ Branch 6 taken 138 times.

      276
        return ContainsRegex(regex);
    
      }
    
      inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    
          const ::std::string& regex) {
    
        return ContainsRegex(regex);
    
      }
    
      // If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
    
      // used directly.
    
      inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    
          Matcher<const ::std::string&> matcher) {
    
        return matcher;
    
      }
    
      // Traps C++ exceptions escaping statement and reports them as test
    
      // failures. Note that trapping SEH exceptions is not implemented here.
    
      #if GTEST_HAS_EXCEPTIONS
    
      #define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test)           \
    
        try {                                                                      \
    
          GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
    
        } catch (const ::std::exception& gtest_exception) {                        \
    
          fprintf(                                                                 \
    
              stderr,                                                              \
    
              "\n%s: Caught std::exception-derived exception escaping the "        \
    
              "death test statement. Exception message: %s\n",                     \
    
              ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
    
              gtest_exception.what());                                             \
    
          fflush(stderr);                                                          \
    
          death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
    
        } catch (...) {                                                            \
    
          death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
    
        }
    
      #else
    
      #define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
    
        GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
    
      #endif
    
      // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
    
      // ASSERT_EXIT*, and EXPECT_EXIT*.
    
      #define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
    
        GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
    
        if (::testing::internal::AlwaysTrue()) {                                     \
    
          ::testing::internal::DeathTest* gtest_dt;                                  \
    
          if (!::testing::internal::DeathTest::Create(                               \
    
                  #statement,                                                        \
    
                  ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
    
                  __FILE__, __LINE__, &gtest_dt)) {                                  \
    
            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
    
          }                                                                          \
    
          if (gtest_dt != nullptr) {                                                 \
    
            std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
    
            switch (gtest_dt->AssumeRole()) {                                        \
    
              case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
    
                if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
    
                  goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
    
                }                                                                    \
    
                break;                                                               \
    
              case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
    
                ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
    
                    gtest_dt);                                                       \
    
                GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
    
                gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
    
                break;                                                               \
    
              }                                                                      \
    
            }                                                                        \
    
          }                                                                          \
    
        } else                                                                       \
    
          GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
    
              : fail(::testing::internal::DeathTest::LastMessage())
    
      // The symbol "fail" here expands to something into which a message
    
      // can be streamed.
    
      // This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
    
      // NDEBUG mode. In this case we need the statements to be executed and the macro
    
      // must accept a streamed message even though the message is never printed.
    
      // The regex object is not evaluated, but it is used to prevent "unused"
    
      // warnings and to avoid an expression that doesn't compile in debug mode.
    
      #define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
    
        GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
    
        if (::testing::internal::AlwaysTrue()) {                       \
    
          GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
    
        } else if (!::testing::internal::AlwaysTrue()) {               \
    
          ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
    
        } else                                                         \
    
          ::testing::Message()
    
      // A class representing the parsed contents of the
    
      // --gtest_internal_run_death_test flag, as it existed when
    
      // RUN_ALL_TESTS was called.
    
      class InternalRunDeathTestFlag {
    
       public:
    
        InternalRunDeathTestFlag(const std::string& a_file, int a_line, int an_index,
    
                                 int a_write_fd)
    
            : file_(a_file), line_(a_line), index_(an_index), write_fd_(a_write_fd) {}
    
        ~InternalRunDeathTestFlag() {
    
          if (write_fd_ >= 0) posix::Close(write_fd_);
    
        }
    
        const std::string& file() const { return file_; }
    
        int line() const { return line_; }
    
        int index() const { return index_; }
    
        int write_fd() const { return write_fd_; }
    
       private:
    
        std::string file_;
    
        int line_;
    
        int index_;
    
        int write_fd_;
    
        InternalRunDeathTestFlag(const InternalRunDeathTestFlag&) = delete;
    
        InternalRunDeathTestFlag& operator=(const InternalRunDeathTestFlag&) = delete;
    
      };
    
      // Returns a newly created InternalRunDeathTestFlag object with fields
    
      // initialized from the GTEST_FLAG(internal_run_death_test) flag if
    
      // the flag is specified; otherwise returns NULL.
    
      InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
    
      #endif  // GTEST_HAS_DEATH_TEST
    
      }  // namespace internal
    
      }  // namespace testing
    
      #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

Line	Branch	Exec	Source
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			// The Google C++ Testing and Mocking Framework (Google Test)
31			//
32			// This header file defines internal utilities needed for implementing
33			// death tests. They are subject to change without notice.
34
35			// IWYU pragma: private, include "gtest/gtest.h"
36			// IWYU pragma: friend gtest/.*
37			// IWYU pragma: friend gmock/.*
38
39			#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
40			#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
41
42			#include <stdio.h>
43
44			#include <memory>
45
46			#include "gtest/gtest-matchers.h"
47			#include "gtest/internal/gtest-internal.h"
48
49			GTEST_DECLARE_string_(internal_run_death_test);
50
51			namespace testing {
52			namespace internal {
53
54			// Names of the flags (needed for parsing Google Test flags).
55			const char kDeathTestStyleFlag[] = "death_test_style";
56			const char kDeathTestUseFork[] = "death_test_use_fork";
57			const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
58
59			#if GTEST_HAS_DEATH_TEST
60
61			GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
62			/* class A needs to have dll-interface to be used by clients of class B */)
63
64			// DeathTest is a class that hides much of the complexity of the
65			// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method
66			// returns a concrete class that depends on the prevailing death test
67			// style, as defined by the --gtest_death_test_style and/or
68			// --gtest_internal_run_death_test flags.
69
70			// In describing the results of death tests, these terms are used with
71			// the corresponding definitions:
72			//
73			// exit status: The integer exit information in the format specified
74			// by wait(2)
75			// exit code: The integer code passed to exit(3), _exit(2), or
76			// returned from main()
77			class GTEST_API_ DeathTest {
78			public:
79			// Create returns false if there was an error determining the
80			// appropriate action to take for the current death test; for example,
81			// if the gtest_death_test_style flag is set to an invalid value.
82			// The LastMessage method will return a more detailed message in that
83			// case. Otherwise, the DeathTest pointer pointed to by the "test"
84			// argument is set. If the death test should be skipped, the pointer
85			// is set to NULL; otherwise, it is set to the address of a new concrete
86			// DeathTest object that controls the execution of the current test.
87			static bool Create(const char* statement, Matcher<const std::string&> matcher,
88			const char* file, int line, DeathTest** test);
89			DeathTest();
90			virtual ~DeathTest() {}
91
92			// A helper class that aborts a death test when it's deleted.
93			class ReturnSentinel {
94			public:
95		✗	explicit ReturnSentinel(DeathTest* test) : test_(test) {}
96		✗	~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
97
98			private:
99			DeathTest* const test_;
100			ReturnSentinel(const ReturnSentinel&) = delete;
101			ReturnSentinel& operator=(const ReturnSentinel&) = delete;
102			} GTEST_ATTRIBUTE_UNUSED_;
103
104			// An enumeration of possible roles that may be taken when a death
105			// test is encountered. EXECUTE means that the death test logic should
106			// be executed immediately. OVERSEE means that the program should prepare
107			// the appropriate environment for a child process to execute the death
108			// test, then wait for it to complete.
109			enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
110
111			// An enumeration of the three reasons that a test might be aborted.
112			enum AbortReason {
113			TEST_ENCOUNTERED_RETURN_STATEMENT,
114			TEST_THREW_EXCEPTION,
115			TEST_DID_NOT_DIE
116			};
117
118			// Assumes one of the above roles.
119			virtual TestRole AssumeRole() = 0;
120
121			// Waits for the death test to finish and returns its status.
122			virtual int Wait() = 0;
123
124			// Returns true if the death test passed; that is, the test process
125			// exited during the test, its exit status matches a user-supplied
126			// predicate, and its stderr output matches a user-supplied regular
127			// expression.
128			// The user-supplied predicate may be a macro expression rather
129			// than a function pointer or functor, or else Wait and Passed could
130			// be combined.
131			virtual bool Passed(bool exit_status_ok) = 0;
132
133			// Signals that the death test did not die as expected.
134			virtual void Abort(AbortReason reason) = 0;
135
136			// Returns a human-readable outcome message regarding the outcome of
137			// the last death test.
138			static const char* LastMessage();
139
140			static void set_last_death_test_message(const std::string& message);
141
142			private:
143			// A string containing a description of the outcome of the last death test.
144			static std::string last_death_test_message_;
145
146			DeathTest(const DeathTest&) = delete;
147			DeathTest& operator=(const DeathTest&) = delete;
148			};
149
150			GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
151
152			// Factory interface for death tests. May be mocked out for testing.
153			class DeathTestFactory {
154			public:
155			virtual ~DeathTestFactory() {}
156			virtual bool Create(const char* statement,
157			Matcher<const std::string&> matcher, const char* file,
158			int line, DeathTest** test) = 0;
159			};
160
161			// A concrete DeathTestFactory implementation for normal use.
162			class DefaultDeathTestFactory : public DeathTestFactory {
163			public:
164			bool Create(const char* statement, Matcher<const std::string&> matcher,
165			const char* file, int line, DeathTest** test) override;
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			GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
171
172			// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
173			// and interpreted as a regex (rather than an Eq matcher) for legacy
174			// compatibility.
175			inline Matcher<const ::std::string&> MakeDeathTestMatcher(
176			::testing::internal::RE regex) {
177			return ContainsRegex(regex.pattern());
178			}
179		138	inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
180	2/2 ✓ Branch 2 taken 138 times. ✓ Branch 6 taken 138 times.	276	return ContainsRegex(regex);
181			}
182			inline Matcher<const ::std::string&> MakeDeathTestMatcher(
183			const ::std::string& regex) {
184			return ContainsRegex(regex);
185			}
186
187			// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
188			// used directly.
189			inline Matcher<const ::std::string&> MakeDeathTestMatcher(
190			Matcher<const ::std::string&> matcher) {
191			return matcher;
192			}
193
194			// Traps C++ exceptions escaping statement and reports them as test
195			// failures. Note that trapping SEH exceptions is not implemented here.
196			#if GTEST_HAS_EXCEPTIONS
197			#define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
198			try { \
199			GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
200			} catch (const ::std::exception& gtest_exception) { \
201			fprintf( \
202			stderr, \
203			"\n%s: Caught std::exception-derived exception escaping the " \
204			"death test statement. Exception message: %s\n", \
205			::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
206			gtest_exception.what()); \
207			fflush(stderr); \
208			death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
209			} catch (...) { \
210			death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
211			}
212
213			#else
214			#define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
215			GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
216
217			#endif
218
219			// This macro is for implementing ASSERT_DEATH, EXPECT_DEATH,
220			// ASSERT_EXIT, and EXPECT_EXIT.
221			#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail) \
222			GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
223			if (::testing::internal::AlwaysTrue()) { \
224			::testing::internal::DeathTest* gtest_dt; \
225			if (!::testing::internal::DeathTest::Create( \
226			#statement, \
227			::testing::internal::MakeDeathTestMatcher(regex_or_matcher), \
228			__FILE__, __LINE__, &gtest_dt)) { \
229			goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
230			} \
231			if (gtest_dt != nullptr) { \
232			std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
233			switch (gtest_dt->AssumeRole()) { \
234			case ::testing::internal::DeathTest::OVERSEE_TEST: \
235			if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
236			goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
237			} \
238			break; \
239			case ::testing::internal::DeathTest::EXECUTE_TEST: { \
240			::testing::internal::DeathTest::ReturnSentinel gtest_sentinel( \
241			gtest_dt); \
242			GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
243			gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
244			break; \
245			} \
246			} \
247			} \
248			} else \
249			GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__) \
250			: fail(::testing::internal::DeathTest::LastMessage())
251			// The symbol "fail" here expands to something into which a message
252			// can be streamed.
253
254			// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
255			// NDEBUG mode. In this case we need the statements to be executed and the macro
256			// must accept a streamed message even though the message is never printed.
257			// The regex object is not evaluated, but it is used to prevent "unused"
258			// warnings and to avoid an expression that doesn't compile in debug mode.
259			#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher) \
260			GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
261			if (::testing::internal::AlwaysTrue()) { \
262			GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
263			} else if (!::testing::internal::AlwaysTrue()) { \
264			::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
265			} else \
266			::testing::Message()
267
268			// A class representing the parsed contents of the
269			// --gtest_internal_run_death_test flag, as it existed when
270			// RUN_ALL_TESTS was called.
271			class InternalRunDeathTestFlag {
272			public:
273			InternalRunDeathTestFlag(const std::string& a_file, int a_line, int an_index,
274			int a_write_fd)
275			: file_(a_file), line_(a_line), index_(an_index), write_fd_(a_write_fd) {}
276
277			~InternalRunDeathTestFlag() {
278			if (write_fd_ >= 0) posix::Close(write_fd_);
279			}
280
281			const std::string& file() const { return file_; }
282			int line() const { return line_; }
283			int index() const { return index_; }
284			int write_fd() const { return write_fd_; }
285
286			private:
287			std::string file_;
288			int line_;
289			int index_;
290			int write_fd_;
291
292			InternalRunDeathTestFlag(const InternalRunDeathTestFlag&) = delete;
293			InternalRunDeathTestFlag& operator=(const InternalRunDeathTestFlag&) = delete;
294			};
295
296			// Returns a newly created InternalRunDeathTestFlag object with fields
297			// initialized from the GTEST_FLAG(internal_run_death_test) flag if
298			// the flag is specified; otherwise returns NULL.
299			InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
300
301			#endif // GTEST_HAS_DEATH_TEST
302
303			} // namespace internal
304			} // namespace testing
305
306			#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
307