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