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