1 |
2 |
jamieiles |
// 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
|