]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | #include "gtest/internal/custom/gtest.h" | |
37 | ||
38 | #if GTEST_HAS_DEATH_TEST | |
39 | ||
40 | # if GTEST_OS_MAC | |
41 | # include <crt_externs.h> | |
42 | # endif // GTEST_OS_MAC | |
43 | ||
44 | # include <errno.h> | |
45 | # include <fcntl.h> | |
46 | # include <limits.h> | |
47 | ||
48 | # if GTEST_OS_LINUX | |
49 | # include <signal.h> | |
50 | # endif // GTEST_OS_LINUX | |
51 | ||
52 | # include <stdarg.h> | |
53 | ||
54 | # if GTEST_OS_WINDOWS | |
55 | # include <windows.h> | |
56 | # else | |
57 | # include <sys/mman.h> | |
58 | # include <sys/wait.h> | |
59 | # endif // GTEST_OS_WINDOWS | |
60 | ||
61 | # if GTEST_OS_QNX | |
62 | # include <spawn.h> | |
63 | # endif // GTEST_OS_QNX | |
64 | ||
65 | #endif // GTEST_HAS_DEATH_TEST | |
66 | ||
67 | #include "gtest/gtest-message.h" | |
68 | #include "gtest/internal/gtest-string.h" | |
69 | ||
70 | // Indicates that this translation unit is part of Google Test's | |
71 | // implementation. It must come before gtest-internal-inl.h is | |
72 | // included, or there will be a compiler error. This trick exists to | |
73 | // prevent the accidental inclusion of gtest-internal-inl.h in the | |
74 | // user's code. | |
75 | #define GTEST_IMPLEMENTATION_ 1 | |
76 | #include "src/gtest-internal-inl.h" | |
77 | #undef GTEST_IMPLEMENTATION_ | |
78 | ||
79 | namespace testing { | |
80 | ||
81 | // Constants. | |
82 | ||
83 | // The default death test style. | |
84 | static const char kDefaultDeathTestStyle[] = "fast"; | |
85 | ||
86 | GTEST_DEFINE_string_( | |
87 | death_test_style, | |
88 | internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), | |
89 | "Indicates how to run a death test in a forked child process: " | |
90 | "\"threadsafe\" (child process re-executes the test binary " | |
91 | "from the beginning, running only the specific death test) or " | |
92 | "\"fast\" (child process runs the death test immediately " | |
93 | "after forking)."); | |
94 | ||
95 | GTEST_DEFINE_bool_( | |
96 | death_test_use_fork, | |
97 | internal::BoolFromGTestEnv("death_test_use_fork", false), | |
98 | "Instructs to use fork()/_exit() instead of clone() in death tests. " | |
99 | "Ignored and always uses fork() on POSIX systems where clone() is not " | |
100 | "implemented. Useful when running under valgrind or similar tools if " | |
101 | "those do not support clone(). Valgrind 3.3.1 will just fail if " | |
102 | "it sees an unsupported combination of clone() flags. " | |
103 | "It is not recommended to use this flag w/o valgrind though it will " | |
104 | "work in 99% of the cases. Once valgrind is fixed, this flag will " | |
105 | "most likely be removed."); | |
106 | ||
107 | namespace internal { | |
108 | GTEST_DEFINE_string_( | |
109 | internal_run_death_test, "", | |
110 | "Indicates the file, line number, temporal index of " | |
111 | "the single death test to run, and a file descriptor to " | |
112 | "which a success code may be sent, all separated by " | |
113 | "the '|' characters. This flag is specified if and only if the current " | |
114 | "process is a sub-process launched for running a thread-safe " | |
115 | "death test. FOR INTERNAL USE ONLY."); | |
116 | } // namespace internal | |
117 | ||
118 | #if GTEST_HAS_DEATH_TEST | |
119 | ||
120 | namespace internal { | |
121 | ||
122 | // Valid only for fast death tests. Indicates the code is running in the | |
123 | // child process of a fast style death test. | |
124 | # if !GTEST_OS_WINDOWS | |
125 | static bool g_in_fast_death_test_child = false; | |
126 | # endif | |
127 | ||
128 | // Returns a Boolean value indicating whether the caller is currently | |
129 | // executing in the context of the death test child process. Tools such as | |
130 | // Valgrind heap checkers may need this to modify their behavior in death | |
131 | // tests. IMPORTANT: This is an internal utility. Using it may break the | |
132 | // implementation of death tests. User code MUST NOT use it. | |
133 | bool InDeathTestChild() { | |
134 | # if GTEST_OS_WINDOWS | |
135 | ||
136 | // On Windows, death tests are thread-safe regardless of the value of the | |
137 | // death_test_style flag. | |
138 | return !GTEST_FLAG(internal_run_death_test).empty(); | |
139 | ||
140 | # else | |
141 | ||
142 | if (GTEST_FLAG(death_test_style) == "threadsafe") | |
143 | return !GTEST_FLAG(internal_run_death_test).empty(); | |
144 | else | |
145 | return g_in_fast_death_test_child; | |
146 | #endif | |
147 | } | |
148 | ||
149 | } // namespace internal | |
150 | ||
151 | // ExitedWithCode constructor. | |
152 | ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { | |
153 | } | |
154 | ||
155 | // ExitedWithCode function-call operator. | |
156 | bool ExitedWithCode::operator()(int exit_status) const { | |
157 | # if GTEST_OS_WINDOWS | |
158 | ||
159 | return exit_status == exit_code_; | |
160 | ||
161 | # else | |
162 | ||
163 | return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; | |
164 | ||
165 | # endif // GTEST_OS_WINDOWS | |
166 | } | |
167 | ||
168 | # if !GTEST_OS_WINDOWS | |
169 | // KilledBySignal constructor. | |
170 | KilledBySignal::KilledBySignal(int signum) : signum_(signum) { | |
171 | } | |
172 | ||
173 | // KilledBySignal function-call operator. | |
174 | bool KilledBySignal::operator()(int exit_status) const { | |
175 | # if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_) | |
176 | { | |
177 | bool result; | |
178 | if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) { | |
179 | return result; | |
180 | } | |
181 | } | |
182 | # endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_) | |
183 | return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; | |
184 | } | |
185 | # endif // !GTEST_OS_WINDOWS | |
186 | ||
187 | namespace internal { | |
188 | ||
189 | // Utilities needed for death tests. | |
190 | ||
191 | // Generates a textual description of a given exit code, in the format | |
192 | // specified by wait(2). | |
193 | static std::string ExitSummary(int exit_code) { | |
194 | Message m; | |
195 | ||
196 | # if GTEST_OS_WINDOWS | |
197 | ||
198 | m << "Exited with exit status " << exit_code; | |
199 | ||
200 | # else | |
201 | ||
202 | if (WIFEXITED(exit_code)) { | |
203 | m << "Exited with exit status " << WEXITSTATUS(exit_code); | |
204 | } else if (WIFSIGNALED(exit_code)) { | |
205 | m << "Terminated by signal " << WTERMSIG(exit_code); | |
206 | } | |
207 | # ifdef WCOREDUMP | |
208 | if (WCOREDUMP(exit_code)) { | |
209 | m << " (core dumped)"; | |
210 | } | |
211 | # endif | |
212 | # endif // GTEST_OS_WINDOWS | |
213 | ||
214 | return m.GetString(); | |
215 | } | |
216 | ||
217 | // Returns true if exit_status describes a process that was terminated | |
218 | // by a signal, or exited normally with a nonzero exit code. | |
219 | bool ExitedUnsuccessfully(int exit_status) { | |
220 | return !ExitedWithCode(0)(exit_status); | |
221 | } | |
222 | ||
223 | # if !GTEST_OS_WINDOWS | |
224 | // Generates a textual failure message when a death test finds more than | |
225 | // one thread running, or cannot determine the number of threads, prior | |
226 | // to executing the given statement. It is the responsibility of the | |
227 | // caller not to pass a thread_count of 1. | |
228 | static std::string DeathTestThreadWarning(size_t thread_count) { | |
229 | Message msg; | |
230 | msg << "Death tests use fork(), which is unsafe particularly" | |
231 | << " in a threaded context. For this test, " << GTEST_NAME_ << " "; | |
232 | if (thread_count == 0) | |
233 | msg << "couldn't detect the number of threads."; | |
234 | else | |
235 | msg << "detected " << thread_count << " threads."; | |
236 | return msg.GetString(); | |
237 | } | |
238 | # endif // !GTEST_OS_WINDOWS | |
239 | ||
240 | // Flag characters for reporting a death test that did not die. | |
241 | static const char kDeathTestLived = 'L'; | |
242 | static const char kDeathTestReturned = 'R'; | |
243 | static const char kDeathTestThrew = 'T'; | |
244 | static const char kDeathTestInternalError = 'I'; | |
245 | ||
246 | // An enumeration describing all of the possible ways that a death test can | |
247 | // conclude. DIED means that the process died while executing the test | |
248 | // code; LIVED means that process lived beyond the end of the test code; | |
249 | // RETURNED means that the test statement attempted to execute a return | |
250 | // statement, which is not allowed; THREW means that the test statement | |
251 | // returned control by throwing an exception. IN_PROGRESS means the test | |
252 | // has not yet concluded. | |
253 | // TODO(vladl@google.com): Unify names and possibly values for | |
254 | // AbortReason, DeathTestOutcome, and flag characters above. | |
255 | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; | |
256 | ||
257 | // Routine for aborting the program which is safe to call from an | |
258 | // exec-style death test child process, in which case the error | |
259 | // message is propagated back to the parent process. Otherwise, the | |
260 | // message is simply printed to stderr. In either case, the program | |
261 | // then exits with status 1. | |
262 | void DeathTestAbort(const std::string& message) { | |
263 | // On a POSIX system, this function may be called from a threadsafe-style | |
264 | // death test child process, which operates on a very small stack. Use | |
265 | // the heap for any additional non-minuscule memory requirements. | |
266 | const InternalRunDeathTestFlag* const flag = | |
267 | GetUnitTestImpl()->internal_run_death_test_flag(); | |
268 | if (flag != NULL) { | |
269 | FILE* parent = posix::FDOpen(flag->write_fd(), "w"); | |
270 | fputc(kDeathTestInternalError, parent); | |
271 | fprintf(parent, "%s", message.c_str()); | |
272 | fflush(parent); | |
273 | _exit(1); | |
274 | } else { | |
275 | fprintf(stderr, "%s", message.c_str()); | |
276 | fflush(stderr); | |
277 | posix::Abort(); | |
278 | } | |
279 | } | |
280 | ||
281 | // A replacement for CHECK that calls DeathTestAbort if the assertion | |
282 | // fails. | |
283 | # define GTEST_DEATH_TEST_CHECK_(expression) \ | |
284 | do { \ | |
285 | if (!::testing::internal::IsTrue(expression)) { \ | |
286 | DeathTestAbort( \ | |
287 | ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ | |
288 | + ::testing::internal::StreamableToString(__LINE__) + ": " \ | |
289 | + #expression); \ | |
290 | } \ | |
291 | } while (::testing::internal::AlwaysFalse()) | |
292 | ||
293 | // This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for | |
294 | // evaluating any system call that fulfills two conditions: it must return | |
295 | // -1 on failure, and set errno to EINTR when it is interrupted and | |
296 | // should be tried again. The macro expands to a loop that repeatedly | |
297 | // evaluates the expression as long as it evaluates to -1 and sets | |
298 | // errno to EINTR. If the expression evaluates to -1 but errno is | |
299 | // something other than EINTR, DeathTestAbort is called. | |
300 | # define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ | |
301 | do { \ | |
302 | int gtest_retval; \ | |
303 | do { \ | |
304 | gtest_retval = (expression); \ | |
305 | } while (gtest_retval == -1 && errno == EINTR); \ | |
306 | if (gtest_retval == -1) { \ | |
307 | DeathTestAbort( \ | |
308 | ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ | |
309 | + ::testing::internal::StreamableToString(__LINE__) + ": " \ | |
310 | + #expression + " != -1"); \ | |
311 | } \ | |
312 | } while (::testing::internal::AlwaysFalse()) | |
313 | ||
314 | // Returns the message describing the last system error in errno. | |
315 | std::string GetLastErrnoDescription() { | |
316 | return errno == 0 ? "" : posix::StrError(errno); | |
317 | } | |
318 | ||
319 | // This is called from a death test parent process to read a failure | |
320 | // message from the death test child process and log it with the FATAL | |
321 | // severity. On Windows, the message is read from a pipe handle. On other | |
322 | // platforms, it is read from a file descriptor. | |
323 | static void FailFromInternalError(int fd) { | |
324 | Message error; | |
325 | char buffer[256]; | |
326 | int num_read; | |
327 | ||
328 | do { | |
329 | while ((num_read = posix::Read(fd, buffer, 255)) > 0) { | |
330 | buffer[num_read] = '\0'; | |
331 | error << buffer; | |
332 | } | |
333 | } while (num_read == -1 && errno == EINTR); | |
334 | ||
335 | if (num_read == 0) { | |
336 | GTEST_LOG_(FATAL) << error.GetString(); | |
337 | } else { | |
338 | const int last_error = errno; | |
339 | GTEST_LOG_(FATAL) << "Error while reading death test internal: " | |
340 | << GetLastErrnoDescription() << " [" << last_error << "]"; | |
341 | } | |
342 | } | |
343 | ||
344 | // Death test constructor. Increments the running death test count | |
345 | // for the current test. | |
346 | DeathTest::DeathTest() { | |
347 | TestInfo* const info = GetUnitTestImpl()->current_test_info(); | |
348 | if (info == NULL) { | |
349 | DeathTestAbort("Cannot run a death test outside of a TEST or " | |
350 | "TEST_F construct"); | |
351 | } | |
352 | } | |
353 | ||
354 | // Creates and returns a death test by dispatching to the current | |
355 | // death test factory. | |
356 | bool DeathTest::Create(const char* statement, const RE* regex, | |
357 | const char* file, int line, DeathTest** test) { | |
358 | return GetUnitTestImpl()->death_test_factory()->Create( | |
359 | statement, regex, file, line, test); | |
360 | } | |
361 | ||
362 | const char* DeathTest::LastMessage() { | |
363 | return last_death_test_message_.c_str(); | |
364 | } | |
365 | ||
366 | void DeathTest::set_last_death_test_message(const std::string& message) { | |
367 | last_death_test_message_ = message; | |
368 | } | |
369 | ||
370 | std::string DeathTest::last_death_test_message_; | |
371 | ||
372 | // Provides cross platform implementation for some death functionality. | |
373 | class DeathTestImpl : public DeathTest { | |
374 | protected: | |
375 | DeathTestImpl(const char* a_statement, const RE* a_regex) | |
376 | : statement_(a_statement), | |
377 | regex_(a_regex), | |
378 | spawned_(false), | |
379 | status_(-1), | |
380 | outcome_(IN_PROGRESS), | |
381 | read_fd_(-1), | |
382 | write_fd_(-1) {} | |
383 | ||
384 | // read_fd_ is expected to be closed and cleared by a derived class. | |
385 | ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | |
386 | ||
387 | void Abort(AbortReason reason); | |
388 | virtual bool Passed(bool status_ok); | |
389 | ||
390 | const char* statement() const { return statement_; } | |
391 | const RE* regex() const { return regex_; } | |
392 | bool spawned() const { return spawned_; } | |
393 | void set_spawned(bool is_spawned) { spawned_ = is_spawned; } | |
394 | int status() const { return status_; } | |
395 | void set_status(int a_status) { status_ = a_status; } | |
396 | DeathTestOutcome outcome() const { return outcome_; } | |
397 | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } | |
398 | int read_fd() const { return read_fd_; } | |
399 | void set_read_fd(int fd) { read_fd_ = fd; } | |
400 | int write_fd() const { return write_fd_; } | |
401 | void set_write_fd(int fd) { write_fd_ = fd; } | |
402 | ||
403 | // Called in the parent process only. Reads the result code of the death | |
404 | // test child process via a pipe, interprets it to set the outcome_ | |
405 | // member, and closes read_fd_. Outputs diagnostics and terminates in | |
406 | // case of unexpected codes. | |
407 | void ReadAndInterpretStatusByte(); | |
408 | ||
409 | private: | |
410 | // The textual content of the code this object is testing. This class | |
411 | // doesn't own this string and should not attempt to delete it. | |
412 | const char* const statement_; | |
413 | // The regular expression which test output must match. DeathTestImpl | |
414 | // doesn't own this object and should not attempt to delete it. | |
415 | const RE* const regex_; | |
416 | // True if the death test child process has been successfully spawned. | |
417 | bool spawned_; | |
418 | // The exit status of the child process. | |
419 | int status_; | |
420 | // How the death test concluded. | |
421 | DeathTestOutcome outcome_; | |
422 | // Descriptor to the read end of the pipe to the child process. It is | |
423 | // always -1 in the child process. The child keeps its write end of the | |
424 | // pipe in write_fd_. | |
425 | int read_fd_; | |
426 | // Descriptor to the child's write end of the pipe to the parent process. | |
427 | // It is always -1 in the parent process. The parent keeps its end of the | |
428 | // pipe in read_fd_. | |
429 | int write_fd_; | |
430 | }; | |
431 | ||
432 | // Called in the parent process only. Reads the result code of the death | |
433 | // test child process via a pipe, interprets it to set the outcome_ | |
434 | // member, and closes read_fd_. Outputs diagnostics and terminates in | |
435 | // case of unexpected codes. | |
436 | void DeathTestImpl::ReadAndInterpretStatusByte() { | |
437 | char flag; | |
438 | int bytes_read; | |
439 | ||
440 | // The read() here blocks until data is available (signifying the | |
441 | // failure of the death test) or until the pipe is closed (signifying | |
442 | // its success), so it's okay to call this in the parent before | |
443 | // the child process has exited. | |
444 | do { | |
445 | bytes_read = posix::Read(read_fd(), &flag, 1); | |
446 | } while (bytes_read == -1 && errno == EINTR); | |
447 | ||
448 | if (bytes_read == 0) { | |
449 | set_outcome(DIED); | |
450 | } else if (bytes_read == 1) { | |
451 | switch (flag) { | |
452 | case kDeathTestReturned: | |
453 | set_outcome(RETURNED); | |
454 | break; | |
455 | case kDeathTestThrew: | |
456 | set_outcome(THREW); | |
457 | break; | |
458 | case kDeathTestLived: | |
459 | set_outcome(LIVED); | |
460 | break; | |
461 | case kDeathTestInternalError: | |
462 | FailFromInternalError(read_fd()); // Does not return. | |
463 | break; | |
464 | default: | |
465 | GTEST_LOG_(FATAL) << "Death test child process reported " | |
466 | << "unexpected status byte (" | |
467 | << static_cast<unsigned int>(flag) << ")"; | |
468 | } | |
469 | } else { | |
470 | GTEST_LOG_(FATAL) << "Read from death test child process failed: " | |
471 | << GetLastErrnoDescription(); | |
472 | } | |
473 | GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); | |
474 | set_read_fd(-1); | |
475 | } | |
476 | ||
477 | // Signals that the death test code which should have exited, didn't. | |
478 | // Should be called only in a death test child process. | |
479 | // Writes a status byte to the child's status file descriptor, then | |
480 | // calls _exit(1). | |
481 | void DeathTestImpl::Abort(AbortReason reason) { | |
482 | // The parent process considers the death test to be a failure if | |
483 | // it finds any data in our pipe. So, here we write a single flag byte | |
484 | // to the pipe, then exit. | |
485 | const char status_ch = | |
486 | reason == TEST_DID_NOT_DIE ? kDeathTestLived : | |
487 | reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; | |
488 | ||
489 | GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); | |
490 | // We are leaking the descriptor here because on some platforms (i.e., | |
491 | // when built as Windows DLL), destructors of global objects will still | |
492 | // run after calling _exit(). On such systems, write_fd_ will be | |
493 | // indirectly closed from the destructor of UnitTestImpl, causing double | |
494 | // close if it is also closed here. On debug configurations, double close | |
495 | // may assert. As there are no in-process buffers to flush here, we are | |
496 | // relying on the OS to close the descriptor after the process terminates | |
497 | // when the destructors are not run. | |
498 | _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) | |
499 | } | |
500 | ||
501 | // Returns an indented copy of stderr output for a death test. | |
502 | // This makes distinguishing death test output lines from regular log lines | |
503 | // much easier. | |
504 | static ::std::string FormatDeathTestOutput(const ::std::string& output) { | |
505 | ::std::string ret; | |
506 | for (size_t at = 0; ; ) { | |
507 | const size_t line_end = output.find('\n', at); | |
508 | ret += "[ DEATH ] "; | |
509 | if (line_end == ::std::string::npos) { | |
510 | ret += output.substr(at); | |
511 | break; | |
512 | } | |
513 | ret += output.substr(at, line_end + 1 - at); | |
514 | at = line_end + 1; | |
515 | } | |
516 | return ret; | |
517 | } | |
518 | ||
519 | // Assesses the success or failure of a death test, using both private | |
520 | // members which have previously been set, and one argument: | |
521 | // | |
522 | // Private data members: | |
523 | // outcome: An enumeration describing how the death test | |
524 | // concluded: DIED, LIVED, THREW, or RETURNED. The death test | |
525 | // fails in the latter three cases. | |
526 | // status: The exit status of the child process. On *nix, it is in the | |
527 | // in the format specified by wait(2). On Windows, this is the | |
528 | // value supplied to the ExitProcess() API or a numeric code | |
529 | // of the exception that terminated the program. | |
530 | // regex: A regular expression object to be applied to | |
531 | // the test's captured standard error output; the death test | |
532 | // fails if it does not match. | |
533 | // | |
534 | // Argument: | |
535 | // status_ok: true if exit_status is acceptable in the context of | |
536 | // this particular death test, which fails if it is false | |
537 | // | |
538 | // Returns true iff all of the above conditions are met. Otherwise, the | |
539 | // first failing condition, in the order given above, is the one that is | |
540 | // reported. Also sets the last death test message string. | |
541 | bool DeathTestImpl::Passed(bool status_ok) { | |
542 | if (!spawned()) | |
543 | return false; | |
544 | ||
545 | const std::string error_message = GetCapturedStderr(); | |
546 | ||
547 | bool success = false; | |
548 | Message buffer; | |
549 | ||
550 | buffer << "Death test: " << statement() << "\n"; | |
551 | switch (outcome()) { | |
552 | case LIVED: | |
553 | buffer << " Result: failed to die.\n" | |
554 | << " Error msg:\n" << FormatDeathTestOutput(error_message); | |
555 | break; | |
556 | case THREW: | |
557 | buffer << " Result: threw an exception.\n" | |
558 | << " Error msg:\n" << FormatDeathTestOutput(error_message); | |
559 | break; | |
560 | case RETURNED: | |
561 | buffer << " Result: illegal return in test statement.\n" | |
562 | << " Error msg:\n" << FormatDeathTestOutput(error_message); | |
563 | break; | |
564 | case DIED: | |
565 | if (status_ok) { | |
566 | const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); | |
567 | if (matched) { | |
568 | success = true; | |
569 | } else { | |
570 | buffer << " Result: died but not with expected error.\n" | |
571 | << " Expected: " << regex()->pattern() << "\n" | |
572 | << "Actual msg:\n" << FormatDeathTestOutput(error_message); | |
573 | } | |
574 | } else { | |
575 | buffer << " Result: died but not with expected exit code:\n" | |
576 | << " " << ExitSummary(status()) << "\n" | |
577 | << "Actual msg:\n" << FormatDeathTestOutput(error_message); | |
578 | } | |
579 | break; | |
580 | case IN_PROGRESS: | |
581 | default: | |
582 | GTEST_LOG_(FATAL) | |
583 | << "DeathTest::Passed somehow called before conclusion of test"; | |
584 | } | |
585 | ||
586 | DeathTest::set_last_death_test_message(buffer.GetString()); | |
587 | return success; | |
588 | } | |
589 | ||
590 | # if GTEST_OS_WINDOWS | |
591 | // WindowsDeathTest implements death tests on Windows. Due to the | |
592 | // specifics of starting new processes on Windows, death tests there are | |
593 | // always threadsafe, and Google Test considers the | |
594 | // --gtest_death_test_style=fast setting to be equivalent to | |
595 | // --gtest_death_test_style=threadsafe there. | |
596 | // | |
597 | // A few implementation notes: Like the Linux version, the Windows | |
598 | // implementation uses pipes for child-to-parent communication. But due to | |
599 | // the specifics of pipes on Windows, some extra steps are required: | |
600 | // | |
601 | // 1. The parent creates a communication pipe and stores handles to both | |
602 | // ends of it. | |
603 | // 2. The parent starts the child and provides it with the information | |
604 | // necessary to acquire the handle to the write end of the pipe. | |
605 | // 3. The child acquires the write end of the pipe and signals the parent | |
606 | // using a Windows event. | |
607 | // 4. Now the parent can release the write end of the pipe on its side. If | |
608 | // this is done before step 3, the object's reference count goes down to | |
609 | // 0 and it is destroyed, preventing the child from acquiring it. The | |
610 | // parent now has to release it, or read operations on the read end of | |
611 | // the pipe will not return when the child terminates. | |
612 | // 5. The parent reads child's output through the pipe (outcome code and | |
613 | // any possible error messages) from the pipe, and its stderr and then | |
614 | // determines whether to fail the test. | |
615 | // | |
616 | // Note: to distinguish Win32 API calls from the local method and function | |
617 | // calls, the former are explicitly resolved in the global namespace. | |
618 | // | |
619 | class WindowsDeathTest : public DeathTestImpl { | |
620 | public: | |
621 | WindowsDeathTest(const char* a_statement, | |
622 | const RE* a_regex, | |
623 | const char* file, | |
624 | int line) | |
625 | : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {} | |
626 | ||
627 | // All of these virtual functions are inherited from DeathTest. | |
628 | virtual int Wait(); | |
629 | virtual TestRole AssumeRole(); | |
630 | ||
631 | private: | |
632 | // The name of the file in which the death test is located. | |
633 | const char* const file_; | |
634 | // The line number on which the death test is located. | |
635 | const int line_; | |
636 | // Handle to the write end of the pipe to the child process. | |
637 | AutoHandle write_handle_; | |
638 | // Child process handle. | |
639 | AutoHandle child_handle_; | |
640 | // Event the child process uses to signal the parent that it has | |
641 | // acquired the handle to the write end of the pipe. After seeing this | |
642 | // event the parent can release its own handles to make sure its | |
643 | // ReadFile() calls return when the child terminates. | |
644 | AutoHandle event_handle_; | |
645 | }; | |
646 | ||
647 | // Waits for the child in a death test to exit, returning its exit | |
648 | // status, or 0 if no child process exists. As a side effect, sets the | |
649 | // outcome data member. | |
650 | int WindowsDeathTest::Wait() { | |
651 | if (!spawned()) | |
652 | return 0; | |
653 | ||
654 | // Wait until the child either signals that it has acquired the write end | |
655 | // of the pipe or it dies. | |
656 | const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; | |
657 | switch (::WaitForMultipleObjects(2, | |
658 | wait_handles, | |
659 | FALSE, // Waits for any of the handles. | |
660 | INFINITE)) { | |
661 | case WAIT_OBJECT_0: | |
662 | case WAIT_OBJECT_0 + 1: | |
663 | break; | |
664 | default: | |
665 | GTEST_DEATH_TEST_CHECK_(false); // Should not get here. | |
666 | } | |
667 | ||
668 | // The child has acquired the write end of the pipe or exited. | |
669 | // We release the handle on our side and continue. | |
670 | write_handle_.Reset(); | |
671 | event_handle_.Reset(); | |
672 | ||
673 | ReadAndInterpretStatusByte(); | |
674 | ||
675 | // Waits for the child process to exit if it haven't already. This | |
676 | // returns immediately if the child has already exited, regardless of | |
677 | // whether previous calls to WaitForMultipleObjects synchronized on this | |
678 | // handle or not. | |
679 | GTEST_DEATH_TEST_CHECK_( | |
680 | WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), | |
681 | INFINITE)); | |
682 | DWORD status_code; | |
683 | GTEST_DEATH_TEST_CHECK_( | |
684 | ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); | |
685 | child_handle_.Reset(); | |
686 | set_status(static_cast<int>(status_code)); | |
687 | return status(); | |
688 | } | |
689 | ||
690 | // The AssumeRole process for a Windows death test. It creates a child | |
691 | // process with the same executable as the current process to run the | |
692 | // death test. The child process is given the --gtest_filter and | |
693 | // --gtest_internal_run_death_test flags such that it knows to run the | |
694 | // current death test only. | |
695 | DeathTest::TestRole WindowsDeathTest::AssumeRole() { | |
696 | const UnitTestImpl* const impl = GetUnitTestImpl(); | |
697 | const InternalRunDeathTestFlag* const flag = | |
698 | impl->internal_run_death_test_flag(); | |
699 | const TestInfo* const info = impl->current_test_info(); | |
700 | const int death_test_index = info->result()->death_test_count(); | |
701 | ||
702 | if (flag != NULL) { | |
703 | // ParseInternalRunDeathTestFlag() has performed all the necessary | |
704 | // processing. | |
705 | set_write_fd(flag->write_fd()); | |
706 | return EXECUTE_TEST; | |
707 | } | |
708 | ||
709 | // WindowsDeathTest uses an anonymous pipe to communicate results of | |
710 | // a death test. | |
711 | SECURITY_ATTRIBUTES handles_are_inheritable = { | |
712 | sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; | |
713 | HANDLE read_handle, write_handle; | |
714 | GTEST_DEATH_TEST_CHECK_( | |
715 | ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, | |
716 | 0) // Default buffer size. | |
717 | != FALSE); | |
718 | set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), | |
719 | O_RDONLY)); | |
720 | write_handle_.Reset(write_handle); | |
721 | event_handle_.Reset(::CreateEvent( | |
722 | &handles_are_inheritable, | |
723 | TRUE, // The event will automatically reset to non-signaled state. | |
724 | FALSE, // The initial state is non-signalled. | |
725 | NULL)); // The even is unnamed. | |
726 | GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL); | |
727 | const std::string filter_flag = | |
728 | std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + | |
729 | info->test_case_name() + "." + info->name(); | |
730 | const std::string internal_flag = | |
731 | std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + | |
732 | "=" + file_ + "|" + StreamableToString(line_) + "|" + | |
733 | StreamableToString(death_test_index) + "|" + | |
734 | StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) + | |
735 | // size_t has the same width as pointers on both 32-bit and 64-bit | |
736 | // Windows platforms. | |
737 | // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. | |
738 | "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + | |
739 | "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get())); | |
740 | ||
741 | char executable_path[_MAX_PATH + 1]; // NOLINT | |
742 | GTEST_DEATH_TEST_CHECK_( | |
743 | _MAX_PATH + 1 != ::GetModuleFileNameA(NULL, | |
744 | executable_path, | |
745 | _MAX_PATH)); | |
746 | ||
747 | std::string command_line = | |
748 | std::string(::GetCommandLineA()) + " " + filter_flag + " \"" + | |
749 | internal_flag + "\""; | |
750 | ||
751 | DeathTest::set_last_death_test_message(""); | |
752 | ||
753 | CaptureStderr(); | |
754 | // Flush the log buffers since the log streams are shared with the child. | |
755 | FlushInfoLog(); | |
756 | ||
757 | // The child process will share the standard handles with the parent. | |
758 | STARTUPINFOA startup_info; | |
759 | memset(&startup_info, 0, sizeof(STARTUPINFO)); | |
760 | startup_info.dwFlags = STARTF_USESTDHANDLES; | |
761 | startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); | |
762 | startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); | |
763 | startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); | |
764 | ||
765 | PROCESS_INFORMATION process_info; | |
766 | GTEST_DEATH_TEST_CHECK_(::CreateProcessA( | |
767 | executable_path, | |
768 | const_cast<char*>(command_line.c_str()), | |
769 | NULL, // Retuned process handle is not inheritable. | |
770 | NULL, // Retuned thread handle is not inheritable. | |
771 | TRUE, // Child inherits all inheritable handles (for write_handle_). | |
772 | 0x0, // Default creation flags. | |
773 | NULL, // Inherit the parent's environment. | |
774 | UnitTest::GetInstance()->original_working_dir(), | |
775 | &startup_info, | |
776 | &process_info) != FALSE); | |
777 | child_handle_.Reset(process_info.hProcess); | |
778 | ::CloseHandle(process_info.hThread); | |
779 | set_spawned(true); | |
780 | return OVERSEE_TEST; | |
781 | } | |
782 | # else // We are not on Windows. | |
783 | ||
784 | // ForkingDeathTest provides implementations for most of the abstract | |
785 | // methods of the DeathTest interface. Only the AssumeRole method is | |
786 | // left undefined. | |
787 | class ForkingDeathTest : public DeathTestImpl { | |
788 | public: | |
789 | ForkingDeathTest(const char* statement, const RE* regex); | |
790 | ||
791 | // All of these virtual functions are inherited from DeathTest. | |
792 | virtual int Wait(); | |
793 | ||
794 | protected: | |
795 | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } | |
796 | ||
797 | private: | |
798 | // PID of child process during death test; 0 in the child process itself. | |
799 | pid_t child_pid_; | |
800 | }; | |
801 | ||
802 | // Constructs a ForkingDeathTest. | |
803 | ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) | |
804 | : DeathTestImpl(a_statement, a_regex), | |
805 | child_pid_(-1) {} | |
806 | ||
807 | // Waits for the child in a death test to exit, returning its exit | |
808 | // status, or 0 if no child process exists. As a side effect, sets the | |
809 | // outcome data member. | |
810 | int ForkingDeathTest::Wait() { | |
811 | if (!spawned()) | |
812 | return 0; | |
813 | ||
814 | ReadAndInterpretStatusByte(); | |
815 | ||
816 | int status_value; | |
817 | GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); | |
818 | set_status(status_value); | |
819 | return status_value; | |
820 | } | |
821 | ||
822 | // A concrete death test class that forks, then immediately runs the test | |
823 | // in the child process. | |
824 | class NoExecDeathTest : public ForkingDeathTest { | |
825 | public: | |
826 | NoExecDeathTest(const char* a_statement, const RE* a_regex) : | |
827 | ForkingDeathTest(a_statement, a_regex) { } | |
828 | virtual TestRole AssumeRole(); | |
829 | }; | |
830 | ||
831 | // The AssumeRole process for a fork-and-run death test. It implements a | |
832 | // straightforward fork, with a simple pipe to transmit the status byte. | |
833 | DeathTest::TestRole NoExecDeathTest::AssumeRole() { | |
834 | const size_t thread_count = GetThreadCount(); | |
835 | if (thread_count != 1) { | |
836 | GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); | |
837 | } | |
838 | ||
839 | int pipe_fd[2]; | |
840 | GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); | |
841 | ||
842 | DeathTest::set_last_death_test_message(""); | |
843 | CaptureStderr(); | |
844 | // When we fork the process below, the log file buffers are copied, but the | |
845 | // file descriptors are shared. We flush all log files here so that closing | |
846 | // the file descriptors in the child process doesn't throw off the | |
847 | // synchronization between descriptors and buffers in the parent process. | |
848 | // This is as close to the fork as possible to avoid a race condition in case | |
849 | // there are multiple threads running before the death test, and another | |
850 | // thread writes to the log file. | |
851 | FlushInfoLog(); | |
852 | ||
853 | const pid_t child_pid = fork(); | |
854 | GTEST_DEATH_TEST_CHECK_(child_pid != -1); | |
855 | set_child_pid(child_pid); | |
856 | if (child_pid == 0) { | |
857 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); | |
858 | set_write_fd(pipe_fd[1]); | |
859 | // Redirects all logging to stderr in the child process to prevent | |
860 | // concurrent writes to the log files. We capture stderr in the parent | |
861 | // process and append the child process' output to a log. | |
862 | LogToStderr(); | |
863 | // Event forwarding to the listeners of event listener API mush be shut | |
864 | // down in death test subprocesses. | |
865 | GetUnitTestImpl()->listeners()->SuppressEventForwarding(); | |
866 | g_in_fast_death_test_child = true; | |
867 | return EXECUTE_TEST; | |
868 | } else { | |
869 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); | |
870 | set_read_fd(pipe_fd[0]); | |
871 | set_spawned(true); | |
872 | return OVERSEE_TEST; | |
873 | } | |
874 | } | |
875 | ||
876 | // A concrete death test class that forks and re-executes the main | |
877 | // program from the beginning, with command-line flags set that cause | |
878 | // only this specific death test to be run. | |
879 | class ExecDeathTest : public ForkingDeathTest { | |
880 | public: | |
881 | ExecDeathTest(const char* a_statement, const RE* a_regex, | |
882 | const char* file, int line) : | |
883 | ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { } | |
884 | virtual TestRole AssumeRole(); | |
885 | private: | |
886 | static ::std::vector<testing::internal::string> | |
887 | GetArgvsForDeathTestChildProcess() { | |
888 | ::std::vector<testing::internal::string> args = GetInjectableArgvs(); | |
889 | # if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_) | |
890 | ::std::vector<testing::internal::string> extra_args = | |
891 | GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_(); | |
892 | args.insert(args.end(), extra_args.begin(), extra_args.end()); | |
893 | # endif // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_) | |
894 | return args; | |
895 | } | |
896 | // The name of the file in which the death test is located. | |
897 | const char* const file_; | |
898 | // The line number on which the death test is located. | |
899 | const int line_; | |
900 | }; | |
901 | ||
902 | // Utility class for accumulating command-line arguments. | |
903 | class Arguments { | |
904 | public: | |
905 | Arguments() { | |
906 | args_.push_back(NULL); | |
907 | } | |
908 | ||
909 | ~Arguments() { | |
910 | for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); | |
911 | ++i) { | |
912 | free(*i); | |
913 | } | |
914 | } | |
915 | void AddArgument(const char* argument) { | |
916 | args_.insert(args_.end() - 1, posix::StrDup(argument)); | |
917 | } | |
918 | ||
919 | template <typename Str> | |
920 | void AddArguments(const ::std::vector<Str>& arguments) { | |
921 | for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); | |
922 | i != arguments.end(); | |
923 | ++i) { | |
924 | args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); | |
925 | } | |
926 | } | |
927 | char* const* Argv() { | |
928 | return &args_[0]; | |
929 | } | |
930 | ||
931 | private: | |
932 | std::vector<char*> args_; | |
933 | }; | |
934 | ||
935 | // A struct that encompasses the arguments to the child process of a | |
936 | // threadsafe-style death test process. | |
937 | struct ExecDeathTestArgs { | |
938 | char* const* argv; // Command-line arguments for the child's call to exec | |
939 | int close_fd; // File descriptor to close; the read end of a pipe | |
940 | }; | |
941 | ||
942 | # if GTEST_OS_MAC | |
943 | inline char** GetEnviron() { | |
944 | // When Google Test is built as a framework on MacOS X, the environ variable | |
945 | // is unavailable. Apple's documentation (man environ) recommends using | |
946 | // _NSGetEnviron() instead. | |
947 | return *_NSGetEnviron(); | |
948 | } | |
949 | # else | |
950 | // Some POSIX platforms expect you to declare environ. extern "C" makes | |
951 | // it reside in the global namespace. | |
952 | extern "C" char** environ; | |
953 | inline char** GetEnviron() { return environ; } | |
954 | # endif // GTEST_OS_MAC | |
955 | ||
956 | # if !GTEST_OS_QNX | |
957 | // The main function for a threadsafe-style death test child process. | |
958 | // This function is called in a clone()-ed process and thus must avoid | |
959 | // any potentially unsafe operations like malloc or libc functions. | |
960 | static int ExecDeathTestChildMain(void* child_arg) { | |
961 | ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg); | |
962 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); | |
963 | ||
964 | // We need to execute the test program in the same environment where | |
965 | // it was originally invoked. Therefore we change to the original | |
966 | // working directory first. | |
967 | const char* const original_dir = | |
968 | UnitTest::GetInstance()->original_working_dir(); | |
969 | // We can safely call chdir() as it's a direct system call. | |
970 | if (chdir(original_dir) != 0) { | |
971 | DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + | |
972 | GetLastErrnoDescription()); | |
973 | return EXIT_FAILURE; | |
974 | } | |
975 | ||
976 | // We can safely call execve() as it's a direct system call. We | |
977 | // cannot use execvp() as it's a libc function and thus potentially | |
978 | // unsafe. Since execve() doesn't search the PATH, the user must | |
979 | // invoke the test program via a valid path that contains at least | |
980 | // one path separator. | |
981 | execve(args->argv[0], args->argv, GetEnviron()); | |
982 | DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " + | |
983 | original_dir + " failed: " + | |
984 | GetLastErrnoDescription()); | |
985 | return EXIT_FAILURE; | |
986 | } | |
987 | # endif // !GTEST_OS_QNX | |
988 | ||
989 | // Two utility routines that together determine the direction the stack | |
990 | // grows. | |
991 | // This could be accomplished more elegantly by a single recursive | |
992 | // function, but we want to guard against the unlikely possibility of | |
993 | // a smart compiler optimizing the recursion away. | |
994 | // | |
995 | // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining | |
996 | // StackLowerThanAddress into StackGrowsDown, which then doesn't give | |
997 | // correct answer. | |
998 | void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_; | |
999 | void StackLowerThanAddress(const void* ptr, bool* result) { | |
1000 | int dummy; | |
1001 | *result = (&dummy < ptr); | |
1002 | } | |
1003 | ||
1004 | // Make sure AddressSanitizer does not tamper with the stack here. | |
1005 | GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ | |
1006 | bool StackGrowsDown() { | |
1007 | int dummy; | |
1008 | bool result; | |
1009 | StackLowerThanAddress(&dummy, &result); | |
1010 | return result; | |
1011 | } | |
1012 | ||
1013 | // Spawns a child process with the same executable as the current process in | |
1014 | // a thread-safe manner and instructs it to run the death test. The | |
1015 | // implementation uses fork(2) + exec. On systems where clone(2) is | |
1016 | // available, it is used instead, being slightly more thread-safe. On QNX, | |
1017 | // fork supports only single-threaded environments, so this function uses | |
1018 | // spawn(2) there instead. The function dies with an error message if | |
1019 | // anything goes wrong. | |
1020 | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) { | |
1021 | ExecDeathTestArgs args = { argv, close_fd }; | |
1022 | pid_t child_pid = -1; | |
1023 | ||
1024 | # if GTEST_OS_QNX | |
1025 | // Obtains the current directory and sets it to be closed in the child | |
1026 | // process. | |
1027 | const int cwd_fd = open(".", O_RDONLY); | |
1028 | GTEST_DEATH_TEST_CHECK_(cwd_fd != -1); | |
1029 | GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC)); | |
1030 | // We need to execute the test program in the same environment where | |
1031 | // it was originally invoked. Therefore we change to the original | |
1032 | // working directory first. | |
1033 | const char* const original_dir = | |
1034 | UnitTest::GetInstance()->original_working_dir(); | |
1035 | // We can safely call chdir() as it's a direct system call. | |
1036 | if (chdir(original_dir) != 0) { | |
1037 | DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + | |
1038 | GetLastErrnoDescription()); | |
1039 | return EXIT_FAILURE; | |
1040 | } | |
1041 | ||
1042 | int fd_flags; | |
1043 | // Set close_fd to be closed after spawn. | |
1044 | GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD)); | |
1045 | GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD, | |
1046 | fd_flags | FD_CLOEXEC)); | |
1047 | struct inheritance inherit = {0}; | |
1048 | // spawn is a system call. | |
1049 | child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron()); | |
1050 | // Restores the current working directory. | |
1051 | GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1); | |
1052 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); | |
1053 | ||
1054 | # else // GTEST_OS_QNX | |
1055 | # if GTEST_OS_LINUX | |
1056 | // When a SIGPROF signal is received while fork() or clone() are executing, | |
1057 | // the process may hang. To avoid this, we ignore SIGPROF here and re-enable | |
1058 | // it after the call to fork()/clone() is complete. | |
1059 | struct sigaction saved_sigprof_action; | |
1060 | struct sigaction ignore_sigprof_action; | |
1061 | memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action)); | |
1062 | sigemptyset(&ignore_sigprof_action.sa_mask); | |
1063 | ignore_sigprof_action.sa_handler = SIG_IGN; | |
1064 | GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction( | |
1065 | SIGPROF, &ignore_sigprof_action, &saved_sigprof_action)); | |
1066 | # endif // GTEST_OS_LINUX | |
1067 | ||
1068 | # if GTEST_HAS_CLONE | |
1069 | const bool use_fork = GTEST_FLAG(death_test_use_fork); | |
1070 | ||
1071 | if (!use_fork) { | |
1072 | static const bool stack_grows_down = StackGrowsDown(); | |
1073 | const size_t stack_size = getpagesize(); | |
1074 | // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. | |
1075 | void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, | |
1076 | MAP_ANON | MAP_PRIVATE, -1, 0); | |
1077 | GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); | |
1078 | ||
1079 | // Maximum stack alignment in bytes: For a downward-growing stack, this | |
1080 | // amount is subtracted from size of the stack space to get an address | |
1081 | // that is within the stack space and is aligned on all systems we care | |
1082 | // about. As far as I know there is no ABI with stack alignment greater | |
1083 | // than 64. We assume stack and stack_size already have alignment of | |
1084 | // kMaxStackAlignment. | |
1085 | const size_t kMaxStackAlignment = 64; | |
1086 | void* const stack_top = | |
1087 | static_cast<char*>(stack) + | |
1088 | (stack_grows_down ? stack_size - kMaxStackAlignment : 0); | |
1089 | GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment && | |
1090 | reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0); | |
1091 | ||
1092 | child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); | |
1093 | ||
1094 | GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); | |
1095 | } | |
1096 | # else | |
1097 | const bool use_fork = true; | |
1098 | # endif // GTEST_HAS_CLONE | |
1099 | ||
1100 | if (use_fork && (child_pid = fork()) == 0) { | |
1101 | ExecDeathTestChildMain(&args); | |
1102 | _exit(0); | |
1103 | } | |
1104 | # endif // GTEST_OS_QNX | |
1105 | # if GTEST_OS_LINUX | |
1106 | GTEST_DEATH_TEST_CHECK_SYSCALL_( | |
1107 | sigaction(SIGPROF, &saved_sigprof_action, NULL)); | |
1108 | # endif // GTEST_OS_LINUX | |
1109 | ||
1110 | GTEST_DEATH_TEST_CHECK_(child_pid != -1); | |
1111 | return child_pid; | |
1112 | } | |
1113 | ||
1114 | // The AssumeRole process for a fork-and-exec death test. It re-executes the | |
1115 | // main program from the beginning, setting the --gtest_filter | |
1116 | // and --gtest_internal_run_death_test flags to cause only the current | |
1117 | // death test to be re-run. | |
1118 | DeathTest::TestRole ExecDeathTest::AssumeRole() { | |
1119 | const UnitTestImpl* const impl = GetUnitTestImpl(); | |
1120 | const InternalRunDeathTestFlag* const flag = | |
1121 | impl->internal_run_death_test_flag(); | |
1122 | const TestInfo* const info = impl->current_test_info(); | |
1123 | const int death_test_index = info->result()->death_test_count(); | |
1124 | ||
1125 | if (flag != NULL) { | |
1126 | set_write_fd(flag->write_fd()); | |
1127 | return EXECUTE_TEST; | |
1128 | } | |
1129 | ||
1130 | int pipe_fd[2]; | |
1131 | GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); | |
1132 | // Clear the close-on-exec flag on the write end of the pipe, lest | |
1133 | // it be closed when the child process does an exec: | |
1134 | GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); | |
1135 | ||
1136 | const std::string filter_flag = | |
1137 | std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" | |
1138 | + info->test_case_name() + "." + info->name(); | |
1139 | const std::string internal_flag = | |
1140 | std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" | |
1141 | + file_ + "|" + StreamableToString(line_) + "|" | |
1142 | + StreamableToString(death_test_index) + "|" | |
1143 | + StreamableToString(pipe_fd[1]); | |
1144 | Arguments args; | |
1145 | args.AddArguments(GetArgvsForDeathTestChildProcess()); | |
1146 | args.AddArgument(filter_flag.c_str()); | |
1147 | args.AddArgument(internal_flag.c_str()); | |
1148 | ||
1149 | DeathTest::set_last_death_test_message(""); | |
1150 | ||
1151 | CaptureStderr(); | |
1152 | // See the comment in NoExecDeathTest::AssumeRole for why the next line | |
1153 | // is necessary. | |
1154 | FlushInfoLog(); | |
1155 | ||
1156 | const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); | |
1157 | GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); | |
1158 | set_child_pid(child_pid); | |
1159 | set_read_fd(pipe_fd[0]); | |
1160 | set_spawned(true); | |
1161 | return OVERSEE_TEST; | |
1162 | } | |
1163 | ||
1164 | # endif // !GTEST_OS_WINDOWS | |
1165 | ||
1166 | // Creates a concrete DeathTest-derived class that depends on the | |
1167 | // --gtest_death_test_style flag, and sets the pointer pointed to | |
1168 | // by the "test" argument to its address. If the test should be | |
1169 | // skipped, sets that pointer to NULL. Returns true, unless the | |
1170 | // flag is set to an invalid value. | |
1171 | bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, | |
1172 | const char* file, int line, | |
1173 | DeathTest** test) { | |
1174 | UnitTestImpl* const impl = GetUnitTestImpl(); | |
1175 | const InternalRunDeathTestFlag* const flag = | |
1176 | impl->internal_run_death_test_flag(); | |
1177 | const int death_test_index = impl->current_test_info() | |
1178 | ->increment_death_test_count(); | |
1179 | ||
1180 | if (flag != NULL) { | |
1181 | if (death_test_index > flag->index()) { | |
1182 | DeathTest::set_last_death_test_message( | |
1183 | "Death test count (" + StreamableToString(death_test_index) | |
1184 | + ") somehow exceeded expected maximum (" | |
1185 | + StreamableToString(flag->index()) + ")"); | |
1186 | return false; | |
1187 | } | |
1188 | ||
1189 | if (!(flag->file() == file && flag->line() == line && | |
1190 | flag->index() == death_test_index)) { | |
1191 | *test = NULL; | |
1192 | return true; | |
1193 | } | |
1194 | } | |
1195 | ||
1196 | # if GTEST_OS_WINDOWS | |
1197 | ||
1198 | if (GTEST_FLAG(death_test_style) == "threadsafe" || | |
1199 | GTEST_FLAG(death_test_style) == "fast") { | |
1200 | *test = new WindowsDeathTest(statement, regex, file, line); | |
1201 | } | |
1202 | ||
1203 | # else | |
1204 | ||
1205 | if (GTEST_FLAG(death_test_style) == "threadsafe") { | |
1206 | *test = new ExecDeathTest(statement, regex, file, line); | |
1207 | } else if (GTEST_FLAG(death_test_style) == "fast") { | |
1208 | *test = new NoExecDeathTest(statement, regex); | |
1209 | } | |
1210 | ||
1211 | # endif // GTEST_OS_WINDOWS | |
1212 | ||
1213 | else { // NOLINT - this is more readable than unbalanced brackets inside #if. | |
1214 | DeathTest::set_last_death_test_message( | |
1215 | "Unknown death test style \"" + GTEST_FLAG(death_test_style) | |
1216 | + "\" encountered"); | |
1217 | return false; | |
1218 | } | |
1219 | ||
1220 | return true; | |
1221 | } | |
1222 | ||
1223 | # if GTEST_OS_WINDOWS | |
1224 | // Recreates the pipe and event handles from the provided parameters, | |
1225 | // signals the event, and returns a file descriptor wrapped around the pipe | |
1226 | // handle. This function is called in the child process only. | |
1227 | int GetStatusFileDescriptor(unsigned int parent_process_id, | |
1228 | size_t write_handle_as_size_t, | |
1229 | size_t event_handle_as_size_t) { | |
1230 | AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, | |
1231 | FALSE, // Non-inheritable. | |
1232 | parent_process_id)); | |
1233 | if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { | |
1234 | DeathTestAbort("Unable to open parent process " + | |
1235 | StreamableToString(parent_process_id)); | |
1236 | } | |
1237 | ||
1238 | // TODO(vladl@google.com): Replace the following check with a | |
1239 | // compile-time assertion when available. | |
1240 | GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); | |
1241 | ||
1242 | const HANDLE write_handle = | |
1243 | reinterpret_cast<HANDLE>(write_handle_as_size_t); | |
1244 | HANDLE dup_write_handle; | |
1245 | ||
1246 | // The newly initialized handle is accessible only in in the parent | |
1247 | // process. To obtain one accessible within the child, we need to use | |
1248 | // DuplicateHandle. | |
1249 | if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, | |
1250 | ::GetCurrentProcess(), &dup_write_handle, | |
1251 | 0x0, // Requested privileges ignored since | |
1252 | // DUPLICATE_SAME_ACCESS is used. | |
1253 | FALSE, // Request non-inheritable handler. | |
1254 | DUPLICATE_SAME_ACCESS)) { | |
1255 | DeathTestAbort("Unable to duplicate the pipe handle " + | |
1256 | StreamableToString(write_handle_as_size_t) + | |
1257 | " from the parent process " + | |
1258 | StreamableToString(parent_process_id)); | |
1259 | } | |
1260 | ||
1261 | const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t); | |
1262 | HANDLE dup_event_handle; | |
1263 | ||
1264 | if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, | |
1265 | ::GetCurrentProcess(), &dup_event_handle, | |
1266 | 0x0, | |
1267 | FALSE, | |
1268 | DUPLICATE_SAME_ACCESS)) { | |
1269 | DeathTestAbort("Unable to duplicate the event handle " + | |
1270 | StreamableToString(event_handle_as_size_t) + | |
1271 | " from the parent process " + | |
1272 | StreamableToString(parent_process_id)); | |
1273 | } | |
1274 | ||
1275 | const int write_fd = | |
1276 | ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND); | |
1277 | if (write_fd == -1) { | |
1278 | DeathTestAbort("Unable to convert pipe handle " + | |
1279 | StreamableToString(write_handle_as_size_t) + | |
1280 | " to a file descriptor"); | |
1281 | } | |
1282 | ||
1283 | // Signals the parent that the write end of the pipe has been acquired | |
1284 | // so the parent can release its own write end. | |
1285 | ::SetEvent(dup_event_handle); | |
1286 | ||
1287 | return write_fd; | |
1288 | } | |
1289 | # endif // GTEST_OS_WINDOWS | |
1290 | ||
1291 | // Returns a newly created InternalRunDeathTestFlag object with fields | |
1292 | // initialized from the GTEST_FLAG(internal_run_death_test) flag if | |
1293 | // the flag is specified; otherwise returns NULL. | |
1294 | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { | |
1295 | if (GTEST_FLAG(internal_run_death_test) == "") return NULL; | |
1296 | ||
1297 | // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we | |
1298 | // can use it here. | |
1299 | int line = -1; | |
1300 | int index = -1; | |
1301 | ::std::vector< ::std::string> fields; | |
1302 | SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); | |
1303 | int write_fd = -1; | |
1304 | ||
1305 | # if GTEST_OS_WINDOWS | |
1306 | ||
1307 | unsigned int parent_process_id = 0; | |
1308 | size_t write_handle_as_size_t = 0; | |
1309 | size_t event_handle_as_size_t = 0; | |
1310 | ||
1311 | if (fields.size() != 6 | |
1312 | || !ParseNaturalNumber(fields[1], &line) | |
1313 | || !ParseNaturalNumber(fields[2], &index) | |
1314 | || !ParseNaturalNumber(fields[3], &parent_process_id) | |
1315 | || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) | |
1316 | || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { | |
1317 | DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + | |
1318 | GTEST_FLAG(internal_run_death_test)); | |
1319 | } | |
1320 | write_fd = GetStatusFileDescriptor(parent_process_id, | |
1321 | write_handle_as_size_t, | |
1322 | event_handle_as_size_t); | |
1323 | # else | |
1324 | ||
1325 | if (fields.size() != 4 | |
1326 | || !ParseNaturalNumber(fields[1], &line) | |
1327 | || !ParseNaturalNumber(fields[2], &index) | |
1328 | || !ParseNaturalNumber(fields[3], &write_fd)) { | |
1329 | DeathTestAbort("Bad --gtest_internal_run_death_test flag: " | |
1330 | + GTEST_FLAG(internal_run_death_test)); | |
1331 | } | |
1332 | ||
1333 | # endif // GTEST_OS_WINDOWS | |
1334 | ||
1335 | return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); | |
1336 | } | |
1337 | ||
1338 | } // namespace internal | |
1339 | ||
1340 | #endif // GTEST_HAS_DEATH_TEST | |
1341 | ||
1342 | } // namespace testing |