Externals/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h

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