1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc. 2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved. 3d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without 5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are 6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met: 7d201456903f3ecae1f7794edfab0d5678e64226shiqian// 8d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions of source code must retain the above copyright 9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer. 10d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions in binary form must reproduce the above 11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer 12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the 13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution. 14d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Neither the name of Google Inc. nor the names of its 15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from 16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission. 17d201456903f3ecae1f7794edfab0d5678e64226shiqian// 18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29d201456903f3ecae1f7794edfab0d5678e64226shiqian// 30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Author: wan@google.com (Zhanyong Wan) 31d201456903f3ecae1f7794edfab0d5678e64226shiqian// 32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for death tests. 33d201456903f3ecae1f7794edfab0d5678e64226shiqian 34dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest-death-test.h" 35dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest.h" 36dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/internal/gtest-filepath.h" 37d201456903f3ecae1f7794edfab0d5678e64226shiqian 38f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysFalse; 39f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysTrue; 40f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan 410af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 42d201456903f3ecae1f7794edfab0d5678e64226shiqian 43ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 44ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <direct.h> // For chdir(). 45ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 46ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <unistd.h> 47ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <sys/wait.h> // For waitpid. 48ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 494984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 50ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <limits.h> 51ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <signal.h> 52ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include <stdio.h> 5344a041b711ff4a5b5f341f21127aed46dbfe38adzhanyong.wan 544b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev# if GTEST_OS_LINUX 554b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev# include <sys/time.h> 564b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev# endif // GTEST_OS_LINUX 574b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 58ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include "gtest/gtest-spi.h" 59d201456903f3ecae1f7794edfab0d5678e64226shiqian 60d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 61d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 62d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 63d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 64d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 65ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# define GTEST_IMPLEMENTATION_ 1 66ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# include "src/gtest-internal-inl.h" 67ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# undef GTEST_IMPLEMENTATION_ 68d201456903f3ecae1f7794edfab0d5678e64226shiqian 693c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wannamespace posix = ::testing::internal::posix; 704984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 713c7bbf5b46679aea4e0ac7d3ad241cb036146751zhanyong.wanusing testing::Message; 72d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::DeathTest; 73d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::DeathTestFactory; 7487d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wanusing testing::internal::FilePath; 752c0fc6d415343b732a4ae39cce1458be1170b9f6zhanyong.wanusing testing::internal::GetLastErrnoDescription; 76aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wanusing testing::internal::GetUnitTestImpl; 77829402edcffe712ed4c79412ca020525cd8295advladlosevusing testing::internal::InDeathTestChild; 784984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanusing testing::internal::ParseNaturalNumber; 79d201456903f3ecae1f7794edfab0d5678e64226shiqian 80d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 81d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 82d201456903f3ecae1f7794edfab0d5678e64226shiqian 83d201456903f3ecae1f7794edfab0d5678e64226shiqian// A helper class whose objects replace the death test factory for a 84d201456903f3ecae1f7794edfab0d5678e64226shiqian// single UnitTest object during their lifetimes. 85d201456903f3ecae1f7794edfab0d5678e64226shiqianclass ReplaceDeathTestFactory { 86d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 87aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory) 88aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan : unit_test_impl_(GetUnitTestImpl()) { 89aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan old_factory_ = unit_test_impl_->death_test_factory_.release(); 90aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan unit_test_impl_->death_test_factory_.reset(new_factory); 91d201456903f3ecae1f7794edfab0d5678e64226shiqian } 92d201456903f3ecae1f7794edfab0d5678e64226shiqian 93d201456903f3ecae1f7794edfab0d5678e64226shiqian ~ReplaceDeathTestFactory() { 94aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan unit_test_impl_->death_test_factory_.release(); 95aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan unit_test_impl_->death_test_factory_.reset(old_factory_); 96d201456903f3ecae1f7794edfab0d5678e64226shiqian } 97d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 98d201456903f3ecae1f7794edfab0d5678e64226shiqian // Prevents copying ReplaceDeathTestFactory objects. 99d201456903f3ecae1f7794edfab0d5678e64226shiqian ReplaceDeathTestFactory(const ReplaceDeathTestFactory&); 100d201456903f3ecae1f7794edfab0d5678e64226shiqian void operator=(const ReplaceDeathTestFactory&); 101d201456903f3ecae1f7794edfab0d5678e64226shiqian 102aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan UnitTestImpl* unit_test_impl_; 103d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTestFactory* old_factory_; 104d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 105d201456903f3ecae1f7794edfab0d5678e64226shiqian 106d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 107d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 108d201456903f3ecae1f7794edfab0d5678e64226shiqian 10940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanvoid DieWithMessage(const ::std::string& message) { 11040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan fprintf(stderr, "%s", message.c_str()); 11140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan fflush(stderr); // Make sure the text is printed before the process exits. 11240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 113172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev // We call _exit() instead of exit(), as the former is a direct 114172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev // system call and thus safer in the presence of threads. exit() 115172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev // will invoke user-defined exit-hooks, which may do dangerous 116172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev // things that conflict with death tests. 11740604f891efd16779af66c2b3e42f433ead74b15vladlosev // 11840604f891efd16779af66c2b3e42f433ead74b15vladlosev // Some compilers can recognize that _exit() never returns and issue the 11940604f891efd16779af66c2b3e42f433ead74b15vladlosev // 'unreachable code' warning for code following this function, unless 12040604f891efd16779af66c2b3e42f433ead74b15vladlosev // fooled by a fake condition. 12140604f891efd16779af66c2b3e42f433ead74b15vladlosev if (AlwaysTrue()) 12240604f891efd16779af66c2b3e42f433ead74b15vladlosev _exit(1); 123172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev} 124172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev 12540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanvoid DieInside(const ::std::string& function) { 12640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan DieWithMessage("death inside " + function + "()."); 12740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 12840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 129d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that death tests work. 130d201456903f3ecae1f7794edfab0d5678e64226shiqian 131d201456903f3ecae1f7794edfab0d5678e64226shiqianclass TestForDeathTest : public testing::Test { 132d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 13387d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {} 13487d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan 13587d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan virtual ~TestForDeathTest() { 136f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wan posix::ChDir(original_dir_.c_str()); 13787d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan } 13887d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan 139d201456903f3ecae1f7794edfab0d5678e64226shiqian // A static member function that's expected to die. 140172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev static void StaticMemberFunction() { DieInside("StaticMemberFunction"); } 141d201456903f3ecae1f7794edfab0d5678e64226shiqian 142d201456903f3ecae1f7794edfab0d5678e64226shiqian // A method of the test fixture that may die. 143d201456903f3ecae1f7794edfab0d5678e64226shiqian void MemberFunction() { 144172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev if (should_die_) 145172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("MemberFunction"); 146d201456903f3ecae1f7794edfab0d5678e64226shiqian } 147d201456903f3ecae1f7794edfab0d5678e64226shiqian 148d201456903f3ecae1f7794edfab0d5678e64226shiqian // True iff MemberFunction() should die. 149d201456903f3ecae1f7794edfab0d5678e64226shiqian bool should_die_; 15087d23e45f096c91c9e722b20bf15b733dbab0f80zhanyong.wan const FilePath original_dir_; 151d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 152d201456903f3ecae1f7794edfab0d5678e64226shiqian 153d201456903f3ecae1f7794edfab0d5678e64226shiqian// A class with a member function that may die. 154d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MayDie { 155d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 156d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MayDie(bool should_die) : should_die_(should_die) {} 157d201456903f3ecae1f7794edfab0d5678e64226shiqian 158d201456903f3ecae1f7794edfab0d5678e64226shiqian // A member function that may die. 159d201456903f3ecae1f7794edfab0d5678e64226shiqian void MemberFunction() const { 160172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev if (should_die_) 161172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("MayDie::MemberFunction"); 162d201456903f3ecae1f7794edfab0d5678e64226shiqian } 163d201456903f3ecae1f7794edfab0d5678e64226shiqian 164d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 165d201456903f3ecae1f7794edfab0d5678e64226shiqian // True iff MemberFunction() should die. 166d201456903f3ecae1f7794edfab0d5678e64226shiqian bool should_die_; 167d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 168d201456903f3ecae1f7794edfab0d5678e64226shiqian 169d201456903f3ecae1f7794edfab0d5678e64226shiqian// A global function that's expected to die. 170172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosevvoid GlobalFunction() { DieInside("GlobalFunction"); } 171d201456903f3ecae1f7794edfab0d5678e64226shiqian 172d201456903f3ecae1f7794edfab0d5678e64226shiqian// A non-void function that's expected to die. 173d201456903f3ecae1f7794edfab0d5678e64226shiqianint NonVoidFunction() { 174172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("NonVoidFunction"); 175d201456903f3ecae1f7794edfab0d5678e64226shiqian return 1; 176d201456903f3ecae1f7794edfab0d5678e64226shiqian} 177d201456903f3ecae1f7794edfab0d5678e64226shiqian 178d201456903f3ecae1f7794edfab0d5678e64226shiqian// A unary function that may die. 179d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid DieIf(bool should_die) { 180172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev if (should_die) 181172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("DieIf"); 182d201456903f3ecae1f7794edfab0d5678e64226shiqian} 183d201456903f3ecae1f7794edfab0d5678e64226shiqian 184d201456903f3ecae1f7794edfab0d5678e64226shiqian// A binary function that may die. 185d201456903f3ecae1f7794edfab0d5678e64226shiqianbool DieIfLessThan(int x, int y) { 186d201456903f3ecae1f7794edfab0d5678e64226shiqian if (x < y) { 187172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("DieIfLessThan"); 188d201456903f3ecae1f7794edfab0d5678e64226shiqian } 189d201456903f3ecae1f7794edfab0d5678e64226shiqian return true; 190d201456903f3ecae1f7794edfab0d5678e64226shiqian} 191d201456903f3ecae1f7794edfab0d5678e64226shiqian 192d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 193d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid DeathTestSubroutine() { 194d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 195d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 196d201456903f3ecae1f7794edfab0d5678e64226shiqian} 197d201456903f3ecae1f7794edfab0d5678e64226shiqian 198d201456903f3ecae1f7794edfab0d5678e64226shiqian// Death in dbg, not opt. 199d201456903f3ecae1f7794edfab0d5678e64226shiqianint DieInDebugElse12(int* sideeffect) { 200d201456903f3ecae1f7794edfab0d5678e64226shiqian if (sideeffect) *sideeffect = 12; 201ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 202ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifndef NDEBUG 203ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 204172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev DieInside("DieInDebugElse12"); 205ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 206ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // NDEBUG 207ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 208d201456903f3ecae1f7794edfab0d5678e64226shiqian return 12; 209d201456903f3ecae1f7794edfab0d5678e64226shiqian} 210d201456903f3ecae1f7794edfab0d5678e64226shiqian 211ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 2124984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 2134984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// Tests the ExitedWithCode predicate. 2144984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ExitStatusPredicateTest, ExitedWithCode) { 2154984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // On Windows, the process's exit code is the same as its exit status, 2164984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // so the predicate just compares the its input with its parameter. 2174984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(testing::ExitedWithCode(0)(0)); 2184984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(testing::ExitedWithCode(1)(1)); 2194984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(testing::ExitedWithCode(42)(42)); 2204984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_FALSE(testing::ExitedWithCode(0)(1)); 2214984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_FALSE(testing::ExitedWithCode(1)(0)); 2224984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 2234984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 224ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 2254984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 226019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Returns the exit status of a process that calls _exit(2) with a 227d201456903f3ecae1f7794edfab0d5678e64226shiqian// given exit code. This is a helper function for the 228d201456903f3ecae1f7794edfab0d5678e64226shiqian// ExitStatusPredicateTest test suite. 229d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic int NormalExitStatus(int exit_code) { 230d201456903f3ecae1f7794edfab0d5678e64226shiqian pid_t child_pid = fork(); 231d201456903f3ecae1f7794edfab0d5678e64226shiqian if (child_pid == 0) { 232019d19af978f05b774407e0d46a3bda2c18c67c6shiqian _exit(exit_code); 233d201456903f3ecae1f7794edfab0d5678e64226shiqian } 234d201456903f3ecae1f7794edfab0d5678e64226shiqian int status; 235d201456903f3ecae1f7794edfab0d5678e64226shiqian waitpid(child_pid, &status, 0); 236d201456903f3ecae1f7794edfab0d5678e64226shiqian return status; 237d201456903f3ecae1f7794edfab0d5678e64226shiqian} 238d201456903f3ecae1f7794edfab0d5678e64226shiqian 239d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns the exit status of a process that raises a given signal. 240d201456903f3ecae1f7794edfab0d5678e64226shiqian// If the signal does not cause the process to die, then it returns 241d201456903f3ecae1f7794edfab0d5678e64226shiqian// instead the exit status of a process that exits normally with exit 242d201456903f3ecae1f7794edfab0d5678e64226shiqian// code 1. This is a helper function for the ExitStatusPredicateTest 243d201456903f3ecae1f7794edfab0d5678e64226shiqian// test suite. 244d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic int KilledExitStatus(int signum) { 245d201456903f3ecae1f7794edfab0d5678e64226shiqian pid_t child_pid = fork(); 246d201456903f3ecae1f7794edfab0d5678e64226shiqian if (child_pid == 0) { 247d201456903f3ecae1f7794edfab0d5678e64226shiqian raise(signum); 248019d19af978f05b774407e0d46a3bda2c18c67c6shiqian _exit(1); 249d201456903f3ecae1f7794edfab0d5678e64226shiqian } 250d201456903f3ecae1f7794edfab0d5678e64226shiqian int status; 251d201456903f3ecae1f7794edfab0d5678e64226shiqian waitpid(child_pid, &status, 0); 252d201456903f3ecae1f7794edfab0d5678e64226shiqian return status; 253d201456903f3ecae1f7794edfab0d5678e64226shiqian} 254d201456903f3ecae1f7794edfab0d5678e64226shiqian 255d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the ExitedWithCode predicate. 256d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExitStatusPredicateTest, ExitedWithCode) { 257d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status0 = NormalExitStatus(0); 258d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status1 = NormalExitStatus(1); 259d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status42 = NormalExitStatus(42); 260d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::ExitedWithCode pred0(0); 261d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::ExitedWithCode pred1(1); 262d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::ExitedWithCode pred42(42); 263d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(pred0, status0); 264d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(pred1, status1); 265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(pred42, status42); 266d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(pred0(status1)); 267d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(pred42(status0)); 268d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(pred1(status42)); 269d201456903f3ecae1f7794edfab0d5678e64226shiqian} 270d201456903f3ecae1f7794edfab0d5678e64226shiqian 271d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the KilledBySignal predicate. 272d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExitStatusPredicateTest, KilledBySignal) { 273d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status_segv = KilledExitStatus(SIGSEGV); 274d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status_kill = KilledExitStatus(SIGKILL); 275d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::KilledBySignal pred_segv(SIGSEGV); 276d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::KilledBySignal pred_kill(SIGKILL); 277d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(pred_segv, status_segv); 278d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(pred_kill, status_kill); 279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(pred_segv(status_kill)); 280d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(pred_kill(status_segv)); 281d201456903f3ecae1f7794edfab0d5678e64226shiqian} 282d201456903f3ecae1f7794edfab0d5678e64226shiqian 283ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 2844984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 285d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the death test macros expand to code which may or may not 286d201456903f3ecae1f7794edfab0d5678e64226shiqian// be followed by operator<<, and that in either case the complete text 287d201456903f3ecae1f7794edfab0d5678e64226shiqian// comprises only a single C++ statement. 288d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, SingleStatement) { 289f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 290d201456903f3ecae1f7794edfab0d5678e64226shiqian // This would fail if executed; this is a compilation test only 291d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(return, ""); 292d201456903f3ecae1f7794edfab0d5678e64226shiqian 293f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 294019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), ""); 295d201456903f3ecae1f7794edfab0d5678e64226shiqian else 296d201456903f3ecae1f7794edfab0d5678e64226shiqian // This empty "else" branch is meant to ensure that EXPECT_DEATH 297d201456903f3ecae1f7794edfab0d5678e64226shiqian // doesn't expand into an "if" statement without an "else" 298d201456903f3ecae1f7794edfab0d5678e64226shiqian ; 299d201456903f3ecae1f7794edfab0d5678e64226shiqian 300f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 301d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(return, "") << "did not die"; 302d201456903f3ecae1f7794edfab0d5678e64226shiqian 303f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 304d201456903f3ecae1f7794edfab0d5678e64226shiqian ; 305d201456903f3ecae1f7794edfab0d5678e64226shiqian else 306019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3; 307d201456903f3ecae1f7794edfab0d5678e64226shiqian} 308d201456903f3ecae1f7794edfab0d5678e64226shiqian 309d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid DieWithEmbeddedNul() { 31056a2e686e915d483cb22db091140130b23814127zhanyong.wan fprintf(stderr, "Hello%cmy null world.\n", '\0'); 3114984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan fflush(stderr); 312019d19af978f05b774407e0d46a3bda2c18c67c6shiqian _exit(1); 313d201456903f3ecae1f7794edfab0d5678e64226shiqian} 314d201456903f3ecae1f7794edfab0d5678e64226shiqian 315ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_USES_PCRE 316d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error 317d201456903f3ecae1f7794edfab0d5678e64226shiqian// message has a NUL character in it. 31844a041b711ff4a5b5f341f21127aed46dbfe38adzhanyong.wanTEST_F(TestForDeathTest, EmbeddedNulInMessage) { 319d201456903f3ecae1f7794edfab0d5678e64226shiqian // TODO(wan@google.com): <regex.h> doesn't support matching strings 320d201456903f3ecae1f7794edfab0d5678e64226shiqian // with embedded NUL characters - find a way to workaround it. 32156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_DEATH(DieWithEmbeddedNul(), "my null world"); 32256a2e686e915d483cb22db091140130b23814127zhanyong.wan ASSERT_DEATH(DieWithEmbeddedNul(), "my null world"); 323d201456903f3ecae1f7794edfab0d5678e64226shiqian} 324ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_USES_PCRE 325d201456903f3ecae1f7794edfab0d5678e64226shiqian 326d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that death test macros expand to code which interacts well with switch 327d201456903f3ecae1f7794edfab0d5678e64226shiqian// statements. 328d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, SwitchStatement) { 3298120f66c3249e253f03fdb48bee7e528bc038d31billydonahue // Microsoft compiler usually complains about switch statements without 3308120f66c3249e253f03fdb48bee7e528bc038d31billydonahue // case labels. We suppress that warning for this test. 3318120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065) 3324984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 333d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 334d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 335019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_DEATH(_exit(1), "") << "exit in default switch handler"; 336d201456903f3ecae1f7794edfab0d5678e64226shiqian 337d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 338d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 339019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), "") << "exit in switch case"; 3404984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 3418120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_POP_() 342d201456903f3ecae1f7794edfab0d5678e64226shiqian} 343d201456903f3ecae1f7794edfab0d5678e64226shiqian 344019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Tests that a static member function can be used in a "fast" style 345019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// death test. 346019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) { 347019d19af978f05b774407e0d46a3bda2c18c67c6shiqian testing::GTEST_FLAG(death_test_style) = "fast"; 348d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 349d201456903f3ecae1f7794edfab0d5678e64226shiqian} 350d201456903f3ecae1f7794edfab0d5678e64226shiqian 351019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Tests that a method of the test fixture can be used in a "fast" 352019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// style death test. 353019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST_F(TestForDeathTest, MemberFunctionFastStyle) { 354019d19af978f05b774407e0d46a3bda2c18c67c6shiqian testing::GTEST_FLAG(death_test_style) = "fast"; 355d201456903f3ecae1f7794edfab0d5678e64226shiqian should_die_ = true; 356d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 357d201456903f3ecae1f7794edfab0d5678e64226shiqian} 358d201456903f3ecae1f7794edfab0d5678e64226shiqian 359f2d0d0e3d56794855d1e9a1f157457b7225e8c88zhanyong.wanvoid ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); } 3604984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 361019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Tests that death tests work even if the current directory has been 362019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// changed. 363019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST_F(TestForDeathTest, FastDeathTestInChangedDir) { 364019d19af978f05b774407e0d46a3bda2c18c67c6shiqian testing::GTEST_FLAG(death_test_style) = "fast"; 365019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 3664984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ChangeToRootDir(); 367019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 368019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 3694984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ChangeToRootDir(); 370019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_DEATH(_exit(1), ""); 371019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 372019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 3734b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev# if GTEST_OS_LINUX 3744b07d73f4e683d85546d78793a9914a4b5d3d98evladlosevvoid SigprofAction(int, siginfo_t*, void*) { /* no op */ } 3754b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 3764b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms). 3774b07d73f4e683d85546d78793a9914a4b5d3d98evladlosevvoid SetSigprofActionAndTimer() { 3784b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct itimerval timer; 3794b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev timer.it_interval.tv_sec = 0; 3804b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev timer.it_interval.tv_usec = 1; 3814b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev timer.it_value = timer.it_interval; 3824b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 3834b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct sigaction signal_action; 3844b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev memset(&signal_action, 0, sizeof(signal_action)); 3854b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev sigemptyset(&signal_action.sa_mask); 3864b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev signal_action.sa_sigaction = SigprofAction; 3874b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev signal_action.sa_flags = SA_RESTART | SA_SIGINFO; 3884b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL)); 3894b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev} 3904b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 3914b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev// Disables ITIMER_PROF timer and ignores SIGPROF signal. 3924b07d73f4e683d85546d78793a9914a4b5d3d98evladlosevvoid DisableSigprofActionAndTimer(struct sigaction* old_signal_action) { 3934b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct itimerval timer; 394879916a9393ef4af84ebe8b331220586dd8cafbbvladlosev timer.it_interval.tv_sec = 0; 3954b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev timer.it_interval.tv_usec = 0; 396879916a9393ef4af84ebe8b331220586dd8cafbbvladlosev timer.it_value = timer.it_interval; 3974b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 3984b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct sigaction signal_action; 3994b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev memset(&signal_action, 0, sizeof(signal_action)); 4004b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev sigemptyset(&signal_action.sa_mask); 4014b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev signal_action.sa_handler = SIG_IGN; 4024b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action)); 4034b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev} 4044b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 4054b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev// Tests that death tests work when SIGPROF handler and timer are set. 4064b07d73f4e683d85546d78793a9914a4b5d3d98evladlosevTEST_F(TestForDeathTest, FastSigprofActionSet) { 4074b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev testing::GTEST_FLAG(death_test_style) = "fast"; 4084b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev SetSigprofActionAndTimer(); 4094b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev EXPECT_DEATH(_exit(1), ""); 4104b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct sigaction old_signal_action; 4114b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev DisableSigprofActionAndTimer(&old_signal_action); 4124b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 4134b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev} 4144b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 4154b07d73f4e683d85546d78793a9914a4b5d3d98evladlosevTEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) { 4164b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev testing::GTEST_FLAG(death_test_style) = "threadsafe"; 4174b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev SetSigprofActionAndTimer(); 4184b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev EXPECT_DEATH(_exit(1), ""); 4194b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev struct sigaction old_signal_action; 4204b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev DisableSigprofActionAndTimer(&old_signal_action); 4214b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 4224b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev} 4234b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev# endif // GTEST_OS_LINUX 4244b07d73f4e683d85546d78793a9914a4b5d3d98evladlosev 425d201456903f3ecae1f7794edfab0d5678e64226shiqian// Repeats a representative sample of death tests in the "threadsafe" style: 426d201456903f3ecae1f7794edfab0d5678e64226shiqian 427d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) { 428d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 429d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 430d201456903f3ecae1f7794edfab0d5678e64226shiqian} 431d201456903f3ecae1f7794edfab0d5678e64226shiqian 432d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) { 433d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 434d201456903f3ecae1f7794edfab0d5678e64226shiqian should_die_ = true; 435d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 436d201456903f3ecae1f7794edfab0d5678e64226shiqian} 437d201456903f3ecae1f7794edfab0d5678e64226shiqian 438d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) { 439d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 440d201456903f3ecae1f7794edfab0d5678e64226shiqian 441d201456903f3ecae1f7794edfab0d5678e64226shiqian for (int i = 0; i < 3; ++i) 442019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i; 443019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 444019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 445019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) { 446019d19af978f05b774407e0d46a3bda2c18c67c6shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 447019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 4484984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ChangeToRootDir(); 449019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 450019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 4514984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ChangeToRootDir(); 452019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_DEATH(_exit(1), ""); 453d201456903f3ecae1f7794edfab0d5678e64226shiqian} 454d201456903f3ecae1f7794edfab0d5678e64226shiqian 455d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, MixedStyles) { 456d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 457019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), ""); 458d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "fast"; 459019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), ""); 460d201456903f3ecae1f7794edfab0d5678e64226shiqian} 461d201456903f3ecae1f7794edfab0d5678e64226shiqian 462fc01f532a622a7d460a4eff816c56c0e501f20f7zhanyong.wan# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 463fc01f532a622a7d460a4eff816c56c0e501f20f7zhanyong.wan 464d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 465d201456903f3ecae1f7794edfab0d5678e64226shiqian 466d201456903f3ecae1f7794edfab0d5678e64226shiqianbool pthread_flag; 467d201456903f3ecae1f7794edfab0d5678e64226shiqian 468d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid SetPthreadFlag() { 469d201456903f3ecae1f7794edfab0d5678e64226shiqian pthread_flag = true; 470d201456903f3ecae1f7794edfab0d5678e64226shiqian} 471d201456903f3ecae1f7794edfab0d5678e64226shiqian 472d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 473d201456903f3ecae1f7794edfab0d5678e64226shiqian 474d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) { 47553e0dc4041f660b6517b15b08b496e164be614f1shiqian if (!testing::GTEST_FLAG(death_test_use_fork)) { 47653e0dc4041f660b6517b15b08b496e164be614f1shiqian testing::GTEST_FLAG(death_test_style) = "threadsafe"; 47753e0dc4041f660b6517b15b08b496e164be614f1shiqian pthread_flag = false; 47853e0dc4041f660b6517b15b08b496e164be614f1shiqian ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL)); 47953e0dc4041f660b6517b15b08b496e164be614f1shiqian ASSERT_DEATH(_exit(1), ""); 48053e0dc4041f660b6517b15b08b496e164be614f1shiqian ASSERT_FALSE(pthread_flag); 48153e0dc4041f660b6517b15b08b496e164be614f1shiqian } 482d201456903f3ecae1f7794edfab0d5678e64226shiqian} 483d201456903f3ecae1f7794edfab0d5678e64226shiqian 484ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 4854984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 486d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a method of another class can be used in a death test. 487d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, MethodOfAnotherClass) { 488d201456903f3ecae1f7794edfab0d5678e64226shiqian const MayDie x(true); 489d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction"); 490d201456903f3ecae1f7794edfab0d5678e64226shiqian} 491d201456903f3ecae1f7794edfab0d5678e64226shiqian 492d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a global function can be used in a death test. 493d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, GlobalFunction) { 494d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), "GlobalFunction"); 495d201456903f3ecae1f7794edfab0d5678e64226shiqian} 496d201456903f3ecae1f7794edfab0d5678e64226shiqian 497d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that any value convertible to an RE works as a second 498d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument to EXPECT_DEATH. 499d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) { 500d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char regex_c_str[] = "GlobalFunction"; 501d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), regex_c_str); 502d201456903f3ecae1f7794edfab0d5678e64226shiqian 503d201456903f3ecae1f7794edfab0d5678e64226shiqian const testing::internal::RE regex(regex_c_str); 504d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), regex); 505d201456903f3ecae1f7794edfab0d5678e64226shiqian 506ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_HAS_GLOBAL_STRING 507ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 508d201456903f3ecae1f7794edfab0d5678e64226shiqian const string regex_str(regex_c_str); 509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), regex_str); 510ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 511ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_HAS_GLOBAL_STRING 512d201456903f3ecae1f7794edfab0d5678e64226shiqian 5131e4d31008ff9e095de3ff35a3db7b66773eab54fkosak# if !GTEST_USES_PCRE 5141e4d31008ff9e095de3ff35a3db7b66773eab54fkosak 515d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::string regex_std_str(regex_c_str); 516d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(GlobalFunction(), regex_std_str); 5171e4d31008ff9e095de3ff35a3db7b66773eab54fkosak 5181e4d31008ff9e095de3ff35a3db7b66773eab54fkosak# endif // !GTEST_USES_PCRE 519d201456903f3ecae1f7794edfab0d5678e64226shiqian} 520d201456903f3ecae1f7794edfab0d5678e64226shiqian 521d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a non-void function can be used in a death test. 522d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, NonVoidFunction) { 523d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction"); 524d201456903f3ecae1f7794edfab0d5678e64226shiqian} 525d201456903f3ecae1f7794edfab0d5678e64226shiqian 526d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that functions that take parameter(s) can be used in a death test. 527d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, FunctionWithParameter) { 528d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIf(true), "DieIf\\(\\)"); 529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan"); 530d201456903f3ecae1f7794edfab0d5678e64226shiqian} 531d201456903f3ecae1f7794edfab0d5678e64226shiqian 532d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 533d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, OutsideFixture) { 534d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTestSubroutine(); 535d201456903f3ecae1f7794edfab0d5678e64226shiqian} 536d201456903f3ecae1f7794edfab0d5678e64226shiqian 537d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that death tests can be done inside a loop. 538d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, InsideLoop) { 539d201456903f3ecae1f7794edfab0d5678e64226shiqian for (int i = 0; i < 5; i++) { 540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i; 541d201456903f3ecae1f7794edfab0d5678e64226shiqian } 542d201456903f3ecae1f7794edfab0d5678e64226shiqian} 543d201456903f3ecae1f7794edfab0d5678e64226shiqian 544d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a compound statement can be used in a death test. 545d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, CompoundStatement) { 546d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH({ // NOLINT 547d201456903f3ecae1f7794edfab0d5678e64226shiqian const int x = 2; 548d201456903f3ecae1f7794edfab0d5678e64226shiqian const int y = x + 1; 549d201456903f3ecae1f7794edfab0d5678e64226shiqian DieIfLessThan(x, y); 550d201456903f3ecae1f7794edfab0d5678e64226shiqian }, 551d201456903f3ecae1f7794edfab0d5678e64226shiqian "DieIfLessThan"); 552d201456903f3ecae1f7794edfab0d5678e64226shiqian} 553d201456903f3ecae1f7794edfab0d5678e64226shiqian 554d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that code that doesn't die causes a death test to fail. 555d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, DoesNotDie) { 556d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"), 557d201456903f3ecae1f7794edfab0d5678e64226shiqian "failed to die"); 558d201456903f3ecae1f7794edfab0d5678e64226shiqian} 559d201456903f3ecae1f7794edfab0d5678e64226shiqian 560d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a death test fails when the error message isn't expected. 561d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, ErrorMessageMismatch) { 562d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 563d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message."; 564d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "died but not with expected error"); 565d201456903f3ecae1f7794edfab0d5678e64226shiqian} 566d201456903f3ecae1f7794edfab0d5678e64226shiqian 567d201456903f3ecae1f7794edfab0d5678e64226shiqian// On exit, *aborted will be true iff the EXPECT_DEATH() statement 568d201456903f3ecae1f7794edfab0d5678e64226shiqian// aborted the function. 569d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectDeathTestHelper(bool* aborted) { 570d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 571d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 572d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 573d201456903f3ecae1f7794edfab0d5678e64226shiqian} 574d201456903f3ecae1f7794edfab0d5678e64226shiqian 575d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that EXPECT_DEATH doesn't abort the test on failure. 576d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, EXPECT_DEATH) { 577d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 578d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted), 579d201456903f3ecae1f7794edfab0d5678e64226shiqian "failed to die"); 580d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 581d201456903f3ecae1f7794edfab0d5678e64226shiqian} 582d201456903f3ecae1f7794edfab0d5678e64226shiqian 583d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASSERT_DEATH does abort the test on failure. 584d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, ASSERT_DEATH) { 585d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool aborted; 586d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 587d201456903f3ecae1f7794edfab0d5678e64226shiqian aborted = true; 588d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 589d201456903f3ecae1f7794edfab0d5678e64226shiqian aborted = false; 590d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "failed to die"); 591d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(aborted); 592d201456903f3ecae1f7794edfab0d5678e64226shiqian} 593d201456903f3ecae1f7794edfab0d5678e64226shiqian 594d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that EXPECT_DEATH evaluates the arguments exactly once. 595d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, SingleEvaluation) { 596d201456903f3ecae1f7794edfab0d5678e64226shiqian int x = 3; 597d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIf((++x) == 4), "DieIf"); 598d201456903f3ecae1f7794edfab0d5678e64226shiqian 599d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* regex = "DieIf"; 600d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* regex_save = regex; 601d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(DieIfLessThan(3, 4), regex++); 602d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(regex_save + 1, regex); 603d201456903f3ecae1f7794edfab0d5678e64226shiqian} 604d201456903f3ecae1f7794edfab0d5678e64226shiqian 605d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that run-away death tests are reported as failures. 60650f4deb1cf3ef32282c13b7cb84a81b1bf61e0d8vladlosevTEST_F(TestForDeathTest, RunawayIsFailure) { 607d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"), 608d201456903f3ecae1f7794edfab0d5678e64226shiqian "failed to die."); 60950f4deb1cf3ef32282c13b7cb84a81b1bf61e0d8vladlosev} 610d201456903f3ecae1f7794edfab0d5678e64226shiqian 61150f4deb1cf3ef32282c13b7cb84a81b1bf61e0d8vladlosev// Tests that death tests report executing 'return' in the statement as 61250f4deb1cf3ef32282c13b7cb84a81b1bf61e0d8vladlosev// failure. 61350f4deb1cf3ef32282c13b7cb84a81b1bf61e0d8vladlosevTEST_F(TestForDeathTest, ReturnIsFailure) { 614d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"), 615d201456903f3ecae1f7794edfab0d5678e64226shiqian "illegal return in test statement."); 616d201456903f3ecae1f7794edfab0d5678e64226shiqian} 617d201456903f3ecae1f7794edfab0d5678e64226shiqian 618f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a 619f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// message to it, and in debug mode it: 620d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1. Asserts on death. 621d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2. Has no side effect. 622d201456903f3ecae1f7794edfab0d5678e64226shiqian// 623d201456903f3ecae1f7794edfab0d5678e64226shiqian// And in opt mode, it: 624d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1. Has side effects but does not assert. 625d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, TestExpectDebugDeath) { 626d201456903f3ecae1f7794edfab0d5678e64226shiqian int sideeffect = 0; 627d201456903f3ecae1f7794edfab0d5678e64226shiqian 628f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 629f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << "Must accept a streamed message"; 630d201456903f3ecae1f7794edfab0d5678e64226shiqian 631ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifdef NDEBUG 632ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 633d201456903f3ecae1f7794edfab0d5678e64226shiqian // Checks that the assignment occurs in opt mode (sideeffect). 634d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(12, sideeffect); 635ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 636ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 637ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 638d201456903f3ecae1f7794edfab0d5678e64226shiqian // Checks that the assignment does not occur in dbg mode (no sideeffect). 639d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, sideeffect); 640ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 641ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 642d201456903f3ecae1f7794edfab0d5678e64226shiqian} 643d201456903f3ecae1f7794edfab0d5678e64226shiqian 644f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a 645f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// message to it, and in debug mode it: 646f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// 1. Asserts on death. 647d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2. Has no side effect. 648d201456903f3ecae1f7794edfab0d5678e64226shiqian// 649f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// And in opt mode, it: 650f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// 1. Has side effects but does not assert. 651bcb12fa0f651f7de3a10f4535ed856e52b1c3f62shiqianTEST_F(TestForDeathTest, TestAssertDebugDeath) { 652d201456903f3ecae1f7794edfab0d5678e64226shiqian int sideeffect = 0; 653d201456903f3ecae1f7794edfab0d5678e64226shiqian 654f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 655f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << "Must accept a streamed message"; 656d201456903f3ecae1f7794edfab0d5678e64226shiqian 657ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifdef NDEBUG 658ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 659d201456903f3ecae1f7794edfab0d5678e64226shiqian // Checks that the assignment occurs in opt mode (sideeffect). 660d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(12, sideeffect); 661ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 662ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 663ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 664d201456903f3ecae1f7794edfab0d5678e64226shiqian // Checks that the assignment does not occur in dbg mode (no sideeffect). 665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, sideeffect); 666ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 667ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 668d201456903f3ecae1f7794edfab0d5678e64226shiqian} 669d201456903f3ecae1f7794edfab0d5678e64226shiqian 670ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifndef NDEBUG 671d201456903f3ecae1f7794edfab0d5678e64226shiqian 672d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectDebugDeathHelper(bool* aborted) { 673d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 674d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail."; 675d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 676d201456903f3ecae1f7794edfab0d5678e64226shiqian} 677d201456903f3ecae1f7794edfab0d5678e64226shiqian 678ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 67944a041b711ff4a5b5f341f21127aed46dbfe38adzhanyong.wanTEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) { 6804984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan printf("This test should be considered failing if it shows " 6814984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan "any pop-up dialogs.\n"); 6824984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan fflush(stdout); 6834984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 6844984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_DEATH({ 6854984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan testing::GTEST_FLAG(catch_exceptions) = false; 6864984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan abort(); 6874984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan }, ""); 6884984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 689ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 6904984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 691d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort 692d201456903f3ecae1f7794edfab0d5678e64226shiqian// the function. 693d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) { 694d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 695d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), ""); 696d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 697d201456903f3ecae1f7794edfab0d5678e64226shiqian} 698d201456903f3ecae1f7794edfab0d5678e64226shiqian 699d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AssertDebugDeathHelper(bool* aborted) { 700d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 701a6340420b9cee27f77c5b91bea807121914a5831kosak GTEST_LOG_(INFO) << "Before ASSERT_DEBUG_DEATH"; 702a6340420b9cee27f77c5b91bea807121914a5831kosak ASSERT_DEBUG_DEATH(GTEST_LOG_(INFO) << "In ASSERT_DEBUG_DEATH"; return, "") 703a6340420b9cee27f77c5b91bea807121914a5831kosak << "This is expected to fail."; 704a6340420b9cee27f77c5b91bea807121914a5831kosak GTEST_LOG_(INFO) << "After ASSERT_DEBUG_DEATH"; 705d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 706d201456903f3ecae1f7794edfab0d5678e64226shiqian} 707d201456903f3ecae1f7794edfab0d5678e64226shiqian 708d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on 709d201456903f3ecae1f7794edfab0d5678e64226shiqian// failure. 710d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, AssertDebugDeathAborts) { 711d201456903f3ecae1f7794edfab0d5678e64226shiqian static bool aborted; 712d201456903f3ecae1f7794edfab0d5678e64226shiqian aborted = false; 713d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 714d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(aborted); 715d201456903f3ecae1f7794edfab0d5678e64226shiqian} 716d201456903f3ecae1f7794edfab0d5678e64226shiqian 717a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts2) { 718a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 719a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 720a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 721a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 722a6340420b9cee27f77c5b91bea807121914a5831kosak} 723a6340420b9cee27f77c5b91bea807121914a5831kosak 724a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts3) { 725a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 726a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 727a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 728a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 729a6340420b9cee27f77c5b91bea807121914a5831kosak} 730a6340420b9cee27f77c5b91bea807121914a5831kosak 731a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts4) { 732a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 733a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 734a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 735a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 736a6340420b9cee27f77c5b91bea807121914a5831kosak} 737a6340420b9cee27f77c5b91bea807121914a5831kosak 738a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts5) { 739a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 740a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 741a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 742a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 743a6340420b9cee27f77c5b91bea807121914a5831kosak} 744a6340420b9cee27f77c5b91bea807121914a5831kosak 745a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts6) { 746a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 747a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 748a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 749a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 750a6340420b9cee27f77c5b91bea807121914a5831kosak} 751a6340420b9cee27f77c5b91bea807121914a5831kosak 752a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts7) { 753a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 754a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 755a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 756a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 757a6340420b9cee27f77c5b91bea807121914a5831kosak} 758a6340420b9cee27f77c5b91bea807121914a5831kosak 759a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts8) { 760a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 761a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 762a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 763a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 764a6340420b9cee27f77c5b91bea807121914a5831kosak} 765a6340420b9cee27f77c5b91bea807121914a5831kosak 766a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts9) { 767a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 768a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 769a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 770a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 771a6340420b9cee27f77c5b91bea807121914a5831kosak} 772a6340420b9cee27f77c5b91bea807121914a5831kosak 773a6340420b9cee27f77c5b91bea807121914a5831kosakTEST_F(TestForDeathTest, AssertDebugDeathAborts10) { 774a6340420b9cee27f77c5b91bea807121914a5831kosak static bool aborted; 775a6340420b9cee27f77c5b91bea807121914a5831kosak aborted = false; 776a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 777a6340420b9cee27f77c5b91bea807121914a5831kosak EXPECT_TRUE(aborted); 778a6340420b9cee27f77c5b91bea807121914a5831kosak} 779a6340420b9cee27f77c5b91bea807121914a5831kosak 780ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // _NDEBUG 781d201456903f3ecae1f7794edfab0d5678e64226shiqian 782d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the *_EXIT family of macros, using a variety of predicates. 78353e0dc4041f660b6517b15b08b496e164be614f1shiqianstatic void TestExitMacros() { 784019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 785019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), ""); 7864984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 787ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 788ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 7894984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Of all signals effects on the process exit code, only those of SIGABRT 7904984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // are documented on Windows. 7914984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx. 792f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar"; 793ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 794ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 795ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 7964984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo"; 7974984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar"; 7984984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 799d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 800019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "") 801f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << "This failure is expected, too."; 802d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected, too."); 803ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 804ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 8054984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 8064984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_NONFATAL_FAILURE({ // NOLINT 8074984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "") 808f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << "This failure is expected."; 8094984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan }, "This failure is expected."); 810d201456903f3ecae1f7794edfab0d5678e64226shiqian} 811d201456903f3ecae1f7794edfab0d5678e64226shiqian 81253e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(TestForDeathTest, ExitMacros) { 81353e0dc4041f660b6517b15b08b496e164be614f1shiqian TestExitMacros(); 81453e0dc4041f660b6517b15b08b496e164be614f1shiqian} 81553e0dc4041f660b6517b15b08b496e164be614f1shiqian 81653e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(TestForDeathTest, ExitMacrosUsingFork) { 81753e0dc4041f660b6517b15b08b496e164be614f1shiqian testing::GTEST_FLAG(death_test_use_fork) = true; 81853e0dc4041f660b6517b15b08b496e164be614f1shiqian TestExitMacros(); 81953e0dc4041f660b6517b15b08b496e164be614f1shiqian} 82053e0dc4041f660b6517b15b08b496e164be614f1shiqian 821d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestForDeathTest, InvalidStyle) { 822d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::GTEST_FLAG(death_test_style) = "rococo"; 823d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 824019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(0), "") << "This failure is expected."; 825d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 826d201456903f3ecae1f7794edfab0d5678e64226shiqian} 827d201456903f3ecae1f7794edfab0d5678e64226shiqian 82840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanTEST_F(TestForDeathTest, DeathTestFailedOutput) { 82940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::GTEST_FLAG(death_test_style) = "fast"; 83040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_NONFATAL_FAILURE( 83140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_DEATH(DieWithMessage("death\n"), 83240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "expected message"), 83340d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "Actual msg:\n" 83440d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] death\n"); 83540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 83640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 83740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanTEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) { 83840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::GTEST_FLAG(death_test_style) = "fast"; 83940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_NONFATAL_FAILURE( 84040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_DEATH({ 84140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan fprintf(stderr, "returning\n"); 84240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan fflush(stderr); 84340d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan return; 84440d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan }, ""), 84540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan " Result: illegal return in test statement.\n" 84640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan " Error msg:\n" 84740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] returning\n"); 84840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 84940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 85040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanTEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) { 85140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::GTEST_FLAG(death_test_style) = "fast"; 85240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_NONFATAL_FAILURE( 85340d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"), 85440d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::ExitedWithCode(3), 85540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "expected message"), 85640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan " Result: died but not with expected exit code:\n" 85740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan " Exited with exit status 1\n" 85840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "Actual msg:\n" 85940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] exiting with rc 1\n"); 86040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 86140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 86240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanTEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) { 86340d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::GTEST_FLAG(death_test_style) = "fast"; 86440d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_NONFATAL_FAILURE( 86540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 86640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "line 1\nxyz\nline 3\n"), 86740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "Actual msg:\n" 86840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] line 1\n" 86940d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] line 2\n" 87040d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "[ DEATH ] line 3\n"); 87140d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 87240d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 87340d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wanTEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) { 87440d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan testing::GTEST_FLAG(death_test_style) = "fast"; 87540d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 87640d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan "line 1\nline 2\nline 3\n"); 87740d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan} 87840d0ba7a62a8bc749fbaf0747621b0aa10ddf1b9zhanyong.wan 879d201456903f3ecae1f7794edfab0d5678e64226shiqian// A DeathTestFactory that returns MockDeathTests. 880d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MockDeathTestFactory : public DeathTestFactory { 881d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 882d201456903f3ecae1f7794edfab0d5678e64226shiqian MockDeathTestFactory(); 883d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual bool Create(const char* statement, 884d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::testing::internal::RE* regex, 885d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* file, int line, DeathTest** test); 886d201456903f3ecae1f7794edfab0d5678e64226shiqian 887d201456903f3ecae1f7794edfab0d5678e64226shiqian // Sets the parameters for subsequent calls to Create. 888d201456903f3ecae1f7794edfab0d5678e64226shiqian void SetParameters(bool create, DeathTest::TestRole role, 889d201456903f3ecae1f7794edfab0d5678e64226shiqian int status, bool passed); 890d201456903f3ecae1f7794edfab0d5678e64226shiqian 891d201456903f3ecae1f7794edfab0d5678e64226shiqian // Accessors. 892d201456903f3ecae1f7794edfab0d5678e64226shiqian int AssumeRoleCalls() const { return assume_role_calls_; } 893d201456903f3ecae1f7794edfab0d5678e64226shiqian int WaitCalls() const { return wait_calls_; } 894f8c44a0ae449dd78d703e94c295287d051560217kosak size_t PassedCalls() const { return passed_args_.size(); } 895d201456903f3ecae1f7794edfab0d5678e64226shiqian bool PassedArgument(int n) const { return passed_args_[n]; } 896f8c44a0ae449dd78d703e94c295287d051560217kosak size_t AbortCalls() const { return abort_args_.size(); } 897d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTest::AbortReason AbortArgument(int n) const { 898d201456903f3ecae1f7794edfab0d5678e64226shiqian return abort_args_[n]; 899d201456903f3ecae1f7794edfab0d5678e64226shiqian } 900d201456903f3ecae1f7794edfab0d5678e64226shiqian bool TestDeleted() const { return test_deleted_; } 901d201456903f3ecae1f7794edfab0d5678e64226shiqian 902d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 903d201456903f3ecae1f7794edfab0d5678e64226shiqian friend class MockDeathTest; 904d201456903f3ecae1f7794edfab0d5678e64226shiqian // If true, Create will return a MockDeathTest; otherwise it returns 905d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL. 906d201456903f3ecae1f7794edfab0d5678e64226shiqian bool create_; 907d201456903f3ecae1f7794edfab0d5678e64226shiqian // The value a MockDeathTest will return from its AssumeRole method. 908d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTest::TestRole role_; 909d201456903f3ecae1f7794edfab0d5678e64226shiqian // The value a MockDeathTest will return from its Wait method. 910d201456903f3ecae1f7794edfab0d5678e64226shiqian int status_; 911d201456903f3ecae1f7794edfab0d5678e64226shiqian // The value a MockDeathTest will return from its Passed method. 912d201456903f3ecae1f7794edfab0d5678e64226shiqian bool passed_; 913d201456903f3ecae1f7794edfab0d5678e64226shiqian 914d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of times AssumeRole was called. 915d201456903f3ecae1f7794edfab0d5678e64226shiqian int assume_role_calls_; 916d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of times Wait was called. 917d201456903f3ecae1f7794edfab0d5678e64226shiqian int wait_calls_; 918d201456903f3ecae1f7794edfab0d5678e64226shiqian // The arguments to the calls to Passed since the last call to 919d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetParameters. 920d201456903f3ecae1f7794edfab0d5678e64226shiqian std::vector<bool> passed_args_; 921d201456903f3ecae1f7794edfab0d5678e64226shiqian // The arguments to the calls to Abort since the last call to 922d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetParameters. 923d201456903f3ecae1f7794edfab0d5678e64226shiqian std::vector<DeathTest::AbortReason> abort_args_; 924d201456903f3ecae1f7794edfab0d5678e64226shiqian // True if the last MockDeathTest returned by Create has been 925d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 926d201456903f3ecae1f7794edfab0d5678e64226shiqian bool test_deleted_; 927d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 928d201456903f3ecae1f7794edfab0d5678e64226shiqian 929d201456903f3ecae1f7794edfab0d5678e64226shiqian 930d201456903f3ecae1f7794edfab0d5678e64226shiqian// A DeathTest implementation useful in testing. It returns values set 931d201456903f3ecae1f7794edfab0d5678e64226shiqian// at its creation from its various inherited DeathTest methods, and 932d201456903f3ecae1f7794edfab0d5678e64226shiqian// reports calls to those methods to its parent MockDeathTestFactory 933d201456903f3ecae1f7794edfab0d5678e64226shiqian// object. 934d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MockDeathTest : public DeathTest { 935d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 936d201456903f3ecae1f7794edfab0d5678e64226shiqian MockDeathTest(MockDeathTestFactory *parent, 937d201456903f3ecae1f7794edfab0d5678e64226shiqian TestRole role, int status, bool passed) : 938d201456903f3ecae1f7794edfab0d5678e64226shiqian parent_(parent), role_(role), status_(status), passed_(passed) { 939d201456903f3ecae1f7794edfab0d5678e64226shiqian } 940d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual ~MockDeathTest() { 941d201456903f3ecae1f7794edfab0d5678e64226shiqian parent_->test_deleted_ = true; 942d201456903f3ecae1f7794edfab0d5678e64226shiqian } 943d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual TestRole AssumeRole() { 944d201456903f3ecae1f7794edfab0d5678e64226shiqian ++parent_->assume_role_calls_; 945d201456903f3ecae1f7794edfab0d5678e64226shiqian return role_; 946d201456903f3ecae1f7794edfab0d5678e64226shiqian } 947d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual int Wait() { 948d201456903f3ecae1f7794edfab0d5678e64226shiqian ++parent_->wait_calls_; 949d201456903f3ecae1f7794edfab0d5678e64226shiqian return status_; 950d201456903f3ecae1f7794edfab0d5678e64226shiqian } 951d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual bool Passed(bool exit_status_ok) { 952d201456903f3ecae1f7794edfab0d5678e64226shiqian parent_->passed_args_.push_back(exit_status_ok); 953d201456903f3ecae1f7794edfab0d5678e64226shiqian return passed_; 954d201456903f3ecae1f7794edfab0d5678e64226shiqian } 955d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void Abort(AbortReason reason) { 956d201456903f3ecae1f7794edfab0d5678e64226shiqian parent_->abort_args_.push_back(reason); 957d201456903f3ecae1f7794edfab0d5678e64226shiqian } 9588965a6a0d2165f32e6413594bba6367f271f51e7vladlosev 959d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 960d201456903f3ecae1f7794edfab0d5678e64226shiqian MockDeathTestFactory* const parent_; 961d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestRole role_; 962d201456903f3ecae1f7794edfab0d5678e64226shiqian const int status_; 963d201456903f3ecae1f7794edfab0d5678e64226shiqian const bool passed_; 964d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 965d201456903f3ecae1f7794edfab0d5678e64226shiqian 966d201456903f3ecae1f7794edfab0d5678e64226shiqian 967d201456903f3ecae1f7794edfab0d5678e64226shiqian// MockDeathTestFactory constructor. 968d201456903f3ecae1f7794edfab0d5678e64226shiqianMockDeathTestFactory::MockDeathTestFactory() 969d201456903f3ecae1f7794edfab0d5678e64226shiqian : create_(true), 970d201456903f3ecae1f7794edfab0d5678e64226shiqian role_(DeathTest::OVERSEE_TEST), 971d201456903f3ecae1f7794edfab0d5678e64226shiqian status_(0), 972d201456903f3ecae1f7794edfab0d5678e64226shiqian passed_(true), 973d201456903f3ecae1f7794edfab0d5678e64226shiqian assume_role_calls_(0), 974d201456903f3ecae1f7794edfab0d5678e64226shiqian wait_calls_(0), 975d201456903f3ecae1f7794edfab0d5678e64226shiqian passed_args_(), 976d201456903f3ecae1f7794edfab0d5678e64226shiqian abort_args_() { 977d201456903f3ecae1f7794edfab0d5678e64226shiqian} 978d201456903f3ecae1f7794edfab0d5678e64226shiqian 979d201456903f3ecae1f7794edfab0d5678e64226shiqian 980d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets the parameters for subsequent calls to Create. 981d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid MockDeathTestFactory::SetParameters(bool create, 982d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTest::TestRole role, 983d201456903f3ecae1f7794edfab0d5678e64226shiqian int status, bool passed) { 984d201456903f3ecae1f7794edfab0d5678e64226shiqian create_ = create; 985d201456903f3ecae1f7794edfab0d5678e64226shiqian role_ = role; 986d201456903f3ecae1f7794edfab0d5678e64226shiqian status_ = status; 987d201456903f3ecae1f7794edfab0d5678e64226shiqian passed_ = passed; 988d201456903f3ecae1f7794edfab0d5678e64226shiqian 989d201456903f3ecae1f7794edfab0d5678e64226shiqian assume_role_calls_ = 0; 990d201456903f3ecae1f7794edfab0d5678e64226shiqian wait_calls_ = 0; 991d201456903f3ecae1f7794edfab0d5678e64226shiqian passed_args_.clear(); 992d201456903f3ecae1f7794edfab0d5678e64226shiqian abort_args_.clear(); 993d201456903f3ecae1f7794edfab0d5678e64226shiqian} 994d201456903f3ecae1f7794edfab0d5678e64226shiqian 995d201456903f3ecae1f7794edfab0d5678e64226shiqian 996d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets test to NULL (if create_ is false) or to the address of a new 997d201456903f3ecae1f7794edfab0d5678e64226shiqian// MockDeathTest object with parameters taken from the last call 998d201456903f3ecae1f7794edfab0d5678e64226shiqian// to SetParameters (if create_ is true). Always returns true. 99912d740faef11779b27b17c558ca92622bc0d2b54zhanyong.wanbool MockDeathTestFactory::Create(const char* /*statement*/, 100012d740faef11779b27b17c558ca92622bc0d2b54zhanyong.wan const ::testing::internal::RE* /*regex*/, 100112d740faef11779b27b17c558ca92622bc0d2b54zhanyong.wan const char* /*file*/, 100212d740faef11779b27b17c558ca92622bc0d2b54zhanyong.wan int /*line*/, 1003d201456903f3ecae1f7794edfab0d5678e64226shiqian DeathTest** test) { 1004d201456903f3ecae1f7794edfab0d5678e64226shiqian test_deleted_ = false; 1005d201456903f3ecae1f7794edfab0d5678e64226shiqian if (create_) { 1006d201456903f3ecae1f7794edfab0d5678e64226shiqian *test = new MockDeathTest(this, role_, status_, passed_); 1007d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1008d201456903f3ecae1f7794edfab0d5678e64226shiqian *test = NULL; 1009d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1010d201456903f3ecae1f7794edfab0d5678e64226shiqian return true; 1011d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1012d201456903f3ecae1f7794edfab0d5678e64226shiqian 1013e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro. 1014d201456903f3ecae1f7794edfab0d5678e64226shiqian// It installs a MockDeathTestFactory that is used for the duration 1015d201456903f3ecae1f7794edfab0d5678e64226shiqian// of the test case. 1016d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MacroLogicDeathTest : public testing::Test { 1017d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1018d201456903f3ecae1f7794edfab0d5678e64226shiqian static testing::internal::ReplaceDeathTestFactory* replacer_; 1019d201456903f3ecae1f7794edfab0d5678e64226shiqian static MockDeathTestFactory* factory_; 1020d201456903f3ecae1f7794edfab0d5678e64226shiqian 1021d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 1022d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_ = new MockDeathTestFactory; 1023aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_); 1024d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1025d201456903f3ecae1f7794edfab0d5678e64226shiqian 1026d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 1027d201456903f3ecae1f7794edfab0d5678e64226shiqian delete replacer_; 1028d201456903f3ecae1f7794edfab0d5678e64226shiqian replacer_ = NULL; 1029d201456903f3ecae1f7794edfab0d5678e64226shiqian delete factory_; 1030d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_ = NULL; 1031d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1032d201456903f3ecae1f7794edfab0d5678e64226shiqian 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian // Runs a death test that breaks the rules by returning. Such a death 1034d201456903f3ecae1f7794edfab0d5678e64226shiqian // test cannot be run directly from a test routine that uses a 1035d201456903f3ecae1f7794edfab0d5678e64226shiqian // MockDeathTest, or the remainder of the routine will not be executed. 1036d201456903f3ecae1f7794edfab0d5678e64226shiqian static void RunReturningDeathTest(bool* flag) { 1037d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DEATH({ // NOLINT 1038d201456903f3ecae1f7794edfab0d5678e64226shiqian *flag = true; 1039d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1040d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 1041d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1042d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1043d201456903f3ecae1f7794edfab0d5678e64226shiqian 1044d201456903f3ecae1f7794edfab0d5678e64226shiqiantesting::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ 1045d201456903f3ecae1f7794edfab0d5678e64226shiqian = NULL; 1046d201456903f3ecae1f7794edfab0d5678e64226shiqianMockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL; 1047d201456903f3ecae1f7794edfab0d5678e64226shiqian 1048d201456903f3ecae1f7794edfab0d5678e64226shiqian 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian// Test that nothing happens when the factory doesn't return a DeathTest: 1050d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(MacroLogicDeathTest, NothingHappens) { 1051d201456903f3ecae1f7794edfab0d5678e64226shiqian bool flag = false; 1052d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true); 1053d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(flag = true, ""); 1054d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(flag); 1055d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, factory_->AssumeRoleCalls()); 1056d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, factory_->WaitCalls()); 1057f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->PassedCalls()); 1058f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->AbortCalls()); 1059d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(factory_->TestDeleted()); 1060d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1061d201456903f3ecae1f7794edfab0d5678e64226shiqian 1062d201456903f3ecae1f7794edfab0d5678e64226shiqian// Test that the parent process doesn't run the death test code, 1063d201456903f3ecae1f7794edfab0d5678e64226shiqian// and that the Passed method returns false when the (simulated) 1064d201456903f3ecae1f7794edfab0d5678e64226shiqian// child process exits with status 0: 1065d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) { 1066d201456903f3ecae1f7794edfab0d5678e64226shiqian bool flag = false; 1067d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true); 1068d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(flag = true, ""); 1069d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(flag); 1070d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->AssumeRoleCalls()); 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->WaitCalls()); 1072f8c44a0ae449dd78d703e94c295287d051560217kosak ASSERT_EQ(1U, factory_->PassedCalls()); 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(factory_->PassedArgument(0)); 1074f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->AbortCalls()); 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(factory_->TestDeleted()); 1076d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1077d201456903f3ecae1f7794edfab0d5678e64226shiqian 1078d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the Passed method was given the argument "true" when 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian// the (simulated) child process exits with status 1: 1080d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) { 1081d201456903f3ecae1f7794edfab0d5678e64226shiqian bool flag = false; 1082d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true); 1083d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(flag = true, ""); 1084d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(flag); 1085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->AssumeRoleCalls()); 1086d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->WaitCalls()); 1087f8c44a0ae449dd78d703e94c295287d051560217kosak ASSERT_EQ(1U, factory_->PassedCalls()); 1088d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(factory_->PassedArgument(0)); 1089f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->AbortCalls()); 1090d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(factory_->TestDeleted()); 1091d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1092d201456903f3ecae1f7794edfab0d5678e64226shiqian 1093d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the (simulated) child process executes the death test 1094d201456903f3ecae1f7794edfab0d5678e64226shiqian// code, and is aborted with the correct AbortReason if it 1095d201456903f3ecae1f7794edfab0d5678e64226shiqian// executes a return statement. 1096d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(MacroLogicDeathTest, ChildPerformsReturn) { 1097d201456903f3ecae1f7794edfab0d5678e64226shiqian bool flag = false; 1098d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 1099d201456903f3ecae1f7794edfab0d5678e64226shiqian RunReturningDeathTest(&flag); 1100d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(flag); 1101d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->AssumeRoleCalls()); 1102d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, factory_->WaitCalls()); 1103f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->PassedCalls()); 1104f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(1U, factory_->AbortCalls()); 1105d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 1106d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->AbortArgument(0)); 1107d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(factory_->TestDeleted()); 1108d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1109d201456903f3ecae1f7794edfab0d5678e64226shiqian 1110d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the (simulated) child process is aborted with the 1111d201456903f3ecae1f7794edfab0d5678e64226shiqian// correct AbortReason if it does not die. 1112d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(MacroLogicDeathTest, ChildDoesNotDie) { 1113d201456903f3ecae1f7794edfab0d5678e64226shiqian bool flag = false; 1114d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 1115d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DEATH(flag = true, ""); 1116d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(flag); 1117d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, factory_->AssumeRoleCalls()); 1118d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, factory_->WaitCalls()); 1119f8c44a0ae449dd78d703e94c295287d051560217kosak EXPECT_EQ(0U, factory_->PassedCalls()); 1120d201456903f3ecae1f7794edfab0d5678e64226shiqian // This time there are two calls to Abort: one since the test didn't 1121d201456903f3ecae1f7794edfab0d5678e64226shiqian // die, and another from the ReturnSentinel when it's destroyed. The 1122d201456903f3ecae1f7794edfab0d5678e64226shiqian // sentinel normally isn't destroyed if a test doesn't die, since 1123019d19af978f05b774407e0d46a3bda2c18c67c6shiqian // _exit(2) is called in that case by ForkingDeathTest, but not by 1124d201456903f3ecae1f7794edfab0d5678e64226shiqian // our MockDeathTest. 1125f8c44a0ae449dd78d703e94c295287d051560217kosak ASSERT_EQ(2U, factory_->AbortCalls()); 1126d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, 1127d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->AbortArgument(0)); 1128d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 1129d201456903f3ecae1f7794edfab0d5678e64226shiqian factory_->AbortArgument(1)); 1130d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(factory_->TestDeleted()); 1131d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1132d201456903f3ecae1f7794edfab0d5678e64226shiqian 1133d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a successful death test does not register a successful 1134d201456903f3ecae1f7794edfab0d5678e64226shiqian// test part. 1135d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessRegistrationDeathTest, NoSuccessPart) { 1136019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), ""); 1137c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 1138d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1139d201456903f3ecae1f7794edfab0d5678e64226shiqian 1140d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsDeathTest, DeathTest) { 1141019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(1), "") << "unexpected failure"; 1142019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_DEATH(_exit(1), "") << "unexpected failure"; 1143d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1144019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_DEATH(_exit(0), "") << "expected failure"; 1145d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "expected failure"); 1146d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1147019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_DEATH(_exit(0), "") << "expected failure"; 1148d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "expected failure"); 1149d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1150d201456903f3ecae1f7794edfab0d5678e64226shiqian 11512c0fc6d415343b732a4ae39cce1458be1170b9f6zhanyong.wan// Tests that GetLastErrnoDescription returns an empty string when the 11524984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan// last error is 0 and non-empty string when it is non-zero. 11532c0fc6d415343b732a4ae39cce1458be1170b9f6zhanyong.wanTEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) { 11544984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan errno = ENOENT; 11552c0fc6d415343b732a4ae39cce1458be1170b9f6zhanyong.wan EXPECT_STRNE("", GetLastErrnoDescription().c_str()); 11564984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan errno = 0; 11572c0fc6d415343b732a4ae39cce1458be1170b9f6zhanyong.wan EXPECT_STREQ("", GetLastErrnoDescription().c_str()); 11584984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 11594984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 1160ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 11614984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(AutoHandleTest, AutoHandleWorks) { 11624984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 11634984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ASSERT_NE(INVALID_HANDLE_VALUE, handle); 11644984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 11654984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Tests that the AutoHandle is correctly initialized with a handle. 11664984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan testing::internal::AutoHandle auto_handle(handle); 11674984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(handle, auto_handle.Get()); 11684984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 11694984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Tests that Reset assigns INVALID_HANDLE_VALUE. 11704984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Note that this cannot verify whether the original handle is closed. 11714984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan auto_handle.Reset(); 11724984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get()); 11734984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 11744984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Tests that Reset assigns the new handle. 11754984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Note that this cannot verify whether the original handle is closed. 11764984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 11774984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ASSERT_NE(INVALID_HANDLE_VALUE, handle); 11784984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan auto_handle.Reset(handle); 11794984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(handle, auto_handle.Get()); 11804984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 11814984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default. 11824984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan testing::internal::AutoHandle auto_handle2; 11834984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get()); 11844984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 1185ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 11864984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 1187ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 11884984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wantypedef unsigned __int64 BiggestParsable; 11894984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wantypedef signed __int64 BiggestSignedParsable; 1190ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 11914984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wantypedef unsigned long long BiggestParsable; 11924984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wantypedef signed long long BiggestSignedParsable; 1193ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 11944984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 11952d3543f81d6d4583332f8b60768ade18e0f96220zhanyong.wan// We cannot use std::numeric_limits<T>::max() as it clashes with the 11962d3543f81d6d4583332f8b60768ade18e0f96220zhanyong.wan// max() macro defined by <windows.h>. 11972d3543f81d6d4583332f8b60768ade18e0f96220zhanyong.wanconst BiggestParsable kBiggestParsableMax = ULLONG_MAX; 11982d3543f81d6d4583332f8b60768ade18e0f96220zhanyong.wanconst BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX; 11992d3543f81d6d4583332f8b60768ade18e0f96220zhanyong.wan 12004984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ParseNaturalNumberTest, RejectsInvalidFormat) { 12014984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan BiggestParsable result = 0; 12024984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12034984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Rejects non-numbers. 120487fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber("non-number string", &result)); 12054984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12064984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Rejects numbers with whitespace prefix. 120787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber(" 123", &result)); 12084984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12094984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Rejects negative numbers. 121087fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber("-123", &result)); 12114984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12124984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Rejects numbers starting with a plus sign. 121387fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber("+123", &result)); 12144984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan errno = 0; 12154984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 12164984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12174984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ParseNaturalNumberTest, RejectsOverflownNumbers) { 12184984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan BiggestParsable result = 0; 12194984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 122087fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result)); 12214984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12224984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan signed char char_result = 0; 122387fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(ParseNaturalNumber("200", &char_result)); 12244984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan errno = 0; 12254984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 12264984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12274984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ParseNaturalNumberTest, AcceptsValidNumbers) { 12284984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan BiggestParsable result = 0; 12294984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12304984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan result = 0; 123187fdda2cf24d953f3cbec1e0c266b2db9928f406jgm ASSERT_TRUE(ParseNaturalNumber("123", &result)); 123216b9431ae01d83de80db7ef3e411d9771ee845e4zhanyong.wan EXPECT_EQ(123U, result); 12334984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12344984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // Check 0 as an edge case. 12354984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan result = 1; 123687fdda2cf24d953f3cbec1e0c266b2db9928f406jgm ASSERT_TRUE(ParseNaturalNumber("0", &result)); 123716b9431ae01d83de80db7ef3e411d9771ee845e4zhanyong.wan EXPECT_EQ(0U, result); 12384984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12394984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan result = 1; 124087fdda2cf24d953f3cbec1e0c266b2db9928f406jgm ASSERT_TRUE(ParseNaturalNumber("00000", &result)); 124116b9431ae01d83de80db7ef3e411d9771ee845e4zhanyong.wan EXPECT_EQ(0U, result); 12424984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 12434984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12444984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ParseNaturalNumberTest, AcceptsTypeLimits) { 12454984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan Message msg; 12464984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan msg << kBiggestParsableMax; 12474984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12484984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan BiggestParsable result = 0; 12494984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result)); 12504984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(kBiggestParsableMax, result); 12514984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12524984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan Message msg2; 12534984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan msg2 << kBiggestSignedParsableMax; 12544984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12554984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan BiggestSignedParsable signed_result = 0; 12564984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result)); 12574984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(kBiggestSignedParsableMax, signed_result); 12584984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12594984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan Message msg3; 12604984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan msg3 << INT_MAX; 12614984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12624984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan int int_result = 0; 12634984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result)); 12644984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(INT_MAX, int_result); 12654984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12664984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan Message msg4; 12674984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan msg4 << UINT_MAX; 12684984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12694984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan unsigned int uint_result = 0; 12704984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result)); 12714984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(UINT_MAX, uint_result); 12724984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 12734984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12744984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(ParseNaturalNumberTest, WorksForShorterIntegers) { 12754984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan short short_result = 0; 127687fdda2cf24d953f3cbec1e0c266b2db9928f406jgm ASSERT_TRUE(ParseNaturalNumber("123", &short_result)); 12774984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(123, short_result); 12784984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 12794984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan signed char char_result = 0; 128087fdda2cf24d953f3cbec1e0c266b2db9928f406jgm ASSERT_TRUE(ParseNaturalNumber("123", &char_result)); 12814984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan EXPECT_EQ(123, char_result); 12824984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 12834984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 1284ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS 12854984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wanTEST(EnvironmentTest, HandleFitsIntoSizeT) { 12864984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // TODO(vladl@google.com): Remove this test after this condition is verified 12874984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // in a static assertion in gtest-death-test.cc in the function 12884984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan // GetStatusFileDescriptor. 12894984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t)); 12904984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan} 1291ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS 12924984c93490eeeb7d3d1979b30a39a21cad07cba5zhanyong.wan 1293ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger 1294ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan// failures when death tests are available on the system. 1295ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wanTEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) { 1296172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"), 1297172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev "death inside CondDeathTestExpectMacro"); 1298172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"), 1299172b233a0477f82a5bc2b6d15f0647db1cfe5a1evladlosev "death inside CondDeathTestAssertMacro"); 1300ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 1301ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan // Empty statement will not crash, which must trigger a failure. 1302ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), ""); 1303ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), ""); 1304ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan} 1305ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 13068120f66c3249e253f03fdb48bee7e528bc038d31billydonahueTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) { 13078120f66c3249e253f03fdb48bee7e528bc038d31billydonahue testing::GTEST_FLAG(death_test_style) = "fast"; 13088120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_FALSE(InDeathTestChild()); 13098120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_DEATH({ 13108120f66c3249e253f03fdb48bee7e528bc038d31billydonahue fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 13118120f66c3249e253f03fdb48bee7e528bc038d31billydonahue fflush(stderr); 13128120f66c3249e253f03fdb48bee7e528bc038d31billydonahue _exit(1); 13138120f66c3249e253f03fdb48bee7e528bc038d31billydonahue }, "Inside"); 13148120f66c3249e253f03fdb48bee7e528bc038d31billydonahue} 13158120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 13168120f66c3249e253f03fdb48bee7e528bc038d31billydonahueTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) { 13178120f66c3249e253f03fdb48bee7e528bc038d31billydonahue testing::GTEST_FLAG(death_test_style) = "threadsafe"; 13188120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_FALSE(InDeathTestChild()); 13198120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_DEATH({ 13208120f66c3249e253f03fdb48bee7e528bc038d31billydonahue fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 13218120f66c3249e253f03fdb48bee7e528bc038d31billydonahue fflush(stderr); 13228120f66c3249e253f03fdb48bee7e528bc038d31billydonahue _exit(1); 13238120f66c3249e253f03fdb48bee7e528bc038d31billydonahue }, "Inside"); 13248120f66c3249e253f03fdb48bee7e528bc038d31billydonahue} 13258120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 13268120f66c3249e253f03fdb48bee7e528bc038d31billydonahue#else // !GTEST_HAS_DEATH_TEST follows 1327ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 1328ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wanusing testing::internal::CaptureStderr; 1329ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wanusing testing::internal::GetCapturedStderr; 1330ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 1331ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still 1332b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// defined but do not trigger failures when death tests are not available on 1333ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan// the system. 1334ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wanTEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) { 1335ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan // Empty statement will not crash, but that should not trigger a failure 1336ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan // when death tests are not supported. 1337ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan CaptureStderr(); 1338ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(;, ""); 133987fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::string output = GetCapturedStderr(); 1340ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan ASSERT_TRUE(NULL != strstr(output.c_str(), 1341ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan "Death tests are not supported on this platform")); 1342ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 1343ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 1344b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan // The streamed message should not be printed as there is no test failure. 1345ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan CaptureStderr(); 1346b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; 1347b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan output = GetCapturedStderr(); 1348b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 1349b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1350b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan CaptureStderr(); 1351b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(;, ""); // NOLINT 1352ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan output = GetCapturedStderr(); 1353ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan ASSERT_TRUE(NULL != strstr(output.c_str(), 1354ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan "Death tests are not supported on this platform")); 1355ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 1356b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1357b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan CaptureStderr(); 1358b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; // NOLINT 1359b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan output = GetCapturedStderr(); 1360b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 1361ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan} 1362ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan 1363b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wanvoid FuncWithAssert(int* n) { 1364b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(return;, ""); 1365b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan (*n)++; 1366b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan} 1367b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1368b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current 1369b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// function (as ASSERT_DEATH does) if death tests are not supported. 1370b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wanTEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) { 1371b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan int n = 0; 1372b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan FuncWithAssert(&n); 1373b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_EQ(1, n); 1374b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan} 137581ddb8434f2b034f49d24b07c03c80a70d116404zhanyong.wan 13768120f66c3249e253f03fdb48bee7e528bc038d31billydonahue#endif // !GTEST_HAS_DEATH_TEST 1377d201456903f3ecae1f7794edfab0d5678e64226shiqian 1378b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// Tests that the death test macros expand to code which may or may not 1379b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// be followed by operator<<, and that in either case the complete text 1380b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// comprises only a single C++ statement. 1381b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// 1382b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// The syntax should work whether death tests are available or not. 1383b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wanTEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) { 1384f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 1385b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan // This would fail if executed; this is a compilation test only 1386b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(return, ""); 1387b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1388f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 1389b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(_exit(1), ""); 1390b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan else 1391b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan // This empty "else" branch is meant to ensure that EXPECT_DEATH 1392b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan // doesn't expand into an "if" statement without an "else" 1393b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ; // NOLINT 1394b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1395f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 1396b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die"; 1397b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1398f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 1399b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ; // NOLINT 1400b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan else 1401b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3; 1402b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan} 1403b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1404b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// Tests that conditional death test macros expand to code which interacts 1405b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan// well with switch statements. 1406b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wanTEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) { 14078120f66c3249e253f03fdb48bee7e528bc038d31billydonahue // Microsoft compiler usually complains about switch statements without 14088120f66c3249e253f03fdb48bee7e528bc038d31billydonahue // case labels. We suppress that warning for this test. 14098120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065) 1410b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1411b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan switch (0) 1412b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan default: 1413b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") 1414b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan << "exit in default switch handler"; 1415b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1416b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan switch (0) 1417b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan case 0: 1418b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case"; 1419b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 14208120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_POP_() 1421b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan} 1422b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan 1423d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a test case whose name ends with "DeathTest" works fine 1424d201456903f3ecae1f7794edfab0d5678e64226shiqian// on Windows. 1425d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NotADeathTest, Test) { 1426d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 1427d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1428