gtest-death-test.cc 45 KB
Newer Older
shiqian's avatar
shiqian committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
30
// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev)
shiqian's avatar
shiqian committed
31
32
33
//
// This file implements death tests.

34
35
#include "gtest/gtest-death-test.h"
#include "gtest/internal/gtest-port.h"
shiqian's avatar
shiqian committed
36

zhanyong.wan's avatar
zhanyong.wan committed
37
#if GTEST_HAS_DEATH_TEST
38
39
40
41
42

#if GTEST_OS_MAC
#include <crt_externs.h>
#endif  // GTEST_OS_MAC

shiqian's avatar
shiqian committed
43
#include <errno.h>
44
#include <fcntl.h>
shiqian's avatar
shiqian committed
45
46
#include <limits.h>
#include <stdarg.h>
47
48
49
50
51

#if GTEST_OS_WINDOWS
#include <windows.h>
#else
#include <sys/mman.h>
52
#include <sys/wait.h>
53
54
#endif  // GTEST_OS_WINDOWS

55
#endif  // GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
56

57
58
#include "gtest/gtest-message.h"
#include "gtest/internal/gtest-string.h"
shiqian's avatar
shiqian committed
59
60
61
62
63
64

// Indicates that this translation unit is part of Google Test's
// implementation.  It must come before gtest-internal-inl.h is
// included, or there will be a compiler error.  This trick is to
// prevent a user from accidentally including gtest-internal-inl.h in
// his code.
zhanyong.wan's avatar
zhanyong.wan committed
65
#define GTEST_IMPLEMENTATION_ 1
66
#include "src/gtest-internal-inl.h"
zhanyong.wan's avatar
zhanyong.wan committed
67
#undef GTEST_IMPLEMENTATION_
shiqian's avatar
shiqian committed
68
69
70
71
72
73
74
75

namespace testing {

// Constants.

// The default death test style.
static const char kDefaultDeathTestStyle[] = "fast";

shiqian's avatar
shiqian committed
76
GTEST_DEFINE_string_(
shiqian's avatar
shiqian committed
77
78
79
80
81
82
83
84
    death_test_style,
    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
    "Indicates how to run a death test in a forked child process: "
    "\"threadsafe\" (child process re-executes the test binary "
    "from the beginning, running only the specific death test) or "
    "\"fast\" (child process runs the death test immediately "
    "after forking).");

85
86
87
88
GTEST_DEFINE_bool_(
    death_test_use_fork,
    internal::BoolFromGTestEnv("death_test_use_fork", false),
    "Instructs to use fork()/_exit() instead of clone() in death tests. "
89
90
91
    "Ignored and always uses fork() on POSIX systems where clone() is not "
    "implemented. Useful when running under valgrind or similar tools if "
    "those do not support clone(). Valgrind 3.3.1 will just fail if "
92
93
94
95
96
    "it sees an unsupported combination of clone() flags. "
    "It is not recommended to use this flag w/o valgrind though it will "
    "work in 99% of the cases. Once valgrind is fixed, this flag will "
    "most likely be removed.");

shiqian's avatar
shiqian committed
97
namespace internal {
shiqian's avatar
shiqian committed
98
GTEST_DEFINE_string_(
shiqian's avatar
shiqian committed
99
100
101
102
103
104
105
106
107
    internal_run_death_test, "",
    "Indicates the file, line number, temporal index of "
    "the single death test to run, and a file descriptor to "
    "which a success code may be sent, all separated by "
    "colons.  This flag is specified if and only if the current "
    "process is a sub-process launched for running a thread-safe "
    "death test.  FOR INTERNAL USE ONLY.");
}  // namespace internal

zhanyong.wan's avatar
zhanyong.wan committed
108
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
109
110
111
112
113
114
115

// ExitedWithCode constructor.
ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
}

// ExitedWithCode function-call operator.
bool ExitedWithCode::operator()(int exit_status) const {
116
117
118
#if GTEST_OS_WINDOWS
  return exit_status == exit_code_;
#else
shiqian's avatar
shiqian committed
119
  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
120
#endif  // GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
121
122
}

123
#if !GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
124
125
126
127
128
129
130
131
// KilledBySignal constructor.
KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
}

// KilledBySignal function-call operator.
bool KilledBySignal::operator()(int exit_status) const {
  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
}
132
#endif  // !GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
133
134
135
136
137
138
139
140
141

