Index: third_party/gtest/src/gtest-death-test.cc |
diff --git a/third_party/gtest/src/gtest-death-test.cc b/third_party/gtest/src/gtest-death-test.cc |
deleted file mode 100644 |
index 106b01c763e97c5325b8b59cb8aeebd037141b87..0000000000000000000000000000000000000000 |
--- a/third_party/gtest/src/gtest-death-test.cc |
+++ /dev/null |
@@ -1,1174 +0,0 @@ |
-// 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. |
-// |
-// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev) |
-// |
-// This file implements death tests. |
- |
-#include <gtest/gtest-death-test.h> |
-#include <gtest/internal/gtest-port.h> |
- |
-#if GTEST_HAS_DEATH_TEST |
- |
-#if GTEST_OS_MAC |
-#include <crt_externs.h> |
-#endif // GTEST_OS_MAC |
- |
-#include <errno.h> |
-#include <fcntl.h> |
-#include <limits.h> |
-#include <stdarg.h> |
- |
-#if GTEST_OS_WINDOWS |
-#include <windows.h> |
-#else |
-#include <sys/mman.h> |
-#include <sys/wait.h> |
-#endif // GTEST_OS_WINDOWS |
- |
-#endif // GTEST_HAS_DEATH_TEST |
- |
-#include <gtest/gtest-message.h> |
-#include <gtest/internal/gtest-string.h> |
- |
-// 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. |
-#define GTEST_IMPLEMENTATION_ 1 |
-#include "src/gtest-internal-inl.h" |
-#undef GTEST_IMPLEMENTATION_ |
- |
-namespace testing { |
- |
-// Constants. |
- |
-// The default death test style. |
-static const char kDefaultDeathTestStyle[] = "fast"; |
- |
-GTEST_DEFINE_string_( |
- 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)."); |
- |
-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. " |
- "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 " |
- "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."); |
- |
-namespace internal { |
-GTEST_DEFINE_string_( |
- 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 |
- |
-#if GTEST_HAS_DEATH_TEST |
- |
-// ExitedWithCode constructor. |
-ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { |
-} |
- |
-// ExitedWithCode function-call operator. |
-bool ExitedWithCode::operator()(int exit_status) const { |
-#if GTEST_OS_WINDOWS |
- return exit_status == exit_code_; |
-#else |
- return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; |
-#endif // GTEST_OS_WINDOWS |
-} |
- |
-#if !GTEST_OS_WINDOWS |
-// 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_; |
-} |
-#endif // !GTEST_OS_WINDOWS |
- |
-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; |
-#if GTEST_OS_WINDOWS |
- m << "Exited with exit status " << exit_code; |
-#else |
- 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 |
-#endif // GTEST_OS_WINDOWS |
- 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); |
-} |
- |
-#if !GTEST_OS_WINDOWS |
-// 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" |
- << " in a threaded context. For this test, " << GTEST_NAME_ << " "; |
- if (thread_count == 0) |
- msg << "couldn't detect the number of threads."; |
- else |
- msg << "detected " << thread_count << " threads."; |
- return msg.GetString(); |
-} |
-#endif // !GTEST_OS_WINDOWS |
- |
-// Flag characters for reporting a death test that did not die. |
-static const char kDeathTestLived = 'L'; |
-static const char kDeathTestReturned = 'R'; |
-static const char kDeathTestInternalError = 'I'; |
- |
-// 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; and RETURNED means that the test statement attempted a "return," |
-// which is not allowed. IN_PROGRESS means the test has not yet |
-// concluded. |
-enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED }; |
- |
-// Routine for aborting the program which is safe to call from an |
-// exec-style death test child process, in which case the error |
-// 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. |
-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. |
- const InternalRunDeathTestFlag* const flag = |
- GetUnitTestImpl()->internal_run_death_test_flag(); |
- if (flag != NULL) { |
- FILE* parent = posix::FDOpen(flag->write_fd(), "w"); |
- fputc(kDeathTestInternalError, parent); |
- fprintf(parent, "%s", message.c_str()); |
- fflush(parent); |
- _exit(1); |
- } else { |
- fprintf(stderr, "%s", message.c_str()); |
- fflush(stderr); |
- abort(); |
- } |
-} |
- |
-// A replacement for CHECK that calls DeathTestAbort if the assertion |
-// fails. |
-#define GTEST_DEATH_TEST_CHECK_(expression) \ |
- do { \ |
- if (!::testing::internal::IsTrue(expression)) { \ |
- DeathTestAbort(::testing::internal::String::Format( \ |
- "CHECK failed: File %s, line %d: %s", \ |
- __FILE__, __LINE__, #expression)); \ |
- } \ |
- } while (::testing::internal::AlwaysFalse()) |
- |
-// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for |
-// 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. |
-#define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ |
- do { \ |
- int gtest_retval; \ |
- do { \ |
- gtest_retval = (expression); \ |
- } while (gtest_retval == -1 && errno == EINTR); \ |
- if (gtest_retval == -1) { \ |
- DeathTestAbort(::testing::internal::String::Format( \ |
- "CHECK failed: File %s, line %d: %s != -1", \ |
- __FILE__, __LINE__, #expression)); \ |
- } \ |
- } while (::testing::internal::AlwaysFalse()) |
- |
-// Returns the message describing the last system error in errno. |
-String GetLastErrnoDescription() { |
- return String(errno == 0 ? "" : posix::StrError(errno)); |
-} |
- |
-// 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 { |
- while ((num_read = posix::Read(fd, buffer, 255)) > 0) { |
- buffer[num_read] = '\0'; |
- error << buffer; |
- } |
- } while (num_read == -1 && errno == EINTR); |
- |
- if (num_read == 0) { |
- GTEST_LOG_(FATAL) << error.GetString(); |
- } else { |
- const int last_error = errno; |
- GTEST_LOG_(FATAL) << "Error while reading death test internal: " |
- << GetLastErrnoDescription() << " [" << last_error << "]"; |
- } |
-} |
- |
-// 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() { |
- return last_death_test_message_.c_str(); |
-} |
- |
-void DeathTest::set_last_death_test_message(const String& message) { |
- last_death_test_message_ = message; |
-} |
- |
-String DeathTest::last_death_test_message_; |
- |
-// Provides cross platform implementation for some death functionality. |
-class DeathTestImpl : public DeathTest { |
- protected: |
- DeathTestImpl(const char* statement, const RE* regex) |
- : statement_(statement), |
- regex_(regex), |
- spawned_(false), |
- status_(-1), |
- outcome_(IN_PROGRESS), |
- read_fd_(-1), |
- write_fd_(-1) {} |
- |
- // 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); |
- virtual bool Passed(bool status_ok); |
- |
- const char* statement() const { return statement_; } |
- const RE* regex() const { return regex_; } |
- bool spawned() const { return spawned_; } |
- void set_spawned(bool spawned) { spawned_ = spawned; } |
- int status() const { return status_; } |
- void set_status(int status) { status_ = status; } |
- DeathTestOutcome outcome() const { return outcome_; } |
- void set_outcome(DeathTestOutcome outcome) { outcome_ = outcome; } |
- 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(); |
- |
- 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_; |
- // 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_; |
-}; |
- |
-// 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 { |
- bytes_read = posix::Read(read_fd(), &flag, 1); |
- } 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; |
- case kDeathTestLived: |
- set_outcome(LIVED); |
- break; |
- case kDeathTestInternalError: |
- FailFromInternalError(read_fd()); // Does not return. |
- break; |
- default: |
- GTEST_LOG_(FATAL) << "Death test child process reported " |
- << "unexpected status byte (" |
- << static_cast<unsigned int>(flag) << ")"; |
- } |
- } else { |
- GTEST_LOG_(FATAL) << "Read from death test child process failed: " |
- << GetLastErrnoDescription(); |
- } |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); |
- 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 = |
- reason == TEST_DID_NOT_DIE ? kDeathTestLived : kDeathTestReturned; |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(write_fd())); |
- _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) |
-} |
- |
-// 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 |
-// concluded: DIED, LIVED, or RETURNED. The death test fails |
-// in the latter two cases. |
-// 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; |
- |
- const String error_message = GetCapturedStderr(); |
- |
- bool success = false; |
- Message buffer; |
- |
- buffer << "Death test: " << statement() << "\n"; |
- switch (outcome()) { |
- case LIVED: |
- buffer << " Result: failed to die.\n" |
- << " Error msg: " << error_message; |
- break; |
- case RETURNED: |
- buffer << " Result: illegal return in test statement.\n" |
- << " Error msg: " << error_message; |
- break; |
- case DIED: |
- if (status_ok) { |
- const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); |
- if (matched) { |
- success = true; |
- } else { |
- buffer << " Result: died but not with expected error.\n" |
- << " Expected: " << regex()->pattern() << "\n" |
- << "Actual msg: " << error_message; |
- } |
- } else { |
- buffer << " Result: died but not with expected exit code:\n" |
- << " " << ExitSummary(status()) << "\n"; |
- } |
- break; |
- case IN_PROGRESS: |
- default: |
- GTEST_LOG_(FATAL) |
- << "DeathTest::Passed somehow called before conclusion of test"; |
- } |
- |
- DeathTest::set_last_death_test_message(buffer.GetString()); |
- return success; |
-} |
- |
-#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: |
- WindowsDeathTest(const char* statement, |
- const RE* regex, |
- const char* file, |
- int line) |
- : DeathTestImpl(statement, regex), file_(file), line_(line) {} |
- |
- // 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(); |
- |
- ReadAndInterpretStatusByte(); |
- |
- // 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)); |
- DWORD status; |
- GTEST_DEATH_TEST_CHECK_(::GetExitCodeProcess(child_handle_.Get(), &status) |
- != FALSE); |
- child_handle_.Reset(); |
- set_status(static_cast<int>(status)); |
- return this->status(); |
-} |
- |
-// 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. |
- set_write_fd(flag->write_fd()); |
- 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; |
- GTEST_DEATH_TEST_CHECK_( |
- ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, |
- 0) // Default buffer size. |
- != FALSE); |
- set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), |
- O_RDONLY)); |
- 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, |
- &process_info) != FALSE); |
- child_handle_.Reset(process_info.hProcess); |
- ::CloseHandle(process_info.hThread); |
- set_spawned(true); |
- return OVERSEE_TEST; |
-} |
-#else // We are not on Windows. |
- |
-// ForkingDeathTest provides implementations for most of the abstract |
-// methods of the DeathTest interface. Only the AssumeRole method is |
-// left undefined. |
-class ForkingDeathTest : public DeathTestImpl { |
- 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. |
-ForkingDeathTest::ForkingDeathTest(const char* statement, const RE* regex) |
- : DeathTestImpl(statement, regex), |
- child_pid_(-1) {} |
- |
-// 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() { |
- if (!spawned()) |
- return 0; |
- |
- ReadAndInterpretStatusByte(); |
- |
- int status; |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status, 0)); |
- set_status(status); |
- return status; |
-} |
- |
-// A concrete death test class that forks, then immediately runs the test |
-// in the child process. |
-class NoExecDeathTest : public ForkingDeathTest { |
- public: |
- NoExecDeathTest(const char* statement, const RE* regex) : |
- ForkingDeathTest(statement, regex) { } |
- 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) { |
- GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); |
- } |
- |
- int pipe_fd[2]; |
- GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); |
- |
- DeathTest::set_last_death_test_message(""); |
- 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(); |
- GTEST_DEATH_TEST_CHECK_(child_pid != -1); |
- set_child_pid(child_pid); |
- if (child_pid == 0) { |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); |
- 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(); |
- // Event forwarding to the listeners of event listener API mush be shut |
- // down in death test subprocesses. |
- GetUnitTestImpl()->listeners()->SuppressEventForwarding(); |
- return EXECUTE_TEST; |
- } else { |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); |
- set_read_fd(pipe_fd[0]); |
- set_spawned(true); |
- 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: |
- ExecDeathTest(const char* statement, const RE* regex, |
- const char* file, int line) : |
- ForkingDeathTest(statement, regex), file_(file), line_(line) { } |
- 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); |
- } |
- |
- ~Arguments() { |
- for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); |
- ++i) { |
- free(*i); |
- } |
- } |
- void AddArgument(const char* argument) { |
- args_.insert(args_.end() - 1, posix::StrDup(argument)); |
- } |
- |
- template <typename Str> |
- void AddArguments(const ::std::vector<Str>& arguments) { |
- for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); |
- i != arguments.end(); |
- ++i) { |
- args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); |
- } |
- } |
- 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 |
-}; |
- |
-#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 |
-// 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; } |
-#endif // GTEST_OS_MAC |
- |
-// The main function for a threadsafe-style death test child process. |
-// This function is called in a clone()-ed process and thus must avoid |
-// any potentially unsafe operations like malloc or libc functions. |
-static int ExecDeathTestChildMain(void* child_arg) { |
- ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg); |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); |
- |
- // 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) { |
- DeathTestAbort(String::Format("chdir(\"%s\") failed: %s", |
- original_dir, |
- GetLastErrnoDescription().c_str())); |
- 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. |
- execve(args->argv[0], args->argv, GetEnviron()); |
- DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s", |
- args->argv[0], |
- original_dir, |
- GetLastErrnoDescription().c_str())); |
- 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. |
-bool StackLowerThanAddress(const void* ptr) { |
- int dummy; |
- return &dummy < ptr; |
-} |
- |
-bool StackGrowsDown() { |
- 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 }; |
- pid_t child_pid = -1; |
- |
-#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) { |
- ExecDeathTestChildMain(&args); |
- _exit(0); |
- } |
- |
- GTEST_DEATH_TEST_CHECK_(child_pid != -1); |
- 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) { |
- set_write_fd(flag->write_fd()); |
- return EXECUTE_TEST; |
- } |
- |
- int pipe_fd[2]; |
- GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); |
- // Clear the close-on-exec flag on the write end of the pipe, lest |
- // it be closed when the child process does an exec: |
- GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); |
- |
- 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|%d", |
- GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag, |
- file_, line_, death_test_index, pipe_fd[1]); |
- Arguments args; |
- args.AddArguments(GetArgvs()); |
- args.AddArgument(filter_flag.c_str()); |
- args.AddArgument(internal_flag.c_str()); |
- |
- DeathTest::set_last_death_test_message(""); |
- |
- 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]); |
- GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); |
- set_child_pid(child_pid); |
- set_read_fd(pipe_fd[0]); |
- set_spawned(true); |
- return OVERSEE_TEST; |
-} |
- |
-#endif // !GTEST_OS_WINDOWS |
- |
-// 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) { |
- if (death_test_index > flag->index()) { |
- DeathTest::set_last_death_test_message(String::Format( |
- "Death test count (%d) somehow exceeded expected maximum (%d)", |
- death_test_index, flag->index())); |
- return false; |
- } |
- |
- if (!(flag->file() == file && flag->line() == line && |
- flag->index() == death_test_index)) { |
- *test = NULL; |
- return true; |
- } |
- } |
- |
-#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 |
- 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); |
- } |
-#endif // GTEST_OS_WINDOWS |
- else { // NOLINT - this is more readable than unbalanced brackets inside #if. |
- DeathTest::set_last_death_test_message(String::Format( |
- "Unknown death test style \"%s\" encountered", |
- GTEST_FLAG(death_test_style).c_str())); |
- 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. |
-// TODO(vladl@google.com): Get rid of std::vector to be able to build on |
-// Visual C++ 7.1 with exceptions disabled. |
-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; |
- while (::testing::internal::AlwaysTrue()) { |
- const ::std::string::size_type colon = str.find(delimiter, pos); |
- 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); |
-} |
- |
-#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, |
- size_t write_handle_as_size_t, |
- 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)); |
- } |
- |
- // TODO(vladl@google.com): Replace the following check with a |
- // compile-time assertion when available. |
- GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); |
- |
- const HANDLE write_handle = |
- reinterpret_cast<HANDLE>(write_handle_as_size_t); |
- HANDLE dup_write_handle; |
- |
- // The newly initialized handle is accessible only in in the parent |
- // process. To obtain one accessible within the child, we need to use |
- // DuplicateHandle. |
- if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, |
- ::GetCurrentProcess(), &dup_write_handle, |
- 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", |
- write_handle_as_size_t, parent_process_id)); |
- } |
- |
- 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)); |
- } |
- |
- const int write_fd = |
- ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND); |
- if (write_fd == -1) { |
- DeathTestAbort(String::Format( |
- "Unable to convert pipe handle %Iu to a file descriptor", |
- write_handle_as_size_t)); |
- } |
- |
- // 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); |
- |
- return write_fd; |
-} |
-#endif // GTEST_OS_WINDOWS |
- |
-// 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. |
- int line = -1; |
- int index = -1; |
- ::std::vector< ::std::string> fields; |
- SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); |
- int write_fd = -1; |
- |
-#if GTEST_OS_WINDOWS |
- unsigned int parent_process_id = 0; |
- size_t write_handle_as_size_t = 0; |
- 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) |
- || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) |
- || !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())); |
- } |
- write_fd = GetStatusFileDescriptor(parent_process_id, |
- write_handle_as_size_t, |
- event_handle_as_size_t); |
-#else |
- if (fields.size() != 4 |
- || !ParseNaturalNumber(fields[1], &line) |
- || !ParseNaturalNumber(fields[2], &index) |
- || !ParseNaturalNumber(fields[3], &write_fd)) { |
- DeathTestAbort(String::Format( |
- "Bad --gtest_internal_run_death_test flag: %s", |
- GTEST_FLAG(internal_run_death_test).c_str())); |
- } |
-#endif // GTEST_OS_WINDOWS |
- return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); |
-} |
- |
-} // namespace internal |
- |
-#endif // GTEST_HAS_DEATH_TEST |
- |
-} // namespace testing |