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_ |
---|