namespace internal {

// Utilities needed for death tests.

// Generates a textual description of a given exit code, in the format
// specified by wait(2).
static String ExitSummary(int exit_code) {
  Message m;
142
143
144
#if GTEST_OS_WINDOWS
  m << "Exited with exit status " << exit_code;
#else
shiqian's avatar
shiqian committed
145
146
147
148
149
150
151
152
153
154
  if (WIFEXITED(exit_code)) {
    m << "Exited with exit status " << WEXITSTATUS(exit_code);
  } else if (WIFSIGNALED(exit_code)) {
    m << "Terminated by signal " << WTERMSIG(exit_code);
  }
#ifdef WCOREDUMP
  if (WCOREDUMP(exit_code)) {
    m << " (core dumped)";
  }
#endif
155
#endif  // GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
156
157
158
159
160
161
162
163
164
  return m.GetString();
}

// Returns true if exit_status describes a process that was terminated
// by a signal, or exited normally with a nonzero exit code.
bool ExitedUnsuccessfully(int exit_status) {
  return !ExitedWithCode(0)(exit_status);
}

165
#if !GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
166
167
168
169
170
171
172
// Generates a textual failure message when a death test finds more than
// one thread running, or cannot determine the number of threads, prior
// to executing the given statement.  It is the responsibility of the
// caller not to pass a thread_count of 1.
static String DeathTestThreadWarning(size_t thread_count) {
  Message msg;
  msg << "Death tests use fork(), which is unsafe particularly"
zhanyong.wan's avatar
zhanyong.wan committed
173
      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
shiqian's avatar
shiqian committed
174
175
176
177
178
179
  if (thread_count == 0)
    msg << "couldn't detect the number of threads.";
  else
    msg << "detected " << thread_count << " threads.";
  return msg.GetString();
}
180
#endif  // !GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
181
182
183
184

// Flag characters for reporting a death test that did not die.
static const char kDeathTestLived = 'L';
static const char kDeathTestReturned = 'R';
185
static const char kDeathTestThrew = 'T';
shiqian's avatar
shiqian committed
186
187
static const char kDeathTestInternalError = 'I';

188
189
190
191
192
193
194
195
196
197
// An enumeration describing all of the possible ways that a death test can
// conclude.  DIED means that the process died while executing the test
// code; LIVED means that process lived beyond the end of the test code;
// RETURNED means that the test statement attempted to execute a return
// statement, which is not allowed; THREW means that the test statement
// returned control by throwing an exception.  IN_PROGRESS means the test
// has not yet concluded.
// TODO(vladl@google.com): Unify names and possibly values for
// AbortReason, DeathTestOutcome, and flag characters above.
enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
shiqian's avatar
shiqian committed
198
199

// Routine for aborting the program which is safe to call from an
200
// exec-style death test child process, in which case the error
shiqian's avatar
shiqian committed
201
202
203
// message is propagated back to the parent process.  Otherwise, the
// message is simply printed to stderr.  In either case, the program
// then exits with status 1.
204
205
206
207
void DeathTestAbort(const String& message) {
  // On a POSIX system, this function may be called from a threadsafe-style
  // death test child process, which operates on a very small stack.  Use
  // the heap for any additional non-minuscule memory requirements.
shiqian's avatar
shiqian committed
208
209
210
  const InternalRunDeathTestFlag* const flag =
      GetUnitTestImpl()->internal_run_death_test_flag();
  if (flag != NULL) {
211
    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
shiqian's avatar
shiqian committed
212
    fputc(kDeathTestInternalError, parent);
213
214
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
shiqian's avatar
shiqian committed
215
216
    _exit(1);
  } else {
217
218
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
shiqian's avatar
shiqian committed
219
220
221
222
223
224
    abort();
  }
}

// A replacement for CHECK that calls DeathTestAbort if the assertion
// fails.
shiqian's avatar
shiqian committed
225
#define GTEST_DEATH_TEST_CHECK_(expression) \
shiqian's avatar
shiqian committed
226
  do { \
227
228
    if (!::testing::internal::IsTrue(expression)) { \
      DeathTestAbort(::testing::internal::String::Format( \
229
230
          "CHECK failed: File %s, line %d: %s", \
          __FILE__, __LINE__, #expression)); \
shiqian's avatar
shiqian committed
231
    } \
232
  } while (::testing::internal::AlwaysFalse())
shiqian's avatar
shiqian committed
233

shiqian's avatar
shiqian committed
234
// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
shiqian's avatar
shiqian committed
235
236
237
238
239
240
// evaluating any system call that fulfills two conditions: it must return
// -1 on failure, and set errno to EINTR when it is interrupted and
// should be tried again.  The macro expands to a loop that repeatedly
// evaluates the expression as long as it evaluates to -1 and sets
// errno to EINTR.  If the expression evaluates to -1 but errno is
// something other than EINTR, DeathTestAbort is called.
shiqian's avatar
shiqian committed
241
#define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
shiqian's avatar
shiqian committed
242
  do { \
243
    int gtest_retval; \
shiqian's avatar
shiqian committed
244
    do { \
245
246
247
      gtest_retval = (expression); \
    } while (gtest_retval == -1 && errno == EINTR); \
    if (gtest_retval == -1) { \
248
      DeathTestAbort(::testing::internal::String::Format( \
249
250
          "CHECK failed: File %s, line %d: %s != -1", \
          __FILE__, __LINE__, #expression)); \
shiqian's avatar
shiqian committed
251
    } \
252
  } while (::testing::internal::AlwaysFalse())
shiqian's avatar
shiqian committed
253

254
255
// Returns the message describing the last system error in errno.
String GetLastErrnoDescription() {
256
    return String(errno == 0 ? "" : posix::StrError(errno));
257
258
}

259
260
261
262
263
264
265
266
267
268
// This is called from a death test parent process to read a failure
// message from the death test child process and log it with the FATAL
// severity. On Windows, the message is read from a pipe handle. On other
// platforms, it is read from a file descriptor.
static void FailFromInternalError(int fd) {
  Message error;
  char buffer[256];
  int num_read;

  do {
269
    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
270
271
272
273
274
275
      buffer[num_read] = '\0';
      error << buffer;
    }
  } while (num_read == -1 && errno == EINTR);

  if (num_read == 0) {
276
    GTEST_LOG_(FATAL) << error.GetString();
277
278
  } else {
    const int last_error = errno;
279
    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
280
                      << GetLastErrnoDescription() << " [" << last_error << "]";
281
282
  }
}
283

shiqian's avatar
shiqian committed
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
// Death test constructor.  Increments the running death test count
// for the current test.
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == NULL) {
    DeathTestAbort("Cannot run a death test outside of a TEST or "
                   "TEST_F construct");
  }
}

// Creates and returns a death test by dispatching to the current
// death test factory.
bool DeathTest::Create(const char* statement, const RE* regex,
                       const char* file, int line, DeathTest** test) {
  return GetUnitTestImpl()->death_test_factory()->Create(
      statement, regex, file, line, test);
}

const char* DeathTest::LastMessage() {
303
304
305
306
307
  return last_death_test_message_.c_str();
}

void DeathTest::set_last_death_test_message(const String& message) {
  last_death_test_message_ = message;
shiqian's avatar
shiqian committed
308
309
}

310
311
312
313
314
String DeathTest::last_death_test_message_;

// Provides cross platform implementation for some death functionality.
class DeathTestImpl : public DeathTest {
 protected:
315
316
317
  DeathTestImpl(const char* a_statement, const RE* a_regex)
      : statement_(a_statement),
        regex_(a_regex),
318
319
        spawned_(false),
        status_(-1),
320
321
322
        outcome_(IN_PROGRESS),
        read_fd_(-1),
        write_fd_(-1) {}
323

324
325
326
327
  // read_fd_ is expected to be closed and cleared by a derived class.
  ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }

  void Abort(AbortReason reason);
328
329
330
331
332
  virtual bool Passed(bool status_ok);

  const char* statement() const { return statement_; }
  const RE* regex() const { return regex_; }
  bool spawned() const { return spawned_; }
333
  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
334
  int status() const { return status_; }
335
  void set_status(int a_status) { status_ = a_status; }
336
  DeathTestOutcome outcome() const { return outcome_; }
337
  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
338
339
340
341
342
343
344
345
346
347
  int read_fd() const { return read_fd_; }
  void set_read_fd(int fd) { read_fd_ = fd; }
  int write_fd() const { return write_fd_; }
  void set_write_fd(int fd) { write_fd_ = fd; }

  // Called in the parent process only. Reads the result code of the death
  // test child process via a pipe, interprets it to set the outcome_
  // member, and closes read_fd_.  Outputs diagnostics and terminates in
  // case of unexpected codes.
  void ReadAndInterpretStatusByte();
348
349
350
351
352
353
354
355
356
357
358
359
360
361

 private:
  // The textual content of the code this object is testing.  This class
  // doesn't own this string and should not attempt to delete it.
  const char* const statement_;
  // The regular expression which test output must match.  DeathTestImpl
  // doesn't own this object and should not attempt to delete it.
  const RE* const regex_;
  // True if the death test child process has been successfully spawned.
  bool spawned_;
  // The exit status of the child process.
  int status_;
  // How the death test concluded.
  DeathTestOutcome outcome_;
362
363
364
365
366
367
368
369
  // Descriptor to the read end of the pipe to the child process.  It is
  // always -1 in the child process.  The child keeps its write end of the
  // pipe in write_fd_.
  int read_fd_;
  // Descriptor to the child's write end of the pipe to the parent process.
  // It is always -1 in the parent process.  The parent keeps its end of the
  // pipe in read_fd_.
  int write_fd_;
370
371
};

372
373
374
375
376
377
378
379
380
381
382
383
384
// Called in the parent process only. Reads the result code of the death
// test child process via a pipe, interprets it to set the outcome_
// member, and closes read_fd_.  Outputs diagnostics and terminates in
// case of unexpected codes.
void DeathTestImpl::ReadAndInterpretStatusByte() {
  char flag;
  int bytes_read;

  // The read() here blocks until data is available (signifying the
  // failure of the death test) or until the pipe is closed (signifying
  // its success), so it's okay to call this in the parent before
  // the child process has exited.
  do {
385
    bytes_read = posix::Read(read_fd(), &flag, 1);
386
387
388
389
390
391
392
393
394
  } while (bytes_read == -1 && errno == EINTR);

  if (bytes_read == 0) {
    set_outcome(DIED);
  } else if (bytes_read == 1) {
    switch (flag) {
      case kDeathTestReturned:
        set_outcome(RETURNED);
        break;
395
396
397
      case kDeathTestThrew:
        set_outcome(THREW);
        break;
398
399
400
401
402
403
404
      case kDeathTestLived:
        set_outcome(LIVED);
        break;
      case kDeathTestInternalError:
        FailFromInternalError(read_fd());  // Does not return.
        break;
      default:
405
406
407
        GTEST_LOG_(FATAL) << "Death test child process reported "
                          << "unexpected status byte ("
                          << static_cast<unsigned int>(flag) << ")";
408
409
    }
  } else {
410
    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
411
                      << GetLastErrnoDescription();
412
  }
413
  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
414
415
416
417
418
419
420
421
422
423
424
425
  set_read_fd(-1);
}

// Signals that the death test code which should have exited, didn't.
// Should be called only in a death test child process.
// Writes a status byte to the child's status file descriptor, then
// calls _exit(1).
void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
  // to the pipe, then exit.
  const char status_ch =
426
427
428
      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;

429
  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
430
431
432
433
434
435
436
437
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
  // run after calling _exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
438
439
440
  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
}

