Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4358 | Serge | 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 |
||
41 | # endif // GTEST_OS_MAC |
||
42 | |||
43 | # include |
||
44 | # include |
||
45 | # include |
||
46 | # include |
||
47 | |||
48 | # if GTEST_OS_WINDOWS |
||
49 | # include |
||
50 | # else |
||
51 | # include |
||
52 | # include |
||
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 | "after forking)."); |
||
84 | |||
85 | 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 | "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 | "death test. FOR INTERNAL USE ONLY."); |
||
106 | } // namespace internal |
||
107 | |||
108 | #if GTEST_HAS_DEATH_TEST |
||
109 | |||
110 | // ExitedWithCode constructor. |
||
111 | ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { |
||
112 | } |
||
113 | |||
114 | // ExitedWithCode function-call operator. |
||
115 | bool ExitedWithCode::operator()(int exit_status) const { |
||
116 | # if GTEST_OS_WINDOWS |
||
117 | |||
118 | return exit_status == exit_code_; |
||
119 | |||
120 | # else |
||
121 | |||
122 | 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 | KilledBySignal::KilledBySignal(int signum) : signum_(signum) { |
||
130 | } |
||
131 | |||
132 | // KilledBySignal function-call operator. |
||
133 | bool KilledBySignal::operator()(int exit_status) const { |
||
134 | 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 | static String ExitSummary(int exit_code) { |
||
145 | Message m; |
||
146 | |||
147 | # if GTEST_OS_WINDOWS |
||
148 | |||
149 | m << "Exited with exit status " << exit_code; |
||
150 | |||
151 | # else |
||
152 | |||
153 | if (WIFEXITED(exit_code)) { |
||
154 | m << "Exited with exit status " << WEXITSTATUS(exit_code); |
||
155 | } else if (WIFSIGNALED(exit_code)) { |
||
156 | m << "Terminated by signal " << WTERMSIG(exit_code); |
||
157 | } |
||
158 | # ifdef WCOREDUMP |
||
159 | if (WCOREDUMP(exit_code)) { |
||
160 | m << " (core dumped)"; |
||
161 | } |
||
162 | # endif |
||
163 | # endif // GTEST_OS_WINDOWS |
||
164 | |||
165 | 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 | bool ExitedUnsuccessfully(int exit_status) { |
||
171 | 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 | static String DeathTestThreadWarning(size_t thread_count) { |
||
180 | Message msg; |
||
181 | msg << "Death tests use fork(), which is unsafe particularly" |
||
182 | << " in a threaded context. For this test, " << GTEST_NAME_ << " "; |
||
183 | if (thread_count == 0) |
||
184 | msg << "couldn't detect the number of threads."; |
||
185 | else |
||
186 | msg << "detected " << thread_count << " threads."; |
||
187 | 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 | 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 | GetUnitTestImpl()->internal_run_death_test_flag(); |
||
219 | if (flag != NULL) { |
||
220 | FILE* parent = posix::FDOpen(flag->write_fd(), "w"); |
||
221 | fputc(kDeathTestInternalError, parent); |
||
222 | fprintf(parent, "%s", message.c_str()); |
||
223 | fflush(parent); |
||
224 | _exit(1); |
||
225 | } else { |
||
226 | fprintf(stderr, "%s", message.c_str()); |
||
227 | fflush(stderr); |
||
228 | posix::Abort(); |
||
229 | } |
||
230 | } |
||
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 | String GetLastErrnoDescription() { |
||
265 | 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 | static void FailFromInternalError(int fd) { |
||
273 | Message error; |
||
274 | char buffer[256]; |
||
275 | int num_read; |
||
276 | |||
277 | do { |
||
278 | while ((num_read = posix::Read(fd, buffer, 255)) > 0) { |
||
279 | buffer[num_read] = '\0'; |
||
280 | error << buffer; |
||
281 | } |
||
282 | } while (num_read == -1 && errno == EINTR); |
||
283 | |||
284 | if (num_read == 0) { |
||
285 | GTEST_LOG_(FATAL) << error.GetString(); |
||
286 | } else { |
||
287 | const int last_error = errno; |
||
288 | GTEST_LOG_(FATAL) << "Error while reading death test internal: " |
||
289 | << GetLastErrnoDescription() << " [" << last_error << "]"; |
||
290 | } |
||
291 | } |
||
292 | |||
293 | // Death test constructor. Increments the running death test count |
||
294 | // for the current test. |
||
295 | DeathTest::DeathTest() { |
||
296 | TestInfo* const info = GetUnitTestImpl()->current_test_info(); |
||
297 | if (info == NULL) { |
||
298 | DeathTestAbort("Cannot run a death test outside of a TEST or " |
||
299 | "TEST_F construct"); |
||
300 | } |
||
301 | } |
||
302 | |||
303 | // Creates and returns a death test by dispatching to the current |
||
304 | // death test factory. |
||
305 | bool DeathTest::Create(const char* statement, const RE* regex, |
||
306 | const char* file, int line, DeathTest** test) { |
||
307 | return GetUnitTestImpl()->death_test_factory()->Create( |
||
308 | statement, regex, file, line, test); |
||
309 | } |
||
310 | |||
311 | const char* DeathTest::LastMessage() { |
||
312 | return last_death_test_message_.c_str(); |
||
313 | } |
||
314 | |||
315 | void DeathTest::set_last_death_test_message(const String& message) { |
||
316 | last_death_test_message_ = message; |
||
317 | } |
||
318 | |||
319 | String DeathTest::last_death_test_message_; |
||
320 | |||
321 | // Provides cross platform implementation for some death functionality. |
||
322 | class DeathTestImpl : public DeathTest { |
||
323 | protected: |
||
324 | 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 | write_fd_(-1) {} |
||
332 | |||
333 | // read_fd_ is expected to be closed and cleared by a derived class. |
||
334 | ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } |
||
335 | |||
336 | void Abort(AbortReason reason); |
||
337 | virtual bool Passed(bool status_ok); |
||
338 | |||
339 | const char* statement() const { return statement_; } |
||
340 | const RE* regex() const { return regex_; } |
||
341 | bool spawned() const { return spawned_; } |
||
342 | void set_spawned(bool is_spawned) { spawned_ = is_spawned; } |
||
343 | int status() const { return status_; } |
||
344 | void set_status(int a_status) { status_ = a_status; } |
||
345 | DeathTestOutcome outcome() const { return outcome_; } |
||
346 | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } |
||
347 | int read_fd() const { return read_fd_; } |
||
348 | void set_read_fd(int fd) { read_fd_ = fd; } |
||
349 | int write_fd() const { return write_fd_; } |
||
350 | 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 | 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 | do { |
||
394 | bytes_read = posix::Read(read_fd(), &flag, 1); |
||
395 | } while (bytes_read == -1 && errno == EINTR); |
||
396 | |||
397 | if (bytes_read == 0) { |
||
398 | set_outcome(DIED); |
||
399 | } else if (bytes_read == 1) { |
||
400 | switch (flag) { |
||
401 | case kDeathTestReturned: |
||
402 | set_outcome(RETURNED); |
||
403 | break; |
||
404 | case kDeathTestThrew: |
||
405 | set_outcome(THREW); |
||
406 | break; |
||
407 | case kDeathTestLived: |
||
408 | set_outcome(LIVED); |
||
409 | break; |
||
410 | case kDeathTestInternalError: |
||
411 | FailFromInternalError(read_fd()); // Does not return. |
||
412 | break; |
||
413 | default: |
||
414 | GTEST_LOG_(FATAL) << "Death test child process reported " |
||
415 | << "unexpected status byte (" |
||
416 | << static_cast |
||
417 | } |
||
418 | } else { |
||
419 | GTEST_LOG_(FATAL) << "Read from death test child process failed: " |
||
420 | << GetLastErrnoDescription(); |
||
421 | } |
||
422 | GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); |
||
423 | set_read_fd(-1); |
||
424 | } |
||
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 | 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 | reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; |
||
437 | |||
438 | 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 | _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 | static ::std::string FormatDeathTestOutput(const ::std::string& output) { |
||
454 | ::std::string ret; |
||
455 | for (size_t at = 0; ; ) { |
||
456 | const size_t line_end = output.find('\n', at); |
||
457 | ret += "[ DEATH ] "; |
||
458 | if (line_end == ::std::string::npos) { |
||
459 | ret += output.substr(at); |
||
460 | break; |
||
461 | } |
||
462 | ret += output.substr(at, line_end + 1 - at); |
||
463 | at = line_end + 1; |
||
464 | } |
||
465 | 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 | bool DeathTestImpl::Passed(bool status_ok) { |
||
491 | if (!spawned()) |
||
492 | return false; |
||
493 | |||
494 | const String error_message = GetCapturedStderr(); |
||
495 | |||
496 | bool success = false; |
||
497 | Message buffer; |
||
498 | |||
499 | buffer << "Death test: " << statement() << "\n"; |
||
500 | switch (outcome()) { |
||
501 | case LIVED: |
||
502 | buffer << " Result: failed to die.\n" |
||
503 | << " Error msg:\n" << FormatDeathTestOutput(error_message); |
||
504 | break; |
||
505 | case THREW: |
||
506 | buffer << " Result: threw an exception.\n" |
||
507 | << " Error msg:\n" << FormatDeathTestOutput(error_message); |
||
508 | break; |
||
509 | case RETURNED: |
||
510 | buffer << " Result: illegal return in test statement.\n" |
||
511 | << " Error msg:\n" << FormatDeathTestOutput(error_message); |
||
512 | break; |
||
513 | case DIED: |
||
514 | if (status_ok) { |
||
515 | const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); |
||
516 | if (matched) { |
||
517 | success = true; |
||
518 | } else { |
||
519 | buffer << " Result: died but not with expected error.\n" |
||
520 | << " Expected: " << regex()->pattern() << "\n" |
||
521 | << "Actual msg:\n" << FormatDeathTestOutput(error_message); |
||
522 | } |
||
523 | } else { |
||
524 | buffer << " Result: died but not with expected exit code:\n" |
||
525 | << " " << ExitSummary(status()) << "\n" |
||
526 | << "Actual msg:\n" << FormatDeathTestOutput(error_message); |
||
527 | } |
||
528 | break; |
||
529 | case IN_PROGRESS: |
||
530 | default: |
||
531 | GTEST_LOG_(FATAL) |
||
532 | << "DeathTest::Passed somehow called before conclusion of test"; |
||
533 | } |
||
534 | |||
535 | DeathTest::set_last_death_test_message(buffer.GetString()); |
||
536 | 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 |
||
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 |
||
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 |
||
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 |
||
691 | reinterpret_cast |
||
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 |
||
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 | 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 | 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 | ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) |
||
757 | : DeathTestImpl(a_statement, a_regex), |
||
758 | 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 | int ForkingDeathTest::Wait() { |
||
764 | if (!spawned()) |
||
765 | return 0; |
||
766 | |||
767 | ReadAndInterpretStatusByte(); |
||
768 | |||
769 | int status_value; |
||
770 | GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); |
||
771 | set_status(status_value); |
||
772 | return status_value; |
||
773 | } |
||
774 | |||
775 | // A concrete death test class that forks, then immediately runs the test |
||
776 | // in the child process. |
||
777 | class NoExecDeathTest : public ForkingDeathTest { |
||
778 | public: |
||
779 | NoExecDeathTest(const char* a_statement, const RE* a_regex) : |
||
780 | 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 | DeathTest::TestRole NoExecDeathTest::AssumeRole() { |
||
787 | const size_t thread_count = GetThreadCount(); |
||
788 | if (thread_count != 1) { |
||
789 | GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); |
||
790 | } |
||
791 | |||
792 | int pipe_fd[2]; |
||
793 | GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); |
||
794 | |||
795 | DeathTest::set_last_death_test_message(""); |
||
796 | 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 | FlushInfoLog(); |
||
805 | |||
806 | const pid_t child_pid = fork(); |
||
807 | GTEST_DEATH_TEST_CHECK_(child_pid != -1); |
||
808 | set_child_pid(child_pid); |
||
809 | if (child_pid == 0) { |
||
810 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); |
||
811 | 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 | LogToStderr(); |
||
816 | // Event forwarding to the listeners of event listener API mush be shut |
||
817 | // down in death test subprocesses. |
||
818 | GetUnitTestImpl()->listeners()->SuppressEventForwarding(); |
||
819 | return EXECUTE_TEST; |
||
820 | } else { |
||
821 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); |
||
822 | set_read_fd(pipe_fd[0]); |
||
823 | set_spawned(true); |
||
824 | 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 | class ExecDeathTest : public ForkingDeathTest { |
||
832 | public: |
||
833 | ExecDeathTest(const char* a_statement, const RE* a_regex, |
||
834 | const char* file, int line) : |
||
835 | 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 | Arguments() { |
||
848 | args_.push_back(NULL); |
||
849 | } |
||
850 | |||
851 | ~Arguments() { |
||
852 | for (std::vector |
||
853 | ++i) { |
||
854 | free(*i); |
||
855 | } |
||
856 | } |
||
857 | void AddArgument(const char* argument) { |
||
858 | args_.insert(args_.end() - 1, posix::StrDup(argument)); |
||
859 | } |
||
860 | |||
861 | template |
||
862 | void AddArguments(const ::std::vector |
||
863 | for (typename ::std::vector |
||
864 | i != arguments.end(); |
||
865 | ++i) { |
||
866 | args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); |
||
867 | } |
||
868 | } |
||
869 | char* const* Argv() { |
||
870 | return &args_[0]; |
||
871 | } |
||
872 | private: |
||
873 | std::vector |
||
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 | 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 | static int ExecDeathTestChildMain(void* child_arg) { |
||
901 | ExecDeathTestArgs* const args = static_cast |
||
902 | 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 | UnitTest::GetInstance()->original_working_dir(); |
||
909 | // We can safely call chdir() as it's a direct system call. |
||
910 | if (chdir(original_dir) != 0) { |
||
911 | DeathTestAbort(String::Format("chdir(\"%s\") failed: %s", |
||
912 | original_dir, |
||
913 | GetLastErrnoDescription().c_str())); |
||
914 | 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 | execve(args->argv[0], args->argv, GetEnviron()); |
||
923 | DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s", |
||
924 | args->argv[0], |
||
925 | original_dir, |
||
926 | GetLastErrnoDescription().c_str())); |
||
927 | 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 | bool StackLowerThanAddress(const void* ptr) { |
||
941 | int dummy; |
||
942 | return &dummy < ptr; |
||
943 | } |
||
944 | |||
945 | bool StackGrowsDown() { |
||
946 | int dummy; |
||
947 | 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 | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) { |
||
954 | ExecDeathTestArgs args = { argv, close_fd }; |
||
955 | pid_t child_pid = -1; |
||
956 | |||
957 | # if GTEST_HAS_CLONE |
||
958 | const bool use_fork = GTEST_FLAG(death_test_use_fork); |
||
959 | |||
960 | if (!use_fork) { |
||
961 | static const bool stack_grows_down = StackGrowsDown(); |
||
962 | 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 | MAP_ANON | MAP_PRIVATE, -1, 0); |
||
966 | GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); |
||
967 | void* const stack_top = |
||
968 | static_cast |
||
969 | |||
970 | child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); |
||
971 | |||
972 | 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 | if (use_fork && (child_pid = fork()) == 0) { |
||
979 | ExecDeathTestChildMain(&args); |
||
980 | _exit(0); |
||
981 | } |
||
982 | |||
983 | GTEST_DEATH_TEST_CHECK_(child_pid != -1); |
||
984 | 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 | DeathTest::TestRole ExecDeathTest::AssumeRole() { |
||
992 | const UnitTestImpl* const impl = GetUnitTestImpl(); |
||
993 | const InternalRunDeathTestFlag* const flag = |
||
994 | impl->internal_run_death_test_flag(); |
||
995 | const TestInfo* const info = impl->current_test_info(); |
||
996 | const int death_test_index = info->result()->death_test_count(); |
||
997 | |||
998 | if (flag != NULL) { |
||
999 | set_write_fd(flag->write_fd()); |
||
1000 | return EXECUTE_TEST; |
||
1001 | } |
||
1002 | |||
1003 | int pipe_fd[2]; |
||
1004 | 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 | 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 | 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 | file_, line_, death_test_index, pipe_fd[1]); |
||
1017 | Arguments args; |
||
1018 | args.AddArguments(GetArgvs()); |
||
1019 | args.AddArgument(filter_flag.c_str()); |
||
1020 | args.AddArgument(internal_flag.c_str()); |
||
1021 | |||
1022 | DeathTest::set_last_death_test_message(""); |
||
1023 | |||
1024 | CaptureStderr(); |
||
1025 | // See the comment in NoExecDeathTest::AssumeRole for why the next line |
||
1026 | // is necessary. |
||
1027 | FlushInfoLog(); |
||
1028 | |||
1029 | const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]); |
||
1030 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); |
||
1031 | set_child_pid(child_pid); |
||
1032 | set_read_fd(pipe_fd[0]); |
||
1033 | set_spawned(true); |
||
1034 | 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 | bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, |
||
1045 | const char* file, int line, |
||
1046 | DeathTest** test) { |
||
1047 | UnitTestImpl* const impl = GetUnitTestImpl(); |
||
1048 | const InternalRunDeathTestFlag* const flag = |
||
1049 | impl->internal_run_death_test_flag(); |
||
1050 | const int death_test_index = impl->current_test_info() |
||
1051 | ->increment_death_test_count(); |
||
1052 | |||
1053 | if (flag != NULL) { |
||
1054 | 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 | death_test_index, flag->index())); |
||
1058 | return false; |
||
1059 | } |
||
1060 | |||
1061 | if (!(flag->file() == file && flag->line() == line && |
||
1062 | flag->index() == death_test_index)) { |
||
1063 | *test = NULL; |
||
1064 | 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 | if (GTEST_FLAG(death_test_style) == "threadsafe") { |
||
1078 | *test = new ExecDeathTest(statement, regex, file, line); |
||
1079 | } else if (GTEST_FLAG(death_test_style) == "fast") { |
||
1080 | *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 | GTEST_FLAG(death_test_style).c_str())); |
||
1089 | return false; |
||
1090 | } |
||
1091 | |||
1092 | 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 | static void SplitString(const ::std::string& str, char delimiter, |
||
1099 | ::std::vector< ::std::string>* dest) { |
||
1100 | ::std::vector< ::std::string> parsed; |
||
1101 | ::std::string::size_type pos = 0; |
||
1102 | while (::testing::internal::AlwaysTrue()) { |
||
1103 | const ::std::string::size_type colon = str.find(delimiter, pos); |
||
1104 | if (colon == ::std::string::npos) { |
||
1105 | parsed.push_back(str.substr(pos)); |
||
1106 | break; |
||
1107 | } else { |
||
1108 | parsed.push_back(str.substr(pos, colon - pos)); |
||
1109 | pos = colon + 1; |
||
1110 | } |
||
1111 | } |
||
1112 | dest->swap(parsed); |
||
1113 | } |
||
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 |
||
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 |
||
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 |
||
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 | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { |
||
1185 | 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 | int line = -1; |
||
1190 | int index = -1; |
||
1191 | ::std::vector< ::std::string> fields; |
||
1192 | SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); |
||
1193 | 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 | if (fields.size() != 4 |
||
1217 | || !ParseNaturalNumber(fields[1], &line) |
||
1218 | || !ParseNaturalNumber(fields[2], &index) |
||
1219 | || !ParseNaturalNumber(fields[3], &write_fd)) { |
||
1220 | DeathTestAbort(String::Format( |
||
1221 | "Bad --gtest_internal_run_death_test flag: %s", |
||
1222 | GTEST_FLAG(internal_run_death_test).c_str())); |
||
1223 | } |
||
1224 | |||
1225 | # endif // GTEST_OS_WINDOWS |
||
1226 | |||
1227 | 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>=>>>>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><> |