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