441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
// Returns an indented copy of stderr output for a death test.
// This makes distinguishing death test output lines from regular log lines
// much easier.
static ::std::string FormatDeathTestOutput(const ::std::string& output) {
  ::std::string ret;
  for (size_t at = 0; ; ) {
    const size_t line_end = output.find('\n', at);
    ret += "[  DEATH   ] ";
    if (line_end == ::std::string::npos) {
      ret += output.substr(at);
      break;
    }
    ret += output.substr(at, line_end + 1 - at);
    at = line_end + 1;
  }
  return ret;
}

459
460
461
462
463
// Assesses the success or failure of a death test, using both private
// members which have previously been set, and one argument:
//
// Private data members:
//   outcome:  An enumeration describing how the death test
464
465
//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
//             fails in the latter three cases.
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
//   status:   The exit status of the child process. On *nix, it is in the
//             in the format specified by wait(2). On Windows, this is the
//             value supplied to the ExitProcess() API or a numeric code
//             of the exception that terminated the program.
//   regex:    A regular expression object to be applied to
//             the test's captured standard error output; the death test
//             fails if it does not match.
//
// Argument:
//   status_ok: true if exit_status is acceptable in the context of
//              this particular death test, which fails if it is false
//
// Returns true iff all of the above conditions are met.  Otherwise, the
// first failing condition, in the order given above, is the one that is
// reported. Also sets the last death test message string.
bool DeathTestImpl::Passed(bool status_ok) {
  if (!spawned())
    return false;

485
  const String error_message = GetCapturedStderr();
486
487
488
489
490
491
492
493

  bool success = false;
  Message buffer;

  buffer << "Death test: " << statement() << "\n";
  switch (outcome()) {
    case LIVED:
      buffer << "    Result: failed to die.\n"
494
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
495
      break;
496
497
    case THREW:
      buffer << "    Result: threw an exception.\n"
498
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
499
      break;
500
501
    case RETURNED:
      buffer << "    Result: illegal return in test statement.\n"
502
             << " Error msg:\n" << FormatDeathTestOutput(error_message);
503
504
505
      break;
    case DIED:
      if (status_ok) {
506
507
        const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
        if (matched) {
508
509
510
511
          success = true;
        } else {
          buffer << "    Result: died but not with expected error.\n"
                 << "  Expected: " << regex()->pattern() << "\n"
512
                 << "Actual msg:\n" << FormatDeathTestOutput(error_message);
513
514
515
        }
      } else {
        buffer << "    Result: died but not with expected exit code:\n"
516
517
               << "            " << ExitSummary(status()) << "\n"
               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
518
519
520
521
      }
      break;
    case IN_PROGRESS:
    default:
522
523
      GTEST_LOG_(FATAL)
          << "DeathTest::Passed somehow called before conclusion of test";
524
525
526
527
528
  }

  DeathTest::set_last_death_test_message(buffer.GetString());
  return success;
}
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560

