14b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Copyright 2005, Google Inc. 24b6829f0d28990dd645e16386eb226d0f10c8731shiqian// All rights reserved. 34b6829f0d28990dd645e16386eb226d0f10c8731shiqian// 44b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Redistribution and use in source and binary forms, with or without 54b6829f0d28990dd645e16386eb226d0f10c8731shiqian// modification, are permitted provided that the following conditions are 64b6829f0d28990dd645e16386eb226d0f10c8731shiqian// met: 74b6829f0d28990dd645e16386eb226d0f10c8731shiqian// 84b6829f0d28990dd645e16386eb226d0f10c8731shiqian// * Redistributions of source code must retain the above copyright 94b6829f0d28990dd645e16386eb226d0f10c8731shiqian// notice, this list of conditions and the following disclaimer. 104b6829f0d28990dd645e16386eb226d0f10c8731shiqian// * Redistributions in binary form must reproduce the above 114b6829f0d28990dd645e16386eb226d0f10c8731shiqian// copyright notice, this list of conditions and the following disclaimer 124b6829f0d28990dd645e16386eb226d0f10c8731shiqian// in the documentation and/or other materials provided with the 134b6829f0d28990dd645e16386eb226d0f10c8731shiqian// distribution. 144b6829f0d28990dd645e16386eb226d0f10c8731shiqian// * Neither the name of Google Inc. nor the names of its 154b6829f0d28990dd645e16386eb226d0f10c8731shiqian// contributors may be used to endorse or promote products derived from 164b6829f0d28990dd645e16386eb226d0f10c8731shiqian// this software without specific prior written permission. 174b6829f0d28990dd645e16386eb226d0f10c8731shiqian// 184b6829f0d28990dd645e16386eb226d0f10c8731shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 194b6829f0d28990dd645e16386eb226d0f10c8731shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 204b6829f0d28990dd645e16386eb226d0f10c8731shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 214b6829f0d28990dd645e16386eb226d0f10c8731shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 224b6829f0d28990dd645e16386eb226d0f10c8731shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 234b6829f0d28990dd645e16386eb226d0f10c8731shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 244b6829f0d28990dd645e16386eb226d0f10c8731shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 254b6829f0d28990dd645e16386eb226d0f10c8731shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 264b6829f0d28990dd645e16386eb226d0f10c8731shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 274b6829f0d28990dd645e16386eb226d0f10c8731shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 284b6829f0d28990dd645e16386eb226d0f10c8731shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 294b6829f0d28990dd645e16386eb226d0f10c8731shiqian// 30c8c517f0b7062c1859a3c50a12a0e6c30fdb1adezhanyong.wan// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev) 314b6829f0d28990dd645e16386eb226d0f10c8731shiqian// 324b6829f0d28990dd645e16386eb226d0f10c8731shiqian// This file implements death tests. 334b6829f0d28990dd645e16386eb226d0f10c8731shiqian 342620c79810d4741922e9fa89050c0af564994f24zhanyong.wan#include "gtest/gtest-death-test.h" 352620c79810d4741922e9fa89050c0af564994f24zhanyong.wan#include "gtest/internal/gtest-port.h" 364b6829f0d28990dd645e16386eb226d0f10c8731shiqian 374cd62602913a032a7aec091d4c8055ff9af95e37zhanyong.wan#if GTEST_HAS_DEATH_TEST 38f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 39733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_MAC 40733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <crt_externs.h> 41733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_MAC 42733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 43733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <errno.h> 44733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <fcntl.h> 45733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <limits.h> 467c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev 477c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# if GTEST_OS_LINUX 487c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# include <signal.h> 497c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# endif // GTEST_OS_LINUX 507c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev 51733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <stdarg.h> 52733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 53733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 54733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <windows.h> 55733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 56733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <sys/mman.h> 57733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# include <sys/wait.h> 58733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 59c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 60105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# if GTEST_OS_QNX 61105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# include <spawn.h> 62105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# endif // GTEST_OS_QNX 63105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev 64dd4a17bc20377d250ed116b1083d851adbe45f25shiqian#endif // GTEST_HAS_DEATH_TEST 654b6829f0d28990dd645e16386eb226d0f10c8731shiqian 662620c79810d4741922e9fa89050c0af564994f24zhanyong.wan#include "gtest/gtest-message.h" 672620c79810d4741922e9fa89050c0af564994f24zhanyong.wan#include "gtest/internal/gtest-string.h" 684b6829f0d28990dd645e16386eb226d0f10c8731shiqian 694b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Indicates that this translation unit is part of Google Test's 704b6829f0d28990dd645e16386eb226d0f10c8731shiqian// implementation. It must come before gtest-internal-inl.h is 712f9c469cd2ac136ca4b496b8682a316ce6bf466dkosak@google.com// included, or there will be a compiler error. This trick exists to 722f9c469cd2ac136ca4b496b8682a316ce6bf466dkosak@google.com// prevent the accidental inclusion of gtest-internal-inl.h in the 732f9c469cd2ac136ca4b496b8682a316ce6bf466dkosak@google.com// user's code. 744cd62602913a032a7aec091d4c8055ff9af95e37zhanyong.wan#define GTEST_IMPLEMENTATION_ 1 75910dd4971109bd97f4cf45f9baf9b4a2ddc7f380shiqian#include "src/gtest-internal-inl.h" 764cd62602913a032a7aec091d4c8055ff9af95e37zhanyong.wan#undef GTEST_IMPLEMENTATION_ 774b6829f0d28990dd645e16386eb226d0f10c8731shiqian 784b6829f0d28990dd645e16386eb226d0f10c8731shiqiannamespace testing { 794b6829f0d28990dd645e16386eb226d0f10c8731shiqian 804b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Constants. 814b6829f0d28990dd645e16386eb226d0f10c8731shiqian 824b6829f0d28990dd645e16386eb226d0f10c8731shiqian// The default death test style. 834b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic const char kDefaultDeathTestStyle[] = "fast"; 844b6829f0d28990dd645e16386eb226d0f10c8731shiqian 85e44602ec83c65102035ce5304ae8de0cb16e9e56shiqianGTEST_DEFINE_string_( 864b6829f0d28990dd645e16386eb226d0f10c8731shiqian death_test_style, 874b6829f0d28990dd645e16386eb226d0f10c8731shiqian internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), 884b6829f0d28990dd645e16386eb226d0f10c8731shiqian "Indicates how to run a death test in a forked child process: " 894b6829f0d28990dd645e16386eb226d0f10c8731shiqian "\"threadsafe\" (child process re-executes the test binary " 904b6829f0d28990dd645e16386eb226d0f10c8731shiqian "from the beginning, running only the specific death test) or " 914b6829f0d28990dd645e16386eb226d0f10c8731shiqian "\"fast\" (child process runs the death test immediately " 924b6829f0d28990dd645e16386eb226d0f10c8731shiqian "after forking)."); 934b6829f0d28990dd645e16386eb226d0f10c8731shiqian 9421d43d1a7e09d960b790d992f1bb4e92c70391d4shiqianGTEST_DEFINE_bool_( 9521d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian death_test_use_fork, 9621d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian internal::BoolFromGTestEnv("death_test_use_fork", false), 9721d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian "Instructs to use fork()/_exit() instead of clone() in death tests. " 98f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan "Ignored and always uses fork() on POSIX systems where clone() is not " 99f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan "implemented. Useful when running under valgrind or similar tools if " 100f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan "those do not support clone(). Valgrind 3.3.1 will just fail if " 10121d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian "it sees an unsupported combination of clone() flags. " 10221d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian "It is not recommended to use this flag w/o valgrind though it will " 10321d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian "work in 99% of the cases. Once valgrind is fixed, this flag will " 10421d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian "most likely be removed."); 10521d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian 1064b6829f0d28990dd645e16386eb226d0f10c8731shiqiannamespace internal { 107e44602ec83c65102035ce5304ae8de0cb16e9e56shiqianGTEST_DEFINE_string_( 1084b6829f0d28990dd645e16386eb226d0f10c8731shiqian internal_run_death_test, "", 1094b6829f0d28990dd645e16386eb226d0f10c8731shiqian "Indicates the file, line number, temporal index of " 1104b6829f0d28990dd645e16386eb226d0f10c8731shiqian "the single death test to run, and a file descriptor to " 1114b6829f0d28990dd645e16386eb226d0f10c8731shiqian "which a success code may be sent, all separated by " 112f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev "the '|' characters. This flag is specified if and only if the current " 1134b6829f0d28990dd645e16386eb226d0f10c8731shiqian "process is a sub-process launched for running a thread-safe " 1144b6829f0d28990dd645e16386eb226d0f10c8731shiqian "death test. FOR INTERNAL USE ONLY."); 1154b6829f0d28990dd645e16386eb226d0f10c8731shiqian} // namespace internal 1164b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1174cd62602913a032a7aec091d4c8055ff9af95e37zhanyong.wan#if GTEST_HAS_DEATH_TEST 1184b6829f0d28990dd645e16386eb226d0f10c8731shiqian 119f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosevnamespace internal { 120f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 121f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// Valid only for fast death tests. Indicates the code is running in the 122f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// child process of a fast style death test. 123f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosevstatic bool g_in_fast_death_test_child = false; 124f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 125f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// Returns a Boolean value indicating whether the caller is currently 126f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// executing in the context of the death test child process. Tools such as 127f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// Valgrind heap checkers may need this to modify their behavior in death 128f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// tests. IMPORTANT: This is an internal utility. Using it may break the 129f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev// implementation of death tests. User code MUST NOT use it. 130f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosevbool InDeathTestChild() { 131f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev# if GTEST_OS_WINDOWS 132f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 133f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev // On Windows, death tests are thread-safe regardless of the value of the 134f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev // death_test_style flag. 135f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev return !GTEST_FLAG(internal_run_death_test).empty(); 136f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 137f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev# else 138f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 139f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev if (GTEST_FLAG(death_test_style) == "threadsafe") 140f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev return !GTEST_FLAG(internal_run_death_test).empty(); 141f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev else 142f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev return g_in_fast_death_test_child; 143f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev#endif 144f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev} 145f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 146f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev} // namespace internal 147f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev 1484b6829f0d28990dd645e16386eb226d0f10c8731shiqian// ExitedWithCode constructor. 1494b6829f0d28990dd645e16386eb226d0f10c8731shiqianExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { 1504b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 1514b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1524b6829f0d28990dd645e16386eb226d0f10c8731shiqian// ExitedWithCode function-call operator. 1534b6829f0d28990dd645e16386eb226d0f10c8731shiqianbool ExitedWithCode::operator()(int exit_status) const { 154733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 155733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 156c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan return exit_status == exit_code_; 157733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 158733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 159733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1604b6829f0d28990dd645e16386eb226d0f10c8731shiqian return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; 161733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 162733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 1634b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 1644b6829f0d28990dd645e16386eb226d0f10c8731shiqian 165733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if !GTEST_OS_WINDOWS 1664b6829f0d28990dd645e16386eb226d0f10c8731shiqian// KilledBySignal constructor. 1674b6829f0d28990dd645e16386eb226d0f10c8731shiqianKilledBySignal::KilledBySignal(int signum) : signum_(signum) { 1684b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 1694b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1704b6829f0d28990dd645e16386eb226d0f10c8731shiqian// KilledBySignal function-call operator. 1714b6829f0d28990dd645e16386eb226d0f10c8731shiqianbool KilledBySignal::operator()(int exit_status) const { 1724b6829f0d28990dd645e16386eb226d0f10c8731shiqian return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; 1734b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 174733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // !GTEST_OS_WINDOWS 1754b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1764b6829f0d28990dd645e16386eb226d0f10c8731shiqiannamespace internal { 1774b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1784b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Utilities needed for death tests. 1794b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1804b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Generates a textual description of a given exit code, in the format 1814b6829f0d28990dd645e16386eb226d0f10c8731shiqian// specified by wait(2). 18203c314931649a999b0cf5deb0a434a1009157416jgm@google.comstatic std::string ExitSummary(int exit_code) { 1834b6829f0d28990dd645e16386eb226d0f10c8731shiqian Message m; 184733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 185733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 186733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 187c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan m << "Exited with exit status " << exit_code; 188733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 189733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 190733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1914b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (WIFEXITED(exit_code)) { 1924b6829f0d28990dd645e16386eb226d0f10c8731shiqian m << "Exited with exit status " << WEXITSTATUS(exit_code); 1934b6829f0d28990dd645e16386eb226d0f10c8731shiqian } else if (WIFSIGNALED(exit_code)) { 1944b6829f0d28990dd645e16386eb226d0f10c8731shiqian m << "Terminated by signal " << WTERMSIG(exit_code); 1954b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 196733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# ifdef WCOREDUMP 1974b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (WCOREDUMP(exit_code)) { 1984b6829f0d28990dd645e16386eb226d0f10c8731shiqian m << " (core dumped)"; 1994b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 200733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif 201733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 202733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 2034b6829f0d28990dd645e16386eb226d0f10c8731shiqian return m.GetString(); 2044b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 2054b6829f0d28990dd645e16386eb226d0f10c8731shiqian 2064b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Returns true if exit_status describes a process that was terminated 2074b6829f0d28990dd645e16386eb226d0f10c8731shiqian// by a signal, or exited normally with a nonzero exit code. 2084b6829f0d28990dd645e16386eb226d0f10c8731shiqianbool ExitedUnsuccessfully(int exit_status) { 2094b6829f0d28990dd645e16386eb226d0f10c8731shiqian return !ExitedWithCode(0)(exit_status); 2104b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 2114b6829f0d28990dd645e16386eb226d0f10c8731shiqian 212733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if !GTEST_OS_WINDOWS 2134b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Generates a textual failure message when a death test finds more than 2144b6829f0d28990dd645e16386eb226d0f10c8731shiqian// one thread running, or cannot determine the number of threads, prior 2154b6829f0d28990dd645e16386eb226d0f10c8731shiqian// to executing the given statement. It is the responsibility of the 2164b6829f0d28990dd645e16386eb226d0f10c8731shiqian// caller not to pass a thread_count of 1. 21703c314931649a999b0cf5deb0a434a1009157416jgm@google.comstatic std::string DeathTestThreadWarning(size_t thread_count) { 2184b6829f0d28990dd645e16386eb226d0f10c8731shiqian Message msg; 2194b6829f0d28990dd645e16386eb226d0f10c8731shiqian msg << "Death tests use fork(), which is unsafe particularly" 2204cd62602913a032a7aec091d4c8055ff9af95e37zhanyong.wan << " in a threaded context. For this test, " << GTEST_NAME_ << " "; 2214b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (thread_count == 0) 2224b6829f0d28990dd645e16386eb226d0f10c8731shiqian msg << "couldn't detect the number of threads."; 2234b6829f0d28990dd645e16386eb226d0f10c8731shiqian else 2244b6829f0d28990dd645e16386eb226d0f10c8731shiqian msg << "detected " << thread_count << " threads."; 2254b6829f0d28990dd645e16386eb226d0f10c8731shiqian return msg.GetString(); 2264b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 227733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // !GTEST_OS_WINDOWS 2284b6829f0d28990dd645e16386eb226d0f10c8731shiqian 2294b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Flag characters for reporting a death test that did not die. 2304b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic const char kDeathTestLived = 'L'; 2314b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic const char kDeathTestReturned = 'R'; 232636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosevstatic const char kDeathTestThrew = 'T'; 2334b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic const char kDeathTestInternalError = 'I'; 2344b6829f0d28990dd645e16386eb226d0f10c8731shiqian 235636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// An enumeration describing all of the possible ways that a death test can 236636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// conclude. DIED means that the process died while executing the test 237636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// code; LIVED means that process lived beyond the end of the test code; 238636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// RETURNED means that the test statement attempted to execute a return 239636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// statement, which is not allowed; THREW means that the test statement 240636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// returned control by throwing an exception. IN_PROGRESS means the test 241636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// has not yet concluded. 242636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// TODO(vladl@google.com): Unify names and possibly values for 243636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// AbortReason, DeathTestOutcome, and flag characters above. 244636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosevenum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; 2454b6829f0d28990dd645e16386eb226d0f10c8731shiqian 2464b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Routine for aborting the program which is safe to call from an 247c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// exec-style death test child process, in which case the error 2484b6829f0d28990dd645e16386eb226d0f10c8731shiqian// message is propagated back to the parent process. Otherwise, the 2494b6829f0d28990dd645e16386eb226d0f10c8731shiqian// message is simply printed to stderr. In either case, the program 2504b6829f0d28990dd645e16386eb226d0f10c8731shiqian// then exits with status 1. 25103c314931649a999b0cf5deb0a434a1009157416jgm@google.comvoid DeathTestAbort(const std::string& message) { 252c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // On a POSIX system, this function may be called from a threadsafe-style 253c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // death test child process, which operates on a very small stack. Use 254c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // the heap for any additional non-minuscule memory requirements. 2554b6829f0d28990dd645e16386eb226d0f10c8731shiqian const InternalRunDeathTestFlag* const flag = 2564b6829f0d28990dd645e16386eb226d0f10c8731shiqian GetUnitTestImpl()->internal_run_death_test_flag(); 2574b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (flag != NULL) { 258c7f60f1514013d57a624c3a2966709998678f24bzhanyong.wan FILE* parent = posix::FDOpen(flag->write_fd(), "w"); 2594b6829f0d28990dd645e16386eb226d0f10c8731shiqian fputc(kDeathTestInternalError, parent); 260c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan fprintf(parent, "%s", message.c_str()); 261c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan fflush(parent); 2624b6829f0d28990dd645e16386eb226d0f10c8731shiqian _exit(1); 2634b6829f0d28990dd645e16386eb226d0f10c8731shiqian } else { 264c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan fprintf(stderr, "%s", message.c_str()); 265c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan fflush(stderr); 2665298efaeffba66024a9c530f4b6576dd79a6c5b5vladlosev posix::Abort(); 2674b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 2684b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 2694b6829f0d28990dd645e16386eb226d0f10c8731shiqian 2704b6829f0d28990dd645e16386eb226d0f10c8731shiqian// A replacement for CHECK that calls DeathTestAbort if the assertion 2714b6829f0d28990dd645e16386eb226d0f10c8731shiqian// fails. 272733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# define GTEST_DEATH_TEST_CHECK_(expression) \ 2734b6829f0d28990dd645e16386eb226d0f10c8731shiqian do { \ 274f6d087b78d230d875bf5d8281112662795044680zhanyong.wan if (!::testing::internal::IsTrue(expression)) { \ 2753b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort( \ 2763b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ 2773b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + ::testing::internal::StreamableToString(__LINE__) + ": " \ 2783b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + #expression); \ 2794b6829f0d28990dd645e16386eb226d0f10c8731shiqian } \ 280f6d087b78d230d875bf5d8281112662795044680zhanyong.wan } while (::testing::internal::AlwaysFalse()) 2814b6829f0d28990dd645e16386eb226d0f10c8731shiqian 282e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for 2834b6829f0d28990dd645e16386eb226d0f10c8731shiqian// evaluating any system call that fulfills two conditions: it must return 2844b6829f0d28990dd645e16386eb226d0f10c8731shiqian// -1 on failure, and set errno to EINTR when it is interrupted and 2854b6829f0d28990dd645e16386eb226d0f10c8731shiqian// should be tried again. The macro expands to a loop that repeatedly 2864b6829f0d28990dd645e16386eb226d0f10c8731shiqian// evaluates the expression as long as it evaluates to -1 and sets 2874b6829f0d28990dd645e16386eb226d0f10c8731shiqian// errno to EINTR. If the expression evaluates to -1 but errno is 2884b6829f0d28990dd645e16386eb226d0f10c8731shiqian// something other than EINTR, DeathTestAbort is called. 289733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ 2904b6829f0d28990dd645e16386eb226d0f10c8731shiqian do { \ 291c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int gtest_retval; \ 2924b6829f0d28990dd645e16386eb226d0f10c8731shiqian do { \ 293c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan gtest_retval = (expression); \ 294c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } while (gtest_retval == -1 && errno == EINTR); \ 295c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (gtest_retval == -1) { \ 2963b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort( \ 2973b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ 2983b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + ::testing::internal::StreamableToString(__LINE__) + ": " \ 2993b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + #expression + " != -1"); \ 3004b6829f0d28990dd645e16386eb226d0f10c8731shiqian } \ 301f6d087b78d230d875bf5d8281112662795044680zhanyong.wan } while (::testing::internal::AlwaysFalse()) 3024b6829f0d28990dd645e16386eb226d0f10c8731shiqian 303b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Returns the message describing the last system error in errno. 30403c314931649a999b0cf5deb0a434a1009157416jgm@google.comstd::string GetLastErrnoDescription() { 30503c314931649a999b0cf5deb0a434a1009157416jgm@google.com return errno == 0 ? "" : posix::StrError(errno); 306c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan} 307c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 308b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// This is called from a death test parent process to read a failure 309b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// message from the death test child process and log it with the FATAL 310b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// severity. On Windows, the message is read from a pipe handle. On other 311b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// platforms, it is read from a file descriptor. 312b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wanstatic void FailFromInternalError(int fd) { 313b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan Message error; 314b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan char buffer[256]; 315b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int num_read; 316b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 317b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan do { 318c7f60f1514013d57a624c3a2966709998678f24bzhanyong.wan while ((num_read = posix::Read(fd, buffer, 255)) > 0) { 319b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer[num_read] = '\0'; 320b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan error << buffer; 321b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 322b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } while (num_read == -1 && errno == EINTR); 323b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 324b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (num_read == 0) { 3255739b9887f084ae06a0bf6099fd56e6f204fbe26zhanyong.wan GTEST_LOG_(FATAL) << error.GetString(); 326b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } else { 327b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan const int last_error = errno; 3282962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan GTEST_LOG_(FATAL) << "Error while reading death test internal: " 3295739b9887f084ae06a0bf6099fd56e6f204fbe26zhanyong.wan << GetLastErrnoDescription() << " [" << last_error << "]"; 330b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 331b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan} 332c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 3334b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Death test constructor. Increments the running death test count 3344b6829f0d28990dd645e16386eb226d0f10c8731shiqian// for the current test. 3354b6829f0d28990dd645e16386eb226d0f10c8731shiqianDeathTest::DeathTest() { 3364b6829f0d28990dd645e16386eb226d0f10c8731shiqian TestInfo* const info = GetUnitTestImpl()->current_test_info(); 3374b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (info == NULL) { 3384b6829f0d28990dd645e16386eb226d0f10c8731shiqian DeathTestAbort("Cannot run a death test outside of a TEST or " 3394b6829f0d28990dd645e16386eb226d0f10c8731shiqian "TEST_F construct"); 3404b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 3414b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 3424b6829f0d28990dd645e16386eb226d0f10c8731shiqian 3434b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Creates and returns a death test by dispatching to the current 3444b6829f0d28990dd645e16386eb226d0f10c8731shiqian// death test factory. 3454b6829f0d28990dd645e16386eb226d0f10c8731shiqianbool DeathTest::Create(const char* statement, const RE* regex, 3464b6829f0d28990dd645e16386eb226d0f10c8731shiqian const char* file, int line, DeathTest** test) { 3474b6829f0d28990dd645e16386eb226d0f10c8731shiqian return GetUnitTestImpl()->death_test_factory()->Create( 3484b6829f0d28990dd645e16386eb226d0f10c8731shiqian statement, regex, file, line, test); 3494b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 3504b6829f0d28990dd645e16386eb226d0f10c8731shiqian 3514b6829f0d28990dd645e16386eb226d0f10c8731shiqianconst char* DeathTest::LastMessage() { 352c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan return last_death_test_message_.c_str(); 353c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan} 354c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 35503c314931649a999b0cf5deb0a434a1009157416jgm@google.comvoid DeathTest::set_last_death_test_message(const std::string& message) { 356c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan last_death_test_message_ = message; 3574b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 3584b6829f0d28990dd645e16386eb226d0f10c8731shiqian 35903c314931649a999b0cf5deb0a434a1009157416jgm@google.comstd::string DeathTest::last_death_test_message_; 360c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 361c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// Provides cross platform implementation for some death functionality. 362c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanclass DeathTestImpl : public DeathTest { 363c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan protected: 3647de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan DeathTestImpl(const char* a_statement, const RE* a_regex) 3657de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan : statement_(a_statement), 3667de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan regex_(a_regex), 367c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan spawned_(false), 368c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan status_(-1), 369b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan outcome_(IN_PROGRESS), 370b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan read_fd_(-1), 371b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan write_fd_(-1) {} 372c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 373b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // read_fd_ is expected to be closed and cleared by a derived class. 374b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } 375b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 376b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan void Abort(AbortReason reason); 377c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan virtual bool Passed(bool status_ok); 378c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 379c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const char* statement() const { return statement_; } 380c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const RE* regex() const { return regex_; } 381c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan bool spawned() const { return spawned_; } 3827de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan void set_spawned(bool is_spawned) { spawned_ = is_spawned; } 383c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int status() const { return status_; } 3847de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan void set_status(int a_status) { status_ = a_status; } 385c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DeathTestOutcome outcome() const { return outcome_; } 3867de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } 387b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int read_fd() const { return read_fd_; } 388b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan void set_read_fd(int fd) { read_fd_ = fd; } 389b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int write_fd() const { return write_fd_; } 390b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan void set_write_fd(int fd) { write_fd_ = fd; } 391b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 392b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // Called in the parent process only. Reads the result code of the death 393b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // test child process via a pipe, interprets it to set the outcome_ 394b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // member, and closes read_fd_. Outputs diagnostics and terminates in 395b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // case of unexpected codes. 396b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan void ReadAndInterpretStatusByte(); 397c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 398c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan private: 399c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The textual content of the code this object is testing. This class 400c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // doesn't own this string and should not attempt to delete it. 401c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const char* const statement_; 402c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The regular expression which test output must match. DeathTestImpl 403c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // doesn't own this object and should not attempt to delete it. 404c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const RE* const regex_; 405c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // True if the death test child process has been successfully spawned. 406c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan bool spawned_; 407c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The exit status of the child process. 408c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int status_; 409c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // How the death test concluded. 410c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DeathTestOutcome outcome_; 411b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // Descriptor to the read end of the pipe to the child process. It is 412b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // always -1 in the child process. The child keeps its write end of the 413b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // pipe in write_fd_. 414b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int read_fd_; 415b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // Descriptor to the child's write end of the pipe to the parent process. 416b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // It is always -1 in the parent process. The parent keeps its end of the 417b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // pipe in read_fd_. 418b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int write_fd_; 419c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan}; 420c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 421b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Called in the parent process only. Reads the result code of the death 422b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// test child process via a pipe, interprets it to set the outcome_ 423b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// member, and closes read_fd_. Outputs diagnostics and terminates in 424b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// case of unexpected codes. 425b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wanvoid DeathTestImpl::ReadAndInterpretStatusByte() { 426b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan char flag; 427b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int bytes_read; 428b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 429b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // The read() here blocks until data is available (signifying the 430b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // failure of the death test) or until the pipe is closed (signifying 431b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // its success), so it's okay to call this in the parent before 432b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // the child process has exited. 433b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan do { 434c7f60f1514013d57a624c3a2966709998678f24bzhanyong.wan bytes_read = posix::Read(read_fd(), &flag, 1); 435b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } while (bytes_read == -1 && errno == EINTR); 436b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 437b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (bytes_read == 0) { 438b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_outcome(DIED); 439b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } else if (bytes_read == 1) { 440b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan switch (flag) { 441b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case kDeathTestReturned: 442b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_outcome(RETURNED); 443b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 444636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev case kDeathTestThrew: 445636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev set_outcome(THREW); 446636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev break; 447b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case kDeathTestLived: 448b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_outcome(LIVED); 449b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 450b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case kDeathTestInternalError: 451b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan FailFromInternalError(read_fd()); // Does not return. 452b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 453b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan default: 4542962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan GTEST_LOG_(FATAL) << "Death test child process reported " 4552962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan << "unexpected status byte (" 4562962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan << static_cast<unsigned int>(flag) << ")"; 457b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 458b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } else { 4592962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan GTEST_LOG_(FATAL) << "Read from death test child process failed: " 4605739b9887f084ae06a0bf6099fd56e6f204fbe26zhanyong.wan << GetLastErrnoDescription(); 461b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 462c7f60f1514013d57a624c3a2966709998678f24bzhanyong.wan GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); 463b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_read_fd(-1); 464b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan} 465b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 466b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Signals that the death test code which should have exited, didn't. 467b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Should be called only in a death test child process. 468b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Writes a status byte to the child's status file descriptor, then 469b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// calls _exit(1). 470b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wanvoid DeathTestImpl::Abort(AbortReason reason) { 471b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // The parent process considers the death test to be a failure if 472b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // it finds any data in our pipe. So, here we write a single flag byte 473b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan // to the pipe, then exit. 474b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan const char status_ch = 475636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev reason == TEST_DID_NOT_DIE ? kDeathTestLived : 476636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; 477636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev 478c7f60f1514013d57a624c3a2966709998678f24bzhanyong.wan GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); 4792c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // We are leaking the descriptor here because on some platforms (i.e., 4802c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // when built as Windows DLL), destructors of global objects will still 4812c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // run after calling _exit(). On such systems, write_fd_ will be 4822c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // indirectly closed from the destructor of UnitTestImpl, causing double 4832c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // close if it is also closed here. On debug configurations, double close 4842c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // may assert. As there are no in-process buffers to flush here, we are 4852c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // relying on the OS to close the descriptor after the process terminates 4862c2e3bb07ff5bfef9b90617c9eaa6003fb482e6fvladlosev // when the destructors are not run. 487b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) 488b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan} 489b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 49034b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan// Returns an indented copy of stderr output for a death test. 49134b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan// This makes distinguishing death test output lines from regular log lines 49234b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan// much easier. 49334b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wanstatic ::std::string FormatDeathTestOutput(const ::std::string& output) { 49434b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan ::std::string ret; 49534b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan for (size_t at = 0; ; ) { 49634b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan const size_t line_end = output.find('\n', at); 49734b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan ret += "[ DEATH ] "; 49834b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan if (line_end == ::std::string::npos) { 49934b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan ret += output.substr(at); 50034b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan break; 50134b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan } 50234b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan ret += output.substr(at, line_end + 1 - at); 50334b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan at = line_end + 1; 50434b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan } 50534b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan return ret; 50634b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan} 50734b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan 508b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Assesses the success or failure of a death test, using both private 509b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// members which have previously been set, and one argument: 510b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// 511b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Private data members: 512b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// outcome: An enumeration describing how the death test 513636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// concluded: DIED, LIVED, THREW, or RETURNED. The death test 514636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev// fails in the latter three cases. 515b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// status: The exit status of the child process. On *nix, it is in the 516b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// in the format specified by wait(2). On Windows, this is the 517b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// value supplied to the ExitProcess() API or a numeric code 518b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// of the exception that terminated the program. 519b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// regex: A regular expression object to be applied to 520b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// the test's captured standard error output; the death test 521b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// fails if it does not match. 522b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// 523b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Argument: 524b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// status_ok: true if exit_status is acceptable in the context of 525b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// this particular death test, which fails if it is false 526b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// 527b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Returns true iff all of the above conditions are met. Otherwise, the 528b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// first failing condition, in the order given above, is the one that is 529b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// reported. Also sets the last death test message string. 530b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wanbool DeathTestImpl::Passed(bool status_ok) { 531b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (!spawned()) 532b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan return false; 533b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 53403c314931649a999b0cf5deb0a434a1009157416jgm@google.com const std::string error_message = GetCapturedStderr(); 535b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 536b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan bool success = false; 537b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan Message buffer; 538b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 539b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer << "Death test: " << statement() << "\n"; 540b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan switch (outcome()) { 541b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case LIVED: 542b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer << " Result: failed to die.\n" 54334b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << " Error msg:\n" << FormatDeathTestOutput(error_message); 544b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 545636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev case THREW: 546636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev buffer << " Result: threw an exception.\n" 54734b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << " Error msg:\n" << FormatDeathTestOutput(error_message); 548636f903d84ec28714cb3d84a346dfb58f5bc99d3vladlosev break; 549b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case RETURNED: 550b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer << " Result: illegal return in test statement.\n" 55134b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << " Error msg:\n" << FormatDeathTestOutput(error_message); 552b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 553b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case DIED: 554b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (status_ok) { 555f39160b423e8f90902066cf6774e4180667dcbeezhanyong.wan const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); 556f39160b423e8f90902066cf6774e4180667dcbeezhanyong.wan if (matched) { 557b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan success = true; 558b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } else { 559b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer << " Result: died but not with expected error.\n" 560b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan << " Expected: " << regex()->pattern() << "\n" 56134b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << "Actual msg:\n" << FormatDeathTestOutput(error_message); 562b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 563b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } else { 564b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan buffer << " Result: died but not with expected exit code:\n" 56534b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << " " << ExitSummary(status()) << "\n" 56634b3f298ed6c093e36511e235fff9d7501ec4395zhanyong.wan << "Actual msg:\n" << FormatDeathTestOutput(error_message); 567b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 568b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan break; 569b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan case IN_PROGRESS: 570b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan default: 5712962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan GTEST_LOG_(FATAL) 5722962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan << "DeathTest::Passed somehow called before conclusion of test"; 573b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan } 574b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan 575b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan DeathTest::set_last_death_test_message(buffer.GetString()); 576b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan return success; 577b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan} 578c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 579733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 580c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// WindowsDeathTest implements death tests on Windows. Due to the 581c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// specifics of starting new processes on Windows, death tests there are 582c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// always threadsafe, and Google Test considers the 583c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// --gtest_death_test_style=fast setting to be equivalent to 584c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// --gtest_death_test_style=threadsafe there. 585c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 586c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// A few implementation notes: Like the Linux version, the Windows 587c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// implementation uses pipes for child-to-parent communication. But due to 588c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// the specifics of pipes on Windows, some extra steps are required: 589c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 590c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 1. The parent creates a communication pipe and stores handles to both 591c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// ends of it. 592c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 2. The parent starts the child and provides it with the information 593c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// necessary to acquire the handle to the write end of the pipe. 594c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 3. The child acquires the write end of the pipe and signals the parent 595c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// using a Windows event. 596c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 4. Now the parent can release the write end of the pipe on its side. If 597c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// this is done before step 3, the object's reference count goes down to 598c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 0 and it is destroyed, preventing the child from acquiring it. The 599c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// parent now has to release it, or read operations on the read end of 600c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// the pipe will not return when the child terminates. 601c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 5. The parent reads child's output through the pipe (outcome code and 602c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// any possible error messages) from the pipe, and its stderr and then 603c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// determines whether to fail the test. 604c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 605c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// Note: to distinguish Win32 API calls from the local method and function 606c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// calls, the former are explicitly resolved in the global namespace. 607c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// 608c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanclass WindowsDeathTest : public DeathTestImpl { 609c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan public: 610b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan WindowsDeathTest(const char* a_statement, 611b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan const RE* a_regex, 612c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const char* file, 613c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int line) 614b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {} 615c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 616c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // All of these virtual functions are inherited from DeathTest. 617c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan virtual int Wait(); 618c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan virtual TestRole AssumeRole(); 619c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 620c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan private: 621c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The name of the file in which the death test is located. 622c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const char* const file_; 623c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The line number on which the death test is located. 624c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const int line_; 625c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Handle to the write end of the pipe to the child process. 626c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan AutoHandle write_handle_; 627c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Child process handle. 628c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan AutoHandle child_handle_; 629c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Event the child process uses to signal the parent that it has 630c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // acquired the handle to the write end of the pipe. After seeing this 631c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // event the parent can release its own handles to make sure its 632c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // ReadFile() calls return when the child terminates. 633c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan AutoHandle event_handle_; 634c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan}; 635c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 636c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// Waits for the child in a death test to exit, returning its exit 637c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// status, or 0 if no child process exists. As a side effect, sets the 638c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// outcome data member. 639c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanint WindowsDeathTest::Wait() { 640c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (!spawned()) 641c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan return 0; 642c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 643c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Wait until the child either signals that it has acquired the write end 644c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // of the pipe or it dies. 645c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; 646c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan switch (::WaitForMultipleObjects(2, 647c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan wait_handles, 648c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FALSE, // Waits for any of the handles. 649c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan INFINITE)) { 650c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan case WAIT_OBJECT_0: 651c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan case WAIT_OBJECT_0 + 1: 652c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan break; 653c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan default: 654c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_DEATH_TEST_CHECK_(false); // Should not get here. 655c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 656c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 657c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The child has acquired the write end of the pipe or exited. 658c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // We release the handle on our side and continue. 659c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan write_handle_.Reset(); 660c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan event_handle_.Reset(); 661c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 662b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan ReadAndInterpretStatusByte(); 663c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 664c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Waits for the child process to exit if it haven't already. This 665c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // returns immediately if the child has already exited, regardless of 666c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // whether previous calls to WaitForMultipleObjects synchronized on this 667c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // handle or not. 668c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_DEATH_TEST_CHECK_( 669c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), 670c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan INFINITE)); 671b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan DWORD status_code; 672b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan GTEST_DEATH_TEST_CHECK_( 673b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); 674c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan child_handle_.Reset(); 675b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan set_status(static_cast<int>(status_code)); 676b499e7bd16c3014d350967917dcdb85b19721af4zhanyong.wan return status(); 677c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan} 678c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 679c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// The AssumeRole process for a Windows death test. It creates a child 680c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// process with the same executable as the current process to run the 681c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// death test. The child process is given the --gtest_filter and 682c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// --gtest_internal_run_death_test flags such that it knows to run the 683c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// current death test only. 684c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanDeathTest::TestRole WindowsDeathTest::AssumeRole() { 685c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const UnitTestImpl* const impl = GetUnitTestImpl(); 686c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const InternalRunDeathTestFlag* const flag = 687c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan impl->internal_run_death_test_flag(); 688c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const TestInfo* const info = impl->current_test_info(); 689c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const int death_test_index = info->result()->death_test_count(); 690c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 691c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (flag != NULL) { 692c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // ParseInternalRunDeathTestFlag() has performed all the necessary 693c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // processing. 694b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_write_fd(flag->write_fd()); 695c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan return EXECUTE_TEST; 696c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 697c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 698c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // WindowsDeathTest uses an anonymous pipe to communicate results of 699c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // a death test. 700c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan SECURITY_ATTRIBUTES handles_are_inheritable = { 701c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; 702c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan HANDLE read_handle, write_handle; 703f6d087b78d230d875bf5d8281112662795044680zhanyong.wan GTEST_DEATH_TEST_CHECK_( 704f6d087b78d230d875bf5d8281112662795044680zhanyong.wan ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, 705f6d087b78d230d875bf5d8281112662795044680zhanyong.wan 0) // Default buffer size. 706f6d087b78d230d875bf5d8281112662795044680zhanyong.wan != FALSE); 707b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), 708b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan O_RDONLY)); 709c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan write_handle_.Reset(write_handle); 710c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan event_handle_.Reset(::CreateEvent( 711c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan &handles_are_inheritable, 712c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan TRUE, // The event will automatically reset to non-signaled state. 713c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FALSE, // The initial state is non-signalled. 714c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan NULL)); // The even is unnamed. 715c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL); 71603c314931649a999b0cf5deb0a434a1009157416jgm@google.com const std::string filter_flag = 71703c314931649a999b0cf5deb0a434a1009157416jgm@google.com std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + 71803c314931649a999b0cf5deb0a434a1009157416jgm@google.com info->test_case_name() + "." + info->name(); 71903c314931649a999b0cf5deb0a434a1009157416jgm@google.com const std::string internal_flag = 72003c314931649a999b0cf5deb0a434a1009157416jgm@google.com std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + 7213b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com "=" + file_ + "|" + StreamableToString(line_) + "|" + 7223b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(death_test_index) + "|" + 7233b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) + 7243b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com // size_t has the same width as pointers on both 32-bit and 64-bit 725c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Windows platforms. 726c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. 7273b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + 7283b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get())); 729c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 730c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan char executable_path[_MAX_PATH + 1]; // NOLINT 731c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_DEATH_TEST_CHECK_( 732c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan _MAX_PATH + 1 != ::GetModuleFileNameA(NULL, 733c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan executable_path, 734c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan _MAX_PATH)); 735c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 73603c314931649a999b0cf5deb0a434a1009157416jgm@google.com std::string command_line = 73703c314931649a999b0cf5deb0a434a1009157416jgm@google.com std::string(::GetCommandLineA()) + " " + filter_flag + " \"" + 73803c314931649a999b0cf5deb0a434a1009157416jgm@google.com internal_flag + "\""; 739c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 740c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DeathTest::set_last_death_test_message(""); 741c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 742c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan CaptureStderr(); 743c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Flush the log buffers since the log streams are shared with the child. 744c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FlushInfoLog(); 745c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 746c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The child process will share the standard handles with the parent. 747c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan STARTUPINFOA startup_info; 748c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan memset(&startup_info, 0, sizeof(STARTUPINFO)); 749c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan startup_info.dwFlags = STARTF_USESTDHANDLES; 750c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); 751c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); 752c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); 753c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 754c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan PROCESS_INFORMATION process_info; 755c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_DEATH_TEST_CHECK_(::CreateProcessA( 756c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan executable_path, 757c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const_cast<char*>(command_line.c_str()), 758c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan NULL, // Retuned process handle is not inheritable. 759c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan NULL, // Retuned thread handle is not inheritable. 760c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan TRUE, // Child inherits all inheritable handles (for write_handle_). 761c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 0x0, // Default creation flags. 762c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan NULL, // Inherit the parent's environment. 763c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan UnitTest::GetInstance()->original_working_dir(), 764c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan &startup_info, 765f6d087b78d230d875bf5d8281112662795044680zhanyong.wan &process_info) != FALSE); 766c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan child_handle_.Reset(process_info.hProcess); 767c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan ::CloseHandle(process_info.hThread); 768c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan set_spawned(true); 769c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan return OVERSEE_TEST; 770c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan} 771733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else // We are not on Windows. 772c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 7734b6829f0d28990dd645e16386eb226d0f10c8731shiqian// ForkingDeathTest provides implementations for most of the abstract 7744b6829f0d28990dd645e16386eb226d0f10c8731shiqian// methods of the DeathTest interface. Only the AssumeRole method is 7754b6829f0d28990dd645e16386eb226d0f10c8731shiqian// left undefined. 776c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanclass ForkingDeathTest : public DeathTestImpl { 7774b6829f0d28990dd645e16386eb226d0f10c8731shiqian public: 7784b6829f0d28990dd645e16386eb226d0f10c8731shiqian ForkingDeathTest(const char* statement, const RE* regex); 7794b6829f0d28990dd645e16386eb226d0f10c8731shiqian 7804b6829f0d28990dd645e16386eb226d0f10c8731shiqian // All of these virtual functions are inherited from DeathTest. 7814b6829f0d28990dd645e16386eb226d0f10c8731shiqian virtual int Wait(); 7824b6829f0d28990dd645e16386eb226d0f10c8731shiqian 7834b6829f0d28990dd645e16386eb226d0f10c8731shiqian protected: 7844b6829f0d28990dd645e16386eb226d0f10c8731shiqian void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } 7854b6829f0d28990dd645e16386eb226d0f10c8731shiqian 7864b6829f0d28990dd645e16386eb226d0f10c8731shiqian private: 7874b6829f0d28990dd645e16386eb226d0f10c8731shiqian // PID of child process during death test; 0 in the child process itself. 7884b6829f0d28990dd645e16386eb226d0f10c8731shiqian pid_t child_pid_; 7894b6829f0d28990dd645e16386eb226d0f10c8731shiqian}; 7904b6829f0d28990dd645e16386eb226d0f10c8731shiqian 7914b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Constructs a ForkingDeathTest. 7927de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wanForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) 7937de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan : DeathTestImpl(a_statement, a_regex), 794b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan child_pid_(-1) {} 7954b6829f0d28990dd645e16386eb226d0f10c8731shiqian 7964b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Waits for the child in a death test to exit, returning its exit 7974b6829f0d28990dd645e16386eb226d0f10c8731shiqian// status, or 0 if no child process exists. As a side effect, sets the 7984b6829f0d28990dd645e16386eb226d0f10c8731shiqian// outcome data member. 7994b6829f0d28990dd645e16386eb226d0f10c8731shiqianint ForkingDeathTest::Wait() { 800c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (!spawned()) 8014b6829f0d28990dd645e16386eb226d0f10c8731shiqian return 0; 8024b6829f0d28990dd645e16386eb226d0f10c8731shiqian 803b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan ReadAndInterpretStatusByte(); 8044b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8057de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan int status_value; 8067de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); 8077de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan set_status(status_value); 8087de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan return status_value; 8094b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 8104b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8114b6829f0d28990dd645e16386eb226d0f10c8731shiqian// A concrete death test class that forks, then immediately runs the test 8124b6829f0d28990dd645e16386eb226d0f10c8731shiqian// in the child process. 8134b6829f0d28990dd645e16386eb226d0f10c8731shiqianclass NoExecDeathTest : public ForkingDeathTest { 8144b6829f0d28990dd645e16386eb226d0f10c8731shiqian public: 8157de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan NoExecDeathTest(const char* a_statement, const RE* a_regex) : 8167de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan ForkingDeathTest(a_statement, a_regex) { } 8174b6829f0d28990dd645e16386eb226d0f10c8731shiqian virtual TestRole AssumeRole(); 8184b6829f0d28990dd645e16386eb226d0f10c8731shiqian}; 8194b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8204b6829f0d28990dd645e16386eb226d0f10c8731shiqian// The AssumeRole process for a fork-and-run death test. It implements a 8214b6829f0d28990dd645e16386eb226d0f10c8731shiqian// straightforward fork, with a simple pipe to transmit the status byte. 8224b6829f0d28990dd645e16386eb226d0f10c8731shiqianDeathTest::TestRole NoExecDeathTest::AssumeRole() { 8234b6829f0d28990dd645e16386eb226d0f10c8731shiqian const size_t thread_count = GetThreadCount(); 8244b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (thread_count != 1) { 8252962b23886e9b922398b573fadfa7993f1cb26d7zhanyong.wan GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); 8264b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 8274b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8284b6829f0d28990dd645e16386eb226d0f10c8731shiqian int pipe_fd[2]; 829e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); 8304b6829f0d28990dd645e16386eb226d0f10c8731shiqian 831c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DeathTest::set_last_death_test_message(""); 8324b6829f0d28990dd645e16386eb226d0f10c8731shiqian CaptureStderr(); 8334b6829f0d28990dd645e16386eb226d0f10c8731shiqian // When we fork the process below, the log file buffers are copied, but the 8344b6829f0d28990dd645e16386eb226d0f10c8731shiqian // file descriptors are shared. We flush all log files here so that closing 8354b6829f0d28990dd645e16386eb226d0f10c8731shiqian // the file descriptors in the child process doesn't throw off the 8364b6829f0d28990dd645e16386eb226d0f10c8731shiqian // synchronization between descriptors and buffers in the parent process. 8374b6829f0d28990dd645e16386eb226d0f10c8731shiqian // This is as close to the fork as possible to avoid a race condition in case 8384b6829f0d28990dd645e16386eb226d0f10c8731shiqian // there are multiple threads running before the death test, and another 8394b6829f0d28990dd645e16386eb226d0f10c8731shiqian // thread writes to the log file. 8404b6829f0d28990dd645e16386eb226d0f10c8731shiqian FlushInfoLog(); 8414b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8424b6829f0d28990dd645e16386eb226d0f10c8731shiqian const pid_t child_pid = fork(); 843e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_(child_pid != -1); 8444b6829f0d28990dd645e16386eb226d0f10c8731shiqian set_child_pid(child_pid); 8454b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (child_pid == 0) { 846e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); 8474b6829f0d28990dd645e16386eb226d0f10c8731shiqian set_write_fd(pipe_fd[1]); 8484b6829f0d28990dd645e16386eb226d0f10c8731shiqian // Redirects all logging to stderr in the child process to prevent 8494b6829f0d28990dd645e16386eb226d0f10c8731shiqian // concurrent writes to the log files. We capture stderr in the parent 8504b6829f0d28990dd645e16386eb226d0f10c8731shiqian // process and append the child process' output to a log. 8514b6829f0d28990dd645e16386eb226d0f10c8731shiqian LogToStderr(); 852f39160b423e8f90902066cf6774e4180667dcbeezhanyong.wan // Event forwarding to the listeners of event listener API mush be shut 853f39160b423e8f90902066cf6774e4180667dcbeezhanyong.wan // down in death test subprocesses. 854f39160b423e8f90902066cf6774e4180667dcbeezhanyong.wan GetUnitTestImpl()->listeners()->SuppressEventForwarding(); 855f46f3eaf059b7b3ca00a3428c594bd477bc1839cvladlosev g_in_fast_death_test_child = true; 8564b6829f0d28990dd645e16386eb226d0f10c8731shiqian return EXECUTE_TEST; 8574b6829f0d28990dd645e16386eb226d0f10c8731shiqian } else { 858e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); 8594b6829f0d28990dd645e16386eb226d0f10c8731shiqian set_read_fd(pipe_fd[0]); 860c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan set_spawned(true); 8614b6829f0d28990dd645e16386eb226d0f10c8731shiqian return OVERSEE_TEST; 8624b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 8634b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 8644b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8654b6829f0d28990dd645e16386eb226d0f10c8731shiqian// A concrete death test class that forks and re-executes the main 8664b6829f0d28990dd645e16386eb226d0f10c8731shiqian// program from the beginning, with command-line flags set that cause 8674b6829f0d28990dd645e16386eb226d0f10c8731shiqian// only this specific death test to be run. 8684b6829f0d28990dd645e16386eb226d0f10c8731shiqianclass ExecDeathTest : public ForkingDeathTest { 8694b6829f0d28990dd645e16386eb226d0f10c8731shiqian public: 8707de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan ExecDeathTest(const char* a_statement, const RE* a_regex, 8714b6829f0d28990dd645e16386eb226d0f10c8731shiqian const char* file, int line) : 8727de3401f5f8c2a61476a3623e9802f973764fc27zhanyong.wan ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { } 8734b6829f0d28990dd645e16386eb226d0f10c8731shiqian virtual TestRole AssumeRole(); 8744b6829f0d28990dd645e16386eb226d0f10c8731shiqian private: 875e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev static ::std::vector<testing::internal::string> 876e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev GetArgvsForDeathTestChildProcess() { 877e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev ::std::vector<testing::internal::string> args = GetInjectableArgvs(); 878e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev return args; 879e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev } 8804b6829f0d28990dd645e16386eb226d0f10c8731shiqian // The name of the file in which the death test is located. 8814b6829f0d28990dd645e16386eb226d0f10c8731shiqian const char* const file_; 8824b6829f0d28990dd645e16386eb226d0f10c8731shiqian // The line number on which the death test is located. 8834b6829f0d28990dd645e16386eb226d0f10c8731shiqian const int line_; 8844b6829f0d28990dd645e16386eb226d0f10c8731shiqian}; 8854b6829f0d28990dd645e16386eb226d0f10c8731shiqian 8864b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Utility class for accumulating command-line arguments. 8874b6829f0d28990dd645e16386eb226d0f10c8731shiqianclass Arguments { 8884b6829f0d28990dd645e16386eb226d0f10c8731shiqian public: 8894b6829f0d28990dd645e16386eb226d0f10c8731shiqian Arguments() { 8904b6829f0d28990dd645e16386eb226d0f10c8731shiqian args_.push_back(NULL); 8914b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 892c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 8934b6829f0d28990dd645e16386eb226d0f10c8731shiqian ~Arguments() { 894c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); 8954b6829f0d28990dd645e16386eb226d0f10c8731shiqian ++i) { 8964b6829f0d28990dd645e16386eb226d0f10c8731shiqian free(*i); 8974b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 8984b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 8994b6829f0d28990dd645e16386eb226d0f10c8731shiqian void AddArgument(const char* argument) { 9005343de692d0823ba7949d568a74c571c8b63366bzhanyong.wan args_.insert(args_.end() - 1, posix::StrDup(argument)); 9014b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 9024b6829f0d28990dd645e16386eb226d0f10c8731shiqian 9034b6829f0d28990dd645e16386eb226d0f10c8731shiqian template <typename Str> 9044b6829f0d28990dd645e16386eb226d0f10c8731shiqian void AddArguments(const ::std::vector<Str>& arguments) { 9054b6829f0d28990dd645e16386eb226d0f10c8731shiqian for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); 9064b6829f0d28990dd645e16386eb226d0f10c8731shiqian i != arguments.end(); 9074b6829f0d28990dd645e16386eb226d0f10c8731shiqian ++i) { 9085343de692d0823ba7949d568a74c571c8b63366bzhanyong.wan args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); 9094b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 9104b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 9114b6829f0d28990dd645e16386eb226d0f10c8731shiqian char* const* Argv() { 9124b6829f0d28990dd645e16386eb226d0f10c8731shiqian return &args_[0]; 9134b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 91493fed47dbf8e6bc3d39d3f769cb5039551747257vladlosev 9154b6829f0d28990dd645e16386eb226d0f10c8731shiqian private: 9164b6829f0d28990dd645e16386eb226d0f10c8731shiqian std::vector<char*> args_; 9174b6829f0d28990dd645e16386eb226d0f10c8731shiqian}; 9184b6829f0d28990dd645e16386eb226d0f10c8731shiqian 9194b6829f0d28990dd645e16386eb226d0f10c8731shiqian// A struct that encompasses the arguments to the child process of a 9204b6829f0d28990dd645e16386eb226d0f10c8731shiqian// threadsafe-style death test process. 9214b6829f0d28990dd645e16386eb226d0f10c8731shiqianstruct ExecDeathTestArgs { 9224b6829f0d28990dd645e16386eb226d0f10c8731shiqian char* const* argv; // Command-line arguments for the child's call to exec 9234b6829f0d28990dd645e16386eb226d0f10c8731shiqian int close_fd; // File descriptor to close; the read end of a pipe 9244b6829f0d28990dd645e16386eb226d0f10c8731shiqian}; 9254b6829f0d28990dd645e16386eb226d0f10c8731shiqian 926733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_MAC 927f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.waninline char** GetEnviron() { 928f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan // When Google Test is built as a framework on MacOS X, the environ variable 929f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan // is unavailable. Apple's documentation (man environ) recommends using 930f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan // _NSGetEnviron() instead. 931f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan return *_NSGetEnviron(); 932f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan} 933733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 934b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// Some POSIX platforms expect you to declare environ. extern "C" makes 935b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan// it reside in the global namespace. 936b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wanextern "C" char** environ; 937b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.waninline char** GetEnviron() { return environ; } 938733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_MAC 939f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 940105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# if !GTEST_OS_QNX 9414b6829f0d28990dd645e16386eb226d0f10c8731shiqian// The main function for a threadsafe-style death test child process. 942c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian// This function is called in a clone()-ed process and thus must avoid 943c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian// any potentially unsafe operations like malloc or libc functions. 9444b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic int ExecDeathTestChildMain(void* child_arg) { 9454b6829f0d28990dd645e16386eb226d0f10c8731shiqian ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg); 946e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); 947c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian 948c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // We need to execute the test program in the same environment where 949c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // it was originally invoked. Therefore we change to the original 950c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // working directory first. 951c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian const char* const original_dir = 952c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian UnitTest::GetInstance()->original_working_dir(); 953c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // We can safely call chdir() as it's a direct system call. 954c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian if (chdir(original_dir) != 0) { 95503c314931649a999b0cf5deb0a434a1009157416jgm@google.com DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + 95603c314931649a999b0cf5deb0a434a1009157416jgm@google.com GetLastErrnoDescription()); 957c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian return EXIT_FAILURE; 958c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian } 959c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian 960c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // We can safely call execve() as it's a direct system call. We 961c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // cannot use execvp() as it's a libc function and thus potentially 962c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // unsafe. Since execve() doesn't search the PATH, the user must 963c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // invoke the test program via a valid path that contains at least 964c3b4de35a18a1f011e8009d4d794f787f7e4e0c1shiqian // one path separator. 965f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan execve(args->argv[0], args->argv, GetEnviron()); 96603c314931649a999b0cf5deb0a434a1009157416jgm@google.com DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " + 96703c314931649a999b0cf5deb0a434a1009157416jgm@google.com original_dir + " failed: " + 96803c314931649a999b0cf5deb0a434a1009157416jgm@google.com GetLastErrnoDescription()); 9694b6829f0d28990dd645e16386eb226d0f10c8731shiqian return EXIT_FAILURE; 9704b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 971105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# endif // !GTEST_OS_QNX 9724b6829f0d28990dd645e16386eb226d0f10c8731shiqian 9734b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Two utility routines that together determine the direction the stack 9744b6829f0d28990dd645e16386eb226d0f10c8731shiqian// grows. 9754b6829f0d28990dd645e16386eb226d0f10c8731shiqian// This could be accomplished more elegantly by a single recursive 9764b6829f0d28990dd645e16386eb226d0f10c8731shiqian// function, but we want to guard against the unlikely possibility of 9774b6829f0d28990dd645e16386eb226d0f10c8731shiqian// a smart compiler optimizing the recursion away. 978aca3d2c1c2cac957f4232c2feaf529387ef7fcb6zhanyong.wan// 979aca3d2c1c2cac957f4232c2feaf529387ef7fcb6zhanyong.wan// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining 980aca3d2c1c2cac957f4232c2feaf529387ef7fcb6zhanyong.wan// StackLowerThanAddress into StackGrowsDown, which then doesn't give 981aca3d2c1c2cac957f4232c2feaf529387ef7fcb6zhanyong.wan// correct answer. 9824f9248a4270559cf286cb12937ba78b58bde053fvladlosevvoid StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_; 9834f9248a4270559cf286cb12937ba78b58bde053fvladlosevvoid StackLowerThanAddress(const void* ptr, bool* result) { 9844b6829f0d28990dd645e16386eb226d0f10c8731shiqian int dummy; 9854f9248a4270559cf286cb12937ba78b58bde053fvladlosev *result = (&dummy < ptr); 9864b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 9874b6829f0d28990dd645e16386eb226d0f10c8731shiqian 988041a4cefa9db0af77307eca5183c8a7c86d44dbakosak@google.com// Make sure AddressSanitizer does not tamper with the stack here. 989041a4cefa9db0af77307eca5183c8a7c86d44dbakosak@google.comGTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 990f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wanbool StackGrowsDown() { 9914b6829f0d28990dd645e16386eb226d0f10c8731shiqian int dummy; 9924f9248a4270559cf286cb12937ba78b58bde053fvladlosev bool result; 9934f9248a4270559cf286cb12937ba78b58bde053fvladlosev StackLowerThanAddress(&dummy, &result); 9944f9248a4270559cf286cb12937ba78b58bde053fvladlosev return result; 9954b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 9964b6829f0d28990dd645e16386eb226d0f10c8731shiqian 997105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// Spawns a child process with the same executable as the current process in 998105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// a thread-safe manner and instructs it to run the death test. The 999105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// implementation uses fork(2) + exec. On systems where clone(2) is 1000105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// available, it is used instead, being slightly more thread-safe. On QNX, 1001105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// fork supports only single-threaded environments, so this function uses 1002105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// spawn(2) there instead. The function dies with an error message if 1003105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev// anything goes wrong. 1004105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosevstatic pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) { 10054b6829f0d28990dd645e16386eb226d0f10c8731shiqian ExecDeathTestArgs args = { argv, close_fd }; 10062ce6da855a541ba36b74dda9bfe4cd295629c82azhanyong.wan pid_t child_pid = -1; 1007f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1008105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# if GTEST_OS_QNX 1009105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // Obtains the current directory and sets it to be closed in the child 1010105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // process. 1011105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev const int cwd_fd = open(".", O_RDONLY); 1012105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_(cwd_fd != -1); 1013105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC)); 1014105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // We need to execute the test program in the same environment where 1015105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // it was originally invoked. Therefore we change to the original 1016105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // working directory first. 1017105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev const char* const original_dir = 1018105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev UnitTest::GetInstance()->original_working_dir(); 1019105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // We can safely call chdir() as it's a direct system call. 1020105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev if (chdir(original_dir) != 0) { 102103c314931649a999b0cf5deb0a434a1009157416jgm@google.com DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + 102203c314931649a999b0cf5deb0a434a1009157416jgm@google.com GetLastErrnoDescription()); 1023105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev return EXIT_FAILURE; 1024105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev } 1025105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev 1026105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev int fd_flags; 1027105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // Set close_fd to be closed after spawn. 1028105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD)); 1029105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD, 1030105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev fd_flags | FD_CLOEXEC)); 1031105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev struct inheritance inherit = {0}; 1032105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // spawn is a system call. 1033105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron()); 1034105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev // Restores the current working directory. 1035105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1); 1036105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); 1037105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev 1038105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# else // GTEST_OS_QNX 10397c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# if GTEST_OS_LINUX 10407c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev // When a SIGPROF signal is received while fork() or clone() are executing, 10417c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev // the process may hang. To avoid this, we ignore SIGPROF here and re-enable 10427c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev // it after the call to fork()/clone() is complete. 10437c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev struct sigaction saved_sigprof_action; 10447c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev struct sigaction ignore_sigprof_action; 10457c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action)); 10467c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev sigemptyset(&ignore_sigprof_action.sa_mask); 10477c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev ignore_sigprof_action.sa_handler = SIG_IGN; 10487c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction( 10497c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev SIGPROF, &ignore_sigprof_action, &saved_sigprof_action)); 10507c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# endif // GTEST_OS_LINUX 1051105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev 1052105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# if GTEST_HAS_CLONE 1053f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan const bool use_fork = GTEST_FLAG(death_test_use_fork); 1054f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1055f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan if (!use_fork) { 1056f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan static const bool stack_grows_down = StackGrowsDown(); 1057f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan const size_t stack_size = getpagesize(); 1058f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. 1059f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, 1060f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan MAP_ANON | MAP_PRIVATE, -1, 0); 1061f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); 1062120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com 1063120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // Maximum stack alignment in bytes: For a downward-growing stack, this 1064120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // amount is subtracted from size of the stack space to get an address 1065120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // that is within the stack space and is aligned on all systems we care 1066120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // about. As far as I know there is no ABI with stack alignment greater 1067120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // than 64. We assume stack and stack_size already have alignment of 1068120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com // kMaxStackAlignment. 1069120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com const size_t kMaxStackAlignment = 64; 1070f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan void* const stack_top = 1071120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com static_cast<char*>(stack) + 1072120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com (stack_grows_down ? stack_size - kMaxStackAlignment : 0); 1073120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment && 1074120f8b35d7958abcbb5ccfd26d2a5e562a6a8046jgm@google.com reinterpret_cast<intptr_t>(stack_top) % kMaxStackAlignment == 0); 1075f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1076f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); 1077f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1078f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); 1079f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan } 1080105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# else 1081f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan const bool use_fork = true; 1082105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# endif // GTEST_HAS_CLONE 1083f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1084f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan if (use_fork && (child_pid = fork()) == 0) { 108521d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian ExecDeathTestChildMain(&args); 108621d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian _exit(0); 108721d43d1a7e09d960b790d992f1bb4e92c70391d4shiqian } 1088105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev# endif // GTEST_OS_QNX 10897c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# if GTEST_OS_LINUX 10907c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev GTEST_DEATH_TEST_CHECK_SYSCALL_( 10917c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev sigaction(SIGPROF, &saved_sigprof_action, NULL)); 10927c3004c3013fe4adf5e0447d37ee2d0501c2b227vladlosev# endif // GTEST_OS_LINUX 1093f61494217ff1ae294447ebc30679f5d07fba96e1zhanyong.wan 1094e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_(child_pid != -1); 10954b6829f0d28990dd645e16386eb226d0f10c8731shiqian return child_pid; 10964b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 10974b6829f0d28990dd645e16386eb226d0f10c8731shiqian 10984b6829f0d28990dd645e16386eb226d0f10c8731shiqian// The AssumeRole process for a fork-and-exec death test. It re-executes the 10994b6829f0d28990dd645e16386eb226d0f10c8731shiqian// main program from the beginning, setting the --gtest_filter 11004b6829f0d28990dd645e16386eb226d0f10c8731shiqian// and --gtest_internal_run_death_test flags to cause only the current 11014b6829f0d28990dd645e16386eb226d0f10c8731shiqian// death test to be re-run. 11024b6829f0d28990dd645e16386eb226d0f10c8731shiqianDeathTest::TestRole ExecDeathTest::AssumeRole() { 11034b6829f0d28990dd645e16386eb226d0f10c8731shiqian const UnitTestImpl* const impl = GetUnitTestImpl(); 11044b6829f0d28990dd645e16386eb226d0f10c8731shiqian const InternalRunDeathTestFlag* const flag = 11054b6829f0d28990dd645e16386eb226d0f10c8731shiqian impl->internal_run_death_test_flag(); 11064b6829f0d28990dd645e16386eb226d0f10c8731shiqian const TestInfo* const info = impl->current_test_info(); 11074b6829f0d28990dd645e16386eb226d0f10c8731shiqian const int death_test_index = info->result()->death_test_count(); 11084b6829f0d28990dd645e16386eb226d0f10c8731shiqian 11094b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (flag != NULL) { 1110b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan set_write_fd(flag->write_fd()); 11114b6829f0d28990dd645e16386eb226d0f10c8731shiqian return EXECUTE_TEST; 11124b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 11134b6829f0d28990dd645e16386eb226d0f10c8731shiqian 11144b6829f0d28990dd645e16386eb226d0f10c8731shiqian int pipe_fd[2]; 1115e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); 11164b6829f0d28990dd645e16386eb226d0f10c8731shiqian // Clear the close-on-exec flag on the write end of the pipe, lest 11174b6829f0d28990dd645e16386eb226d0f10c8731shiqian // it be closed when the child process does an exec: 1118e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); 11194b6829f0d28990dd645e16386eb226d0f10c8731shiqian 112003c314931649a999b0cf5deb0a434a1009157416jgm@google.com const std::string filter_flag = 11213b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" 11223b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + info->test_case_name() + "." + info->name(); 112303c314931649a999b0cf5deb0a434a1009157416jgm@google.com const std::string internal_flag = 11243b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" 11253b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + file_ + "|" + StreamableToString(line_) + "|" 11263b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + StreamableToString(death_test_index) + "|" 11273b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + StreamableToString(pipe_fd[1]); 11284b6829f0d28990dd645e16386eb226d0f10c8731shiqian Arguments args; 1129e35019652516ad3b4e9bd8c49dbcfca9d443d7e4vladlosev args.AddArguments(GetArgvsForDeathTestChildProcess()); 11304b6829f0d28990dd645e16386eb226d0f10c8731shiqian args.AddArgument(filter_flag.c_str()); 11314b6829f0d28990dd645e16386eb226d0f10c8731shiqian args.AddArgument(internal_flag.c_str()); 11324b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1133c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DeathTest::set_last_death_test_message(""); 11344b6829f0d28990dd645e16386eb226d0f10c8731shiqian 11354b6829f0d28990dd645e16386eb226d0f10c8731shiqian CaptureStderr(); 11364b6829f0d28990dd645e16386eb226d0f10c8731shiqian // See the comment in NoExecDeathTest::AssumeRole for why the next line 11374b6829f0d28990dd645e16386eb226d0f10c8731shiqian // is necessary. 11384b6829f0d28990dd645e16386eb226d0f10c8731shiqian FlushInfoLog(); 11394b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1140105b1431c37c159892cc0983dd0bc2411c6f0c96vladlosev const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); 1141e44602ec83c65102035ce5304ae8de0cb16e9e56shiqian GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); 11424b6829f0d28990dd645e16386eb226d0f10c8731shiqian set_child_pid(child_pid); 11434b6829f0d28990dd645e16386eb226d0f10c8731shiqian set_read_fd(pipe_fd[0]); 1144c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan set_spawned(true); 11454b6829f0d28990dd645e16386eb226d0f10c8731shiqian return OVERSEE_TEST; 11464b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 11474b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1148733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // !GTEST_OS_WINDOWS 1149c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 11504b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Creates a concrete DeathTest-derived class that depends on the 11514b6829f0d28990dd645e16386eb226d0f10c8731shiqian// --gtest_death_test_style flag, and sets the pointer pointed to 11524b6829f0d28990dd645e16386eb226d0f10c8731shiqian// by the "test" argument to its address. If the test should be 11534b6829f0d28990dd645e16386eb226d0f10c8731shiqian// skipped, sets that pointer to NULL. Returns true, unless the 11544b6829f0d28990dd645e16386eb226d0f10c8731shiqian// flag is set to an invalid value. 11554b6829f0d28990dd645e16386eb226d0f10c8731shiqianbool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, 11564b6829f0d28990dd645e16386eb226d0f10c8731shiqian const char* file, int line, 11574b6829f0d28990dd645e16386eb226d0f10c8731shiqian DeathTest** test) { 11584b6829f0d28990dd645e16386eb226d0f10c8731shiqian UnitTestImpl* const impl = GetUnitTestImpl(); 11594b6829f0d28990dd645e16386eb226d0f10c8731shiqian const InternalRunDeathTestFlag* const flag = 11604b6829f0d28990dd645e16386eb226d0f10c8731shiqian impl->internal_run_death_test_flag(); 11614b6829f0d28990dd645e16386eb226d0f10c8731shiqian const int death_test_index = impl->current_test_info() 11624b6829f0d28990dd645e16386eb226d0f10c8731shiqian ->increment_death_test_count(); 11634b6829f0d28990dd645e16386eb226d0f10c8731shiqian 11644b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (flag != NULL) { 1165c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (death_test_index > flag->index()) { 11663b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTest::set_last_death_test_message( 11673b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com "Death test count (" + StreamableToString(death_test_index) 11683b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + ") somehow exceeded expected maximum (" 11693b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + StreamableToString(flag->index()) + ")"); 11704b6829f0d28990dd645e16386eb226d0f10c8731shiqian return false; 11714b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 11724b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1173c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (!(flag->file() == file && flag->line() == line && 1174c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan flag->index() == death_test_index)) { 11754b6829f0d28990dd645e16386eb226d0f10c8731shiqian *test = NULL; 11764b6829f0d28990dd645e16386eb226d0f10c8731shiqian return true; 11774b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 11784b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 11794b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1180733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 1181733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1182c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (GTEST_FLAG(death_test_style) == "threadsafe" || 1183c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_FLAG(death_test_style) == "fast") { 1184c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan *test = new WindowsDeathTest(statement, regex, file, line); 1185c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1186733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1187733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 1188733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 11894b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (GTEST_FLAG(death_test_style) == "threadsafe") { 11904b6829f0d28990dd645e16386eb226d0f10c8731shiqian *test = new ExecDeathTest(statement, regex, file, line); 11914b6829f0d28990dd645e16386eb226d0f10c8731shiqian } else if (GTEST_FLAG(death_test_style) == "fast") { 11924b6829f0d28990dd645e16386eb226d0f10c8731shiqian *test = new NoExecDeathTest(statement, regex); 1193c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1194733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1195733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 1196733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1197c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan else { // NOLINT - this is more readable than unbalanced brackets inside #if. 11983b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTest::set_last_death_test_message( 11993b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com "Unknown death test style \"" + GTEST_FLAG(death_test_style) 12003b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + "\" encountered"); 12014b6829f0d28990dd645e16386eb226d0f10c8731shiqian return false; 12024b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 12034b6829f0d28990dd645e16386eb226d0f10c8731shiqian 12044b6829f0d28990dd645e16386eb226d0f10c8731shiqian return true; 12054b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 12064b6829f0d28990dd645e16386eb226d0f10c8731shiqian 12074b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Splits a given string on a given delimiter, populating a given 12084b6829f0d28990dd645e16386eb226d0f10c8731shiqian// vector with the fields. GTEST_HAS_DEATH_TEST implies that we have 12094b6829f0d28990dd645e16386eb226d0f10c8731shiqian// ::std::string, so we can use it here. 12104b6829f0d28990dd645e16386eb226d0f10c8731shiqianstatic void SplitString(const ::std::string& str, char delimiter, 12114b6829f0d28990dd645e16386eb226d0f10c8731shiqian ::std::vector< ::std::string>* dest) { 12124b6829f0d28990dd645e16386eb226d0f10c8731shiqian ::std::vector< ::std::string> parsed; 12134b6829f0d28990dd645e16386eb226d0f10c8731shiqian ::std::string::size_type pos = 0; 1214f6d087b78d230d875bf5d8281112662795044680zhanyong.wan while (::testing::internal::AlwaysTrue()) { 1215910dd4971109bd97f4cf45f9baf9b4a2ddc7f380shiqian const ::std::string::size_type colon = str.find(delimiter, pos); 12164b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (colon == ::std::string::npos) { 12174b6829f0d28990dd645e16386eb226d0f10c8731shiqian parsed.push_back(str.substr(pos)); 12184b6829f0d28990dd645e16386eb226d0f10c8731shiqian break; 12194b6829f0d28990dd645e16386eb226d0f10c8731shiqian } else { 12204b6829f0d28990dd645e16386eb226d0f10c8731shiqian parsed.push_back(str.substr(pos, colon - pos)); 12214b6829f0d28990dd645e16386eb226d0f10c8731shiqian pos = colon + 1; 12224b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 12234b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 12244b6829f0d28990dd645e16386eb226d0f10c8731shiqian dest->swap(parsed); 12254b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 12264b6829f0d28990dd645e16386eb226d0f10c8731shiqian 1227733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 1228c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// Recreates the pipe and event handles from the provided parameters, 1229c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// signals the event, and returns a file descriptor wrapped around the pipe 1230c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan// handle. This function is called in the child process only. 1231c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wanint GetStatusFileDescriptor(unsigned int parent_process_id, 1232b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan size_t write_handle_as_size_t, 1233c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan size_t event_handle_as_size_t) { 1234c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, 1235c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FALSE, // Non-inheritable. 1236c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan parent_process_id)); 1237c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { 12383b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Unable to open parent process " + 12393b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(parent_process_id)); 12404b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 1241c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1242c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // TODO(vladl@google.com): Replace the following check with a 1243c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // compile-time assertion when available. 1244c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); 1245c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1246b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan const HANDLE write_handle = 1247b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan reinterpret_cast<HANDLE>(write_handle_as_size_t); 1248b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan HANDLE dup_write_handle; 1249c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1250c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // The newly initialized handle is accessible only in in the parent 1251c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // process. To obtain one accessible within the child, we need to use 1252c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // DuplicateHandle. 1253b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, 1254b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan ::GetCurrentProcess(), &dup_write_handle, 1255c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 0x0, // Requested privileges ignored since 1256c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // DUPLICATE_SAME_ACCESS is used. 1257c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FALSE, // Request non-inheritable handler. 1258c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DUPLICATE_SAME_ACCESS)) { 12593b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Unable to duplicate the pipe handle " + 12603b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(write_handle_as_size_t) + 12613b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com " from the parent process " + 12623b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(parent_process_id)); 12634b6829f0d28990dd645e16386eb226d0f10c8731shiqian } 1264c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1265c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t); 1266c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan HANDLE dup_event_handle; 1267c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1268c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, 1269c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan ::GetCurrentProcess(), &dup_event_handle, 1270c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 0x0, 1271c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan FALSE, 1272c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan DUPLICATE_SAME_ACCESS)) { 12733b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Unable to duplicate the event handle " + 12743b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(event_handle_as_size_t) + 12753b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com " from the parent process " + 12763b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(parent_process_id)); 1277c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1278c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1279b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan const int write_fd = 1280b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND); 1281b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan if (write_fd == -1) { 12823b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Unable to convert pipe handle " + 12833b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com StreamableToString(write_handle_as_size_t) + 12843b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com " to a file descriptor"); 1285c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1286c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1287c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // Signals the parent that the write end of the pipe has been acquired 1288c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan // so the parent can release its own write end. 1289c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan ::SetEvent(dup_event_handle); 1290c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1291b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan return write_fd; 12924b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 1293733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 12944b6829f0d28990dd645e16386eb226d0f10c8731shiqian 12954b6829f0d28990dd645e16386eb226d0f10c8731shiqian// Returns a newly created InternalRunDeathTestFlag object with fields 12964b6829f0d28990dd645e16386eb226d0f10c8731shiqian// initialized from the GTEST_FLAG(internal_run_death_test) flag if 12974b6829f0d28990dd645e16386eb226d0f10c8731shiqian// the flag is specified; otherwise returns NULL. 12984b6829f0d28990dd645e16386eb226d0f10c8731shiqianInternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { 12994b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (GTEST_FLAG(internal_run_death_test) == "") return NULL; 13004b6829f0d28990dd645e16386eb226d0f10c8731shiqian 13014b6829f0d28990dd645e16386eb226d0f10c8731shiqian // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we 13024b6829f0d28990dd645e16386eb226d0f10c8731shiqian // can use it here. 1303c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int line = -1; 1304c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan int index = -1; 13054b6829f0d28990dd645e16386eb226d0f10c8731shiqian ::std::vector< ::std::string> fields; 1306c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); 1307b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan int write_fd = -1; 1308c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1309733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# if GTEST_OS_WINDOWS 1310733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1311c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan unsigned int parent_process_id = 0; 1312b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan size_t write_handle_as_size_t = 0; 1313c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan size_t event_handle_as_size_t = 0; 1314c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan 1315c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan if (fields.size() != 6 1316c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[1], &line) 1317c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[2], &index) 1318c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[3], &parent_process_id) 1319b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) 1320c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { 13213b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + 13223b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com GTEST_FLAG(internal_run_death_test)); 1323c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1324b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan write_fd = GetStatusFileDescriptor(parent_process_id, 1325b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan write_handle_as_size_t, 1326b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan event_handle_as_size_t); 1327733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# else 1328733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 13294b6829f0d28990dd645e16386eb226d0f10c8731shiqian if (fields.size() != 4 1330c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[1], &line) 1331c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan || !ParseNaturalNumber(fields[2], &index) 1332b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan || !ParseNaturalNumber(fields[3], &write_fd)) { 13333b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com DeathTestAbort("Bad --gtest_internal_run_death_test flag: " 13343b8388d9490a64a47ed8cbdab2021935b1b2c76ckosak@google.com + GTEST_FLAG(internal_run_death_test)); 1335c85c0c20322a1f36113cf4d6282908e16ca32669zhanyong.wan } 1336733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1337733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan# endif // GTEST_OS_WINDOWS 1338733a54a398766289b74cf3daebe083d7115cf388zhanyong.wan 1339b0b40063a828ca7a4ceb079ecd508775c6aa9d93zhanyong.wan return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); 13404b6829f0d28990dd645e16386eb226d0f10c8731shiqian} 13414b6829f0d28990dd645e16386eb226d0f10c8731shiqian 13424b6829f0d28990dd645e16386eb226d0f10c8731shiqian} // namespace internal 13434b6829f0d28990dd645e16386eb226d0f10c8731shiqian 13444b6829f0d28990dd645e16386eb226d0f10c8731shiqian#endif // GTEST_HAS_DEATH_TEST 13454b6829f0d28990dd645e16386eb226d0f10c8731shiqian 13464b6829f0d28990dd645e16386eb226d0f10c8731shiqian} // namespace testing 1347