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