#if GTEST_OS_WINDOWS
// WindowsDeathTest implements death tests on Windows. Due to the
// specifics of starting new processes on Windows, death tests there are
// always threadsafe, and Google Test considers the
// --gtest_death_test_style=fast setting to be equivalent to
// --gtest_death_test_style=threadsafe there.
//
// A few implementation notes:  Like the Linux version, the Windows
// implementation uses pipes for child-to-parent communication. But due to
// the specifics of pipes on Windows, some extra steps are required:
//
// 1. The parent creates a communication pipe and stores handles to both
//    ends of it.
// 2. The parent starts the child and provides it with the information
//    necessary to acquire the handle to the write end of the pipe.
// 3. The child acquires the write end of the pipe and signals the parent
//    using a Windows event.
// 4. Now the parent can release the write end of the pipe on its side. If
//    this is done before step 3, the object's reference count goes down to
//    0 and it is destroyed, preventing the child from acquiring it. The
//    parent now has to release it, or read operations on the read end of
//    the pipe will not return when the child terminates.
// 5. The parent reads child's output through the pipe (outcome code and
//    any possible error messages) from the pipe, and its stderr and then
//    determines whether to fail the test.
//
// Note: to distinguish Win32 API calls from the local method and function
// calls, the former are explicitly resolved in the global namespace.
//
class WindowsDeathTest : public DeathTestImpl {
 public:
561
562
  WindowsDeathTest(const char* a_statement,
                   const RE* a_regex,
563
564
                   const char* file,
                   int line)
565
      : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612

  // All of these virtual functions are inherited from DeathTest.
  virtual int Wait();
  virtual TestRole AssumeRole();

 private:
  // The name of the file in which the death test is located.
  const char* const file_;
  // The line number on which the death test is located.
  const int line_;
  // Handle to the write end of the pipe to the child process.
  AutoHandle write_handle_;
  // Child process handle.
  AutoHandle child_handle_;
  // Event the child process uses to signal the parent that it has
  // acquired the handle to the write end of the pipe. After seeing this
  // event the parent can release its own handles to make sure its
  // ReadFile() calls return when the child terminates.
  AutoHandle event_handle_;
};

// Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists.  As a side effect, sets the
// outcome data member.
int WindowsDeathTest::Wait() {
  if (!spawned())
    return 0;

  // Wait until the child either signals that it has acquired the write end
  // of the pipe or it dies.
  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
  switch (::WaitForMultipleObjects(2,
                                   wait_handles,
                                   FALSE,  // Waits for any of the handles.
                                   INFINITE)) {
    case WAIT_OBJECT_0:
    case WAIT_OBJECT_0 + 1:
      break;
    default:
      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
  }

  // The child has acquired the write end of the pipe or exited.
  // We release the handle on our side and continue.
  write_handle_.Reset();
  event_handle_.Reset();

613
  ReadAndInterpretStatusByte();
614
615
616
617
618
619
620
621

  // Waits for the child process to exit if it haven't already. This
  // returns immediately if the child has already exited, regardless of
  // whether previous calls to WaitForMultipleObjects synchronized on this
  // handle or not.
  GTEST_DEATH_TEST_CHECK_(
      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
                                             INFINITE));
622
623
624
  DWORD status_code;
  GTEST_DEATH_TEST_CHECK_(
      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
625
  child_handle_.Reset();
626
627
  set_status(static_cast<int>(status_code));
  return status();
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
}

// The AssumeRole process for a Windows death test.  It creates a child
// process with the same executable as the current process to run the
// death test.  The child process is given the --gtest_filter and
// --gtest_internal_run_death_test flags such that it knows to run the
// current death test only.
DeathTest::TestRole WindowsDeathTest::AssumeRole() {
  const UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const TestInfo* const info = impl->current_test_info();
  const int death_test_index = info->result()->death_test_count();

  if (flag != NULL) {
    // ParseInternalRunDeathTestFlag() has performed all the necessary
    // processing.
645
    set_write_fd(flag->write_fd());
646
647
648
649
650
651
652
653
    return EXECUTE_TEST;
  }

  // WindowsDeathTest uses an anonymous pipe to communicate results of
  // a death test.
  SECURITY_ATTRIBUTES handles_are_inheritable = {
    sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
  HANDLE read_handle, write_handle;
654
655
656
657
  GTEST_DEATH_TEST_CHECK_(
      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
                   0)  // Default buffer size.
      != FALSE);
658
659
  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
                                O_RDONLY));
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
  write_handle_.Reset(write_handle);
  event_handle_.Reset(::CreateEvent(
      &handles_are_inheritable,
      TRUE,    // The event will automatically reset to non-signaled state.
      FALSE,   // The initial state is non-signalled.
      NULL));  // The even is unnamed.
  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL);
  const String filter_flag = String::Format("--%s%s=%s.%s",
                                            GTEST_FLAG_PREFIX_, kFilterFlag,
                                            info->test_case_name(),
                                            info->name());
  const String internal_flag = String::Format(
    "--%s%s=%s|%d|%d|%u|%Iu|%Iu",
      GTEST_FLAG_PREFIX_,
      kInternalRunDeathTestFlag,
      file_, line_,
      death_test_index,
      static_cast<unsigned int>(::GetCurrentProcessId()),
      // size_t has the same with as pointers on both 32-bit and 64-bit
      // Windows platforms.
      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
      reinterpret_cast<size_t>(write_handle),
      reinterpret_cast<size_t>(event_handle_.Get()));

  char executable_path[_MAX_PATH + 1];  // NOLINT
  GTEST_DEATH_TEST_CHECK_(
      _MAX_PATH + 1 != ::GetModuleFileNameA(NULL,
                                            executable_path,
                                            _MAX_PATH));

  String command_line = String::Format("%s %s \"%s\"",
                                       ::GetCommandLineA(),
                                       filter_flag.c_str(),
                                       internal_flag.c_str());

  DeathTest::set_last_death_test_message("");

  CaptureStderr();
  // Flush the log buffers since the log streams are shared with the child.
  FlushInfoLog();

  // The child process will share the standard handles with the parent.
  STARTUPINFOA startup_info;
  memset(&startup_info, 0, sizeof(STARTUPINFO));
  startup_info.dwFlags = STARTF_USESTDHANDLES;
  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);

  PROCESS_INFORMATION process_info;
  GTEST_DEATH_TEST_CHECK_(::CreateProcessA(
      executable_path,
      const_cast<char*>(command_line.c_str()),
      NULL,   // Retuned process handle is not inheritable.
      NULL,   // Retuned thread handle is not inheritable.
      TRUE,   // Child inherits all inheritable handles (for write_handle_).
      0x0,    // Default creation flags.
      NULL,   // Inherit the parent's environment.
      UnitTest::GetInstance()->original_working_dir(),
      &startup_info,
720
      &process_info) != FALSE);
721
722
723
724
725
726
727
  child_handle_.Reset(process_info.hProcess);
  ::CloseHandle(process_info.hThread);
  set_spawned(true);
  return OVERSEE_TEST;
}
#else  // We are not on Windows.

shiqian's avatar
shiqian committed
728
729
730
// ForkingDeathTest provides implementations for most of the abstract
// methods of the DeathTest interface.  Only the AssumeRole method is
// left undefined.
731
class ForkingDeathTest : public DeathTestImpl {
shiqian's avatar
shiqian committed
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
 public:
  ForkingDeathTest(const char* statement, const RE* regex);

  // All of these virtual functions are inherited from DeathTest.
  virtual int Wait();

 protected:
  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }

 private:
  // PID of child process during death test; 0 in the child process itself.
  pid_t child_pid_;
};

// Constructs a ForkingDeathTest.
747
748
ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
    : DeathTestImpl(a_statement, a_regex),
749
      child_pid_(-1) {}
shiqian's avatar
shiqian committed
750
751
752
753
754

// Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists.  As a side effect, sets the
// outcome data member.
int ForkingDeathTest::Wait() {
755
  if (!spawned())
shiqian's avatar
shiqian committed
756
757
    return 0;

758
  ReadAndInterpretStatusByte();
shiqian's avatar
shiqian committed
759

760
761
762
763
  int status_value;
  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
  set_status(status_value);
  return status_value;
shiqian's avatar
shiqian committed
764
765
766
767
768
769
}

// A concrete death test class that forks, then immediately runs the test
// in the child process.
class NoExecDeathTest : public ForkingDeathTest {
 public:
770
771
  NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      ForkingDeathTest(a_statement, a_regex) { }
shiqian's avatar
shiqian committed
772
773
774
775
776
777
778
779
  virtual TestRole AssumeRole();
};

// The AssumeRole process for a fork-and-run death test.  It implements a
// straightforward fork, with a simple pipe to transmit the status byte.
DeathTest::TestRole NoExecDeathTest::AssumeRole() {
  const size_t thread_count = GetThreadCount();
  if (thread_count != 1) {
780
    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
shiqian's avatar
shiqian committed
781
782
783
  }

  int pipe_fd[2];
shiqian's avatar
shiqian committed
784
  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
shiqian's avatar
shiqian committed
785

786
  DeathTest::set_last_death_test_message("");
shiqian's avatar
shiqian committed
787
788
789
790
791
792
793
794
795
796
797
  CaptureStderr();
  // When we fork the process below, the log file buffers are copied, but the
  // file descriptors are shared.  We flush all log files here so that closing
  // the file descriptors in the child process doesn't throw off the
  // synchronization between descriptors and buffers in the parent process.
  // This is as close to the fork as possible to avoid a race condition in case
  // there are multiple threads running before the death test, and another
  // thread writes to the log file.
  FlushInfoLog();

  const pid_t child_pid = fork();
shiqian's avatar
shiqian committed
798
  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
shiqian's avatar
shiqian committed
799
800
  set_child_pid(child_pid);
  if (child_pid == 0) {
shiqian's avatar
shiqian committed
801
    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
shiqian's avatar
shiqian committed
802
803
804
805
806
    set_write_fd(pipe_fd[1]);
    // Redirects all logging to stderr in the child process to prevent
    // concurrent writes to the log files.  We capture stderr in the parent
    // process and append the child process' output to a log.
    LogToStderr();
807
808
809
    // Event forwarding to the listeners of event listener API mush be shut
    // down in death test subprocesses.
    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
shiqian's avatar
shiqian committed
810
811
    return EXECUTE_TEST;
  } else {
shiqian's avatar
shiqian committed
812
    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
shiqian's avatar
shiqian committed
813
    set_read_fd(pipe_fd[0]);
814
    set_spawned(true);
shiqian's avatar
shiqian committed
815
816
817
818
819
820
821
822
823
    return OVERSEE_TEST;
  }
}

// A concrete death test class that forks and re-executes the main
// program from the beginning, with command-line flags set that cause
// only this specific death test to be run.
class ExecDeathTest : public ForkingDeathTest {
 public:
824
  ExecDeathTest(const char* a_statement, const RE* a_regex,
shiqian's avatar
shiqian committed
825
                const char* file, int line) :
826
      ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { }
shiqian's avatar
shiqian committed
827
828
829
830
831
832
833
834
835
836
837
838
839
840
  virtual TestRole AssumeRole();
 private:
  // The name of the file in which the death test is located.
  const char* const file_;
  // The line number on which the death test is located.
  const int line_;
};

// Utility class for accumulating command-line arguments.
class Arguments {
 public:
  Arguments() {
    args_.push_back(NULL);
  }
841

shiqian's avatar
shiqian committed
842
  ~Arguments() {
843
    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
shiqian's avatar
shiqian committed
844
845
846
847
848
         ++i) {
      free(*i);
    }
  }
  void AddArgument(const char* argument) {
849
    args_.insert(args_.end() - 1, posix::StrDup(argument));
shiqian's avatar
shiqian committed
850
851
852
853
854
855
856
  }

  template <typename Str>
  void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
857
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
shiqian's avatar
shiqian committed
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
    }
  }
  char* const* Argv() {
    return &args_[0];
  }
 private:
  std::vector<char*> args_;
};

// A struct that encompasses the arguments to the child process of a
// threadsafe-style death test process.
struct ExecDeathTestArgs {
  char* const* argv;  // Command-line arguments for the child's call to exec
  int close_fd;       // File descriptor to close; the read end of a pipe
};

874
875
876
877
878
879
880
881
#if GTEST_OS_MAC
inline char** GetEnviron() {
  // When Google Test is built as a framework on MacOS X, the environ variable
  // is unavailable. Apple's documentation (man environ) recommends using
  // _NSGetEnviron() instead.
  return *_NSGetEnviron();
}
#else
882
883
884
885
// Some POSIX platforms expect you to declare environ. extern "C" makes
// it reside in the global namespace.
extern "C" char** environ;
inline char** GetEnviron() { return environ; }
886
887
#endif  // GTEST_OS_MAC

shiqian's avatar
shiqian committed
888
// The main function for a threadsafe-style death test child process.
889
890
// This function is called in a clone()-ed process and thus must avoid
// any potentially unsafe operations like malloc or libc functions.
shiqian's avatar
shiqian committed
891
892
static int ExecDeathTestChildMain(void* child_arg) {
  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
shiqian's avatar
shiqian committed
893
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
894
895
896
897
898
899
900
901

  // We need to execute the test program in the same environment where
  // it was originally invoked.  Therefore we change to the original
  // working directory first.
  const char* const original_dir =
      UnitTest::GetInstance()->original_working_dir();
  // We can safely call chdir() as it's a direct system call.
  if (chdir(original_dir) != 0) {
902
903
    DeathTestAbort(String::Format("chdir(\"%s\") failed: %s",
                                  original_dir,
904
                                  GetLastErrnoDescription().c_str()));
905
906
907
908
909
910
911
912
    return EXIT_FAILURE;
  }

  // We can safely call execve() as it's a direct system call.  We
  // cannot use execvp() as it's a libc function and thus potentially
  // unsafe.  Since execve() doesn't search the PATH, the user must
  // invoke the test program via a valid path that contains at least
  // one path separator.
913
  execve(args->argv[0], args->argv, GetEnviron());
914
915
916
  DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s",
                                args->argv[0],
                                original_dir,
917
                                GetLastErrnoDescription().c_str()));
shiqian's avatar
shiqian committed
918
919
920
921
922
923
924
925
  return EXIT_FAILURE;
}

// Two utility routines that together determine the direction the stack
// grows.
// This could be accomplished more elegantly by a single recursive
// function, but we want to guard against the unlikely possibility of
// a smart compiler optimizing the recursion away.
926
bool StackLowerThanAddress(const void* ptr) {
shiqian's avatar
shiqian committed
927
928
929
930
  int dummy;
  return &dummy < ptr;
}

931
bool StackGrowsDown() {
shiqian's avatar
shiqian committed
932
933
934
935
936
937
938
939
940
  int dummy;
  return StackLowerThanAddress(&dummy);
}

// A threadsafe implementation of fork(2) for threadsafe-style death tests
// that uses clone(2).  It dies with an error message if anything goes
// wrong.
static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
  ExecDeathTestArgs args = { argv, close_fd };
941
  pid_t child_pid = -1;
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964

#if GTEST_HAS_CLONE
  const bool use_fork = GTEST_FLAG(death_test_use_fork);

  if (!use_fork) {
    static const bool stack_grows_down = StackGrowsDown();
    const size_t stack_size = getpagesize();
    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
    void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE,
                             MAP_ANON | MAP_PRIVATE, -1, 0);
    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
    void* const stack_top =
        static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0);

    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);

    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
  }
#else
  const bool use_fork = true;
#endif  // GTEST_HAS_CLONE

  if (use_fork && (child_pid = fork()) == 0) {
965
966
967
      ExecDeathTestChildMain(&args);
      _exit(0);
  }
968

shiqian's avatar
shiqian committed
969
  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
shiqian's avatar
shiqian committed
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
  return child_pid;
}

// The AssumeRole process for a fork-and-exec death test.  It re-executes the
// main program from the beginning, setting the --gtest_filter
// and --gtest_internal_run_death_test flags to cause only the current
// death test to be re-run.
DeathTest::TestRole ExecDeathTest::AssumeRole() {
  const UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const TestInfo* const info = impl->current_test_info();
  const int death_test_index = info->result()->death_test_count();

  if (flag != NULL) {
985
    set_write_fd(flag->write_fd());
shiqian's avatar
shiqian committed
986
987
988
989
    return EXECUTE_TEST;
  }

  int pipe_fd[2];
shiqian's avatar
shiqian committed
990
  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
shiqian's avatar
shiqian committed
991
992
  // Clear the close-on-exec flag on the write end of the pipe, lest
  // it be closed when the child process does an exec:
shiqian's avatar
shiqian committed
993
  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
shiqian's avatar
shiqian committed
994
995
996

  const String filter_flag =
      String::Format("--%s%s=%s.%s",
zhanyong.wan's avatar
zhanyong.wan committed
997
                     GTEST_FLAG_PREFIX_, kFilterFlag,
shiqian's avatar
shiqian committed
998
999
                     info->test_case_name(), info->name());
  const String internal_flag =
1000
1001
1002
      String::Format("--%s%s=%s|%d|%d|%d",
                     GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag,
                     file_, line_, death_test_index, pipe_fd[1]);
shiqian's avatar
shiqian committed
1003
1004
1005
1006
1007
  Arguments args;
  args.AddArguments(GetArgvs());
  args.AddArgument(filter_flag.c_str());
  args.AddArgument(internal_flag.c_str());

1008
  DeathTest::set_last_death_test_message("");
shiqian's avatar
shiqian committed
1009
1010
1011
1012
1013
1014
1015

  CaptureStderr();
  // See the comment in NoExecDeathTest::AssumeRole for why the next line
  // is necessary.
  FlushInfoLog();

  const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]);
shiqian's avatar
shiqian committed
1016
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
shiqian's avatar
shiqian committed
1017
1018
  set_child_pid(child_pid);
  set_read_fd(pipe_fd[0]);
1019
  set_spawned(true);
shiqian's avatar
shiqian committed
1020
1021
1022
  return OVERSEE_TEST;
}

1023
1024
#endif  // !GTEST_OS_WINDOWS

shiqian's avatar
shiqian committed
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
// Creates a concrete DeathTest-derived class that depends on the
// --gtest_death_test_style flag, and sets the pointer pointed to
// by the "test" argument to its address.  If the test should be
// skipped, sets that pointer to NULL.  Returns true, unless the
// flag is set to an invalid value.
bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
                                     const char* file, int line,
                                     DeathTest** test) {
  UnitTestImpl* const impl = GetUnitTestImpl();
  const InternalRunDeathTestFlag* const flag =
      impl->internal_run_death_test_flag();
  const int death_test_index = impl->current_test_info()
      ->increment_death_test_count();

  if (flag != NULL) {
1040
1041
    if (death_test_index > flag->index()) {
      DeathTest::set_last_death_test_message(String::Format(
shiqian's avatar
shiqian committed
1042
          "Death test count (%d) somehow exceeded expected maximum (%d)",
1043
          death_test_index, flag->index()));
shiqian's avatar
shiqian committed
1044
1045
1046
      return false;
    }

1047
1048
    if (!(flag->file() == file && flag->line() == line &&
          flag->index() == death_test_index)) {
shiqian's avatar
shiqian committed
1049
1050
1051
1052
1053
      *test = NULL;
      return true;
    }
  }

1054
1055
1056
1057
1058
1059
#if GTEST_OS_WINDOWS
  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
      GTEST_FLAG(death_test_style) == "fast") {
    *test = new WindowsDeathTest(statement, regex, file, line);
  }
#else
shiqian's avatar
shiqian committed
1060
1061
1062
1063
  if (GTEST_FLAG(death_test_style) == "threadsafe") {
    *test = new ExecDeathTest(statement, regex, file, line);
  } else if (GTEST_FLAG(death_test_style) == "fast") {
    *test = new NoExecDeathTest(statement, regex);
1064
1065
1066
1067
  }
#endif  // GTEST_OS_WINDOWS
  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
    DeathTest::set_last_death_test_message(String::Format(
shiqian's avatar
shiqian committed
1068
        "Unknown death test style \"%s\" encountered",
1069
        GTEST_FLAG(death_test_style).c_str()));
shiqian's avatar
shiqian committed
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
    return false;
  }

  return true;
}

// Splits a given string on a given delimiter, populating a given
// vector with the fields.  GTEST_HAS_DEATH_TEST implies that we have
// ::std::string, so we can use it here.
static void SplitString(const ::std::string& str, char delimiter,
                        ::std::vector< ::std::string>* dest) {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
1083
  while (::testing::internal::AlwaysTrue()) {
1084
    const ::std::string::size_type colon = str.find(delimiter, pos);
shiqian's avatar
shiqian committed
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

1096
1097
1098
1099
1100
#if GTEST_OS_WINDOWS
// Recreates the pipe and event handles from the provided parameters,
// signals the event, and returns a file descriptor wrapped around the pipe
// handle. This function is called in the child process only.
int GetStatusFileDescriptor(unsigned int parent_process_id,
1101
                            size_t write_handle_as_size_t,
1102
1103
1104
1105
1106
1107
1108
                            size_t event_handle_as_size_t) {
  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
                                                   FALSE,  // Non-inheritable.
                                                   parent_process_id));
  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
    DeathTestAbort(String::Format("Unable to open parent process %u",
                                  parent_process_id));
shiqian's avatar
shiqian committed
1109
  }
1110
1111
1112
1113
1114

  // TODO(vladl@google.com): Replace the following check with a
  // compile-time assertion when available.
  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));

1115
1116
1117
  const HANDLE write_handle =
      reinterpret_cast<HANDLE>(write_handle_as_size_t);
  HANDLE dup_write_handle;
1118
1119
1120
1121

  // The newly initialized handle is accessible only in in the parent
  // process. To obtain one accessible within the child, we need to use
  // DuplicateHandle.
1122
1123
  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
                         ::GetCurrentProcess(), &dup_write_handle,
1124
1125
1126
1127
1128
1129
                         0x0,    // Requested privileges ignored since
                                 // DUPLICATE_SAME_ACCESS is used.
                         FALSE,  // Request non-inheritable handler.
                         DUPLICATE_SAME_ACCESS)) {
    DeathTestAbort(String::Format(
        "Unable to duplicate the pipe handle %Iu from the parent process %u",
1130
        write_handle_as_size_t, parent_process_id));
shiqian's avatar
shiqian committed
1131
  }
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145

  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
  HANDLE dup_event_handle;

  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
                         ::GetCurrentProcess(), &dup_event_handle,
                         0x0,
                         FALSE,
                         DUPLICATE_SAME_ACCESS)) {
    DeathTestAbort(String::Format(
        "Unable to duplicate the event handle %Iu from the parent process %u",
        event_handle_as_size_t, parent_process_id));
  }

1146
1147
1148
  const int write_fd =
      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
  if (write_fd == -1) {
1149
1150
    DeathTestAbort(String::Format(
        "Unable to convert pipe handle %Iu to a file descriptor",
1151
        write_handle_as_size_t));
1152
1153
1154
1155
1156
1157
  }

  // Signals the parent that the write end of the pipe has been acquired
  // so the parent can release its own write end.
  ::SetEvent(dup_event_handle);

1158
  return write_fd;
shiqian's avatar
shiqian committed
1159
}
1160
#endif  // GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
1161
1162
1163
1164
1165
1166
1167
1168
1169

// Returns a newly created InternalRunDeathTestFlag object with fields
// initialized from the GTEST_FLAG(internal_run_death_test) flag if
// the flag is specified; otherwise returns NULL.
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
  if (GTEST_FLAG(internal_run_death_test) == "") return NULL;

  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
  // can use it here.
1170
1171
  int line = -1;
  int index = -1;
shiqian's avatar
shiqian committed
1172
  ::std::vector< ::std::string> fields;
1173
  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
1174
  int write_fd = -1;
1175
1176
1177

#if GTEST_OS_WINDOWS
  unsigned int parent_process_id = 0;
1178
  size_t write_handle_as_size_t = 0;
1179
1180
1181
1182
1183
1184
  size_t event_handle_as_size_t = 0;

  if (fields.size() != 6
      || !ParseNaturalNumber(fields[1], &line)
      || !ParseNaturalNumber(fields[2], &index)
      || !ParseNaturalNumber(fields[3], &parent_process_id)
1185
      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
1186
1187
1188
1189
1190
      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
    DeathTestAbort(String::Format(
        "Bad --gtest_internal_run_death_test flag: %s",
        GTEST_FLAG(internal_run_death_test).c_str()));
  }
1191
1192
1193
  write_fd = GetStatusFileDescriptor(parent_process_id,
                                     write_handle_as_size_t,
                                     event_handle_as_size_t);
1194
#else
shiqian's avatar
shiqian committed
1195
  if (fields.size() != 4
1196
1197
      || !ParseNaturalNumber(fields[1], &line)
      || !ParseNaturalNumber(fields[2], &index)
1198
      || !ParseNaturalNumber(fields[3], &write_fd)) {
1199
1200
1201
1202
1203
    DeathTestAbort(String::Format(
        "Bad --gtest_internal_run_death_test flag: %s",
        GTEST_FLAG(internal_run_death_test).c_str()));
  }
#endif  // GTEST_OS_WINDOWS
1204
  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
shiqian's avatar
shiqian committed
1205
1206
1207
1208
1209
1210
1211
}

}  // namespace internal

#endif  // GTEST_HAS_DEATH_TEST

}  // namespace testing