111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Copyright 2005, Google Inc. 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// All rights reserved. 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Redistribution and use in source and binary forms, with or without 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// modification, are permitted provided that the following conditions are 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// met: 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions of source code must retain the above copyright 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// notice, this list of conditions and the following disclaimer. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions in binary form must reproduce the above 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// copyright notice, this list of conditions and the following disclaimer 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in the documentation and/or other materials provided with the 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// distribution. 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Neither the name of Google Inc. nor the names of its 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// contributors may be used to endorse or promote products derived from 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// this software without specific prior written permission. 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Author: wan@google.com (Zhanyong Wan) 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for death tests. 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest-death-test.h" 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest.h" 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/internal/gtest-filepath.h" 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AlwaysFalse; 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AlwaysTrue; 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_DEATH_TEST 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <direct.h> // For chdir(). 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <unistd.h> 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <sys/wait.h> // For waitpid. 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <limits> // For std::numeric_limits. 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <limits.h> 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <signal.h> 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stdio.h> 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <sys/time.h> 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include "gtest/gtest-spi.h" 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Indicates that this translation unit is part of Google Test's 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implementation. It must come before gtest-internal-inl.h is 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// included, or there will be a compiler error. This trick is to 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// prevent a user from accidentally including gtest-internal-inl.h in 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// his code. 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define GTEST_IMPLEMENTATION_ 1 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include "src/gtest-internal-inl.h" 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# undef GTEST_IMPLEMENTATION_ 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace posix = ::testing::internal::posix; 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::Message; 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::DeathTest; 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::DeathTestFactory; 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::FilePath; 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetLastErrnoDescription; 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetUnitTestImpl; 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::InDeathTestChild; 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ParseNaturalNumber; 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace internal { 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A helper class whose objects replace the death test factory for a 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// single UnitTest object during their lifetimes. 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ReplaceDeathTestFactory { 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory) 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : unit_test_impl_(GetUnitTestImpl()) { 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert old_factory_ = unit_test_impl_->death_test_factory_.release(); 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_impl_->death_test_factory_.reset(new_factory); 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~ReplaceDeathTestFactory() { 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_impl_->death_test_factory_.release(); 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_impl_->death_test_factory_.reset(old_factory_); 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Prevents copying ReplaceDeathTestFactory objects. 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ReplaceDeathTestFactory(const ReplaceDeathTestFactory&); 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const ReplaceDeathTestFactory&); 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestImpl* unit_test_impl_; 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTestFactory* old_factory_; 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace internal 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DieWithMessage(const ::std::string& message) { 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fprintf(stderr, "%s", message.c_str()); 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stderr); // Make sure the text is printed before the process exits. 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We call _exit() instead of exit(), as the former is a direct 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // system call and thus safer in the presence of threads. exit() 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // will invoke user-defined exit-hooks, which may do dangerous 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // things that conflict with death tests. 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some compilers can recognize that _exit() never returns and issue the 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 'unreachable code' warning for code following this function, unless 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fooled by a fake condition. 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(1); 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DieInside(const ::std::string& function) { 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieWithMessage("death inside " + function + "()."); 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death tests work. 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestForDeathTest : public testing::Test { 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {} 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~TestForDeathTest() { 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert posix::ChDir(original_dir_.c_str()); 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A static member function that's expected to die. 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void StaticMemberFunction() { DieInside("StaticMemberFunction"); } 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A method of the test fixture that may die. 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void MemberFunction() { 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (should_die_) 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("MemberFunction"); 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // True iff MemberFunction() should die. 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool should_die_; 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const FilePath original_dir_; 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A class with a member function that may die. 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MayDie { 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit MayDie(bool should_die) : should_die_(should_die) {} 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A member function that may die. 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void MemberFunction() const { 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (should_die_) 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("MayDie::MemberFunction"); 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // True iff MemberFunction() should die. 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool should_die_; 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A global function that's expected to die. 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid GlobalFunction() { DieInside("GlobalFunction"); } 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A non-void function that's expected to die. 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint NonVoidFunction() { 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("NonVoidFunction"); 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return 1; 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A unary function that may die. 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DieIf(bool should_die) { 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (should_die) 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("DieIf"); 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A binary function that may die. 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool DieIfLessThan(int x, int y) { 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (x < y) { 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("DieIfLessThan"); 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DeathTestSubroutine() { 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Death in dbg, not opt. 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint DieInDebugElse12(int* sideeffect) { 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (sideeffect) *sideeffect = 12; 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef NDEBUG 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieInside("DieInDebugElse12"); 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // NDEBUG 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return 12; 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the ExitedWithCode predicate. 21511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExitStatusPredicateTest, ExitedWithCode) { 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // On Windows, the process's exit code is the same as its exit status, 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // so the predicate just compares the its input with its parameter. 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(testing::ExitedWithCode(0)(0)); 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(testing::ExitedWithCode(1)(1)); 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(testing::ExitedWithCode(42)(42)); 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(testing::ExitedWithCode(0)(1)); 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(testing::ExitedWithCode(1)(0)); 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the exit status of a process that calls _exit(2) with a 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// given exit code. This is a helper function for the 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ExitStatusPredicateTest test suite. 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic int NormalExitStatus(int exit_code) { 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pid_t child_pid = fork(); 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (child_pid == 0) { 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(exit_code); 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int status; 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert waitpid(child_pid, &status, 0); 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return status; 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns the exit status of a process that raises a given signal. 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// If the signal does not cause the process to die, then it returns 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// instead the exit status of a process that exits normally with exit 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// code 1. This is a helper function for the ExitStatusPredicateTest 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// test suite. 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic int KilledExitStatus(int signum) { 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pid_t child_pid = fork(); 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (child_pid == 0) { 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert raise(signum); 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(1); 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int status; 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert waitpid(child_pid, &status, 0); 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return status; 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the ExitedWithCode predicate. 25711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExitStatusPredicateTest, ExitedWithCode) { 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status0 = NormalExitStatus(0); 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status1 = NormalExitStatus(1); 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status42 = NormalExitStatus(42); 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::ExitedWithCode pred0(0); 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::ExitedWithCode pred1(1); 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::ExitedWithCode pred42(42); 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(pred0, status0); 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(pred1, status1); 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(pred42, status42); 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(pred0(status1)); 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(pred42(status0)); 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(pred1(status42)); 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the KilledBySignal predicate. 27311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExitStatusPredicateTest, KilledBySignal) { 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status_segv = KilledExitStatus(SIGSEGV); 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status_kill = KilledExitStatus(SIGKILL); 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::KilledBySignal pred_segv(SIGSEGV); 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::KilledBySignal pred_kill(SIGKILL); 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(pred_segv, status_segv); 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(pred_kill, status_kill); 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(pred_segv(status_kill)); 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(pred_kill(status_segv)); 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the death test macros expand to code which may or may not 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be followed by operator<<, and that in either case the complete text 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// comprises only a single C++ statement. 28911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, SingleStatement) { 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This would fail if executed; this is a compilation test only 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(return, ""); 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This empty "else" branch is meant to ensure that EXPECT_DEATH 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // doesn't expand into an "if" statement without an "else" 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(return, "") << "did not die"; 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3; 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DieWithEmbeddedNul() { 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fprintf(stderr, "Hello%cmy null world.\n", '\0'); 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stderr); 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(1); 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_USES_PCRE 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// message has a NUL character in it. 31911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, EmbeddedNulInMessage) { 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TODO(wan@google.com): <regex.h> doesn't support matching strings 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // with embedded NUL characters - find a way to workaround it. 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieWithEmbeddedNul(), "my null world"); 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(DieWithEmbeddedNul(), "my null world"); 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_USES_PCRE 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death test macros expand to code which interacts well with switch 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// statements. 32911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, SwitchStatement) { 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Microsoft compiler usually complains about switch statements without 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// case labels. We suppress that warning for this test. 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef _MSC_VER 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(push) 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(disable: 4065) 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _MSC_VER 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(1), "") << "exit in default switch handler"; 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 0: 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), "") << "exit in switch case"; 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef _MSC_VER 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(pop) 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _MSC_VER 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a static member function can be used in a "fast" style 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// death test. 35211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) { 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a method of the test fixture can be used in a "fast" 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// style death test. 35911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, MemberFunctionFastStyle) { 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert should_die_ = true; 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); } 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death tests work even if the current directory has been 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// changed. 36911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, FastDeathTestInChangedDir) { 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ChangeToRootDir(); 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ChangeToRootDir(); 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(1), ""); 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid SigprofAction(int, siginfo_t*, void*) { /* no op */ } 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms). 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid SetSigprofActionAndTimer() { 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct itimerval timer; 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_interval.tv_sec = 0; 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_interval.tv_usec = 1; 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_value = timer.it_interval; 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct sigaction signal_action; 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert memset(&signal_action, 0, sizeof(signal_action)); 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sigemptyset(&signal_action.sa_mask); 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert signal_action.sa_sigaction = SigprofAction; 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert signal_action.sa_flags = SA_RESTART | SA_SIGINFO; 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL)); 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Disables ITIMER_PROF timer and ignores SIGPROF signal. 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DisableSigprofActionAndTimer(struct sigaction* old_signal_action) { 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct itimerval timer; 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_interval.tv_sec = 0; 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_interval.tv_usec = 0; 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert timer.it_value = timer.it_interval; 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct sigaction signal_action; 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert memset(&signal_action, 0, sizeof(signal_action)); 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sigemptyset(&signal_action.sa_mask); 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert signal_action.sa_handler = SIG_IGN; 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action)); 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death tests work when SIGPROF handler and timer are set. 41211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, FastSigprofActionSet) { 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetSigprofActionAndTimer(); 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct sigaction old_signal_action; 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DisableSigprofActionAndTimer(&old_signal_action); 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) { 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetSigprofActionAndTimer(); 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct sigaction old_signal_action; 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DisableSigprofActionAndTimer(&old_signal_action); 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Repeats a representative sample of death tests in the "threadsafe" style: 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) { 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) { 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert should_die_ = true; 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) { 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < 3; ++i) 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i; 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) { 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ChangeToRootDir(); 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ChangeToRootDir(); 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(1), ""); 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, MixedStyles) { 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace { 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool pthread_flag; 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid SetPthreadFlag() { 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_flag = true; 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) { 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!testing::GTEST_FLAG(death_test_use_fork)) { 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pthread_flag = false; 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL)); 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(1), ""); 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(pthread_flag); 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a method of another class can be used in a death test. 49311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, MethodOfAnotherClass) { 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const MayDie x(true); 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction"); 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a global function can be used in a death test. 49911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, GlobalFunction) { 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), "GlobalFunction"); 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that any value convertible to an RE works as a second 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument to EXPECT_DEATH. 50511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) { 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char regex_c_str[] = "GlobalFunction"; 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), regex_c_str); 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const testing::internal::RE regex(regex_c_str); 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), regex); 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_HAS_GLOBAL_STRING 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const string regex_str(regex_c_str); 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), regex_str); 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_HAS_GLOBAL_STRING 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::std::string regex_std_str(regex_c_str); 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(GlobalFunction(), regex_std_str); 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a non-void function can be used in a death test. 52411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, NonVoidFunction) { 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction"); 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that functions that take parameter(s) can be used in a death test. 52911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, FunctionWithParameter) { 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIf(true), "DieIf\\(\\)"); 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan"); 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 53511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, OutsideFixture) { 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTestSubroutine(); 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death tests can be done inside a loop. 54011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, InsideLoop) { 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < 5; i++) { 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i; 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a compound statement can be used in a death test. 54711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, CompoundStatement) { 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH({ // NOLINT 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int x = 2; 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int y = x + 1; 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DieIfLessThan(x, y); 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "DieIfLessThan"); 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that code that doesn't die causes a death test to fail. 55711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DoesNotDie) { 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"), 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "failed to die"); 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a death test fails when the error message isn't expected. 56311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ErrorMessageMismatch) { 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message."; 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "died but not with expected error"); 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// On exit, *aborted will be true iff the EXPECT_DEATH() statement 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// aborted the function. 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectDeathTestHelper(bool* aborted) { 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = true; 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = false; 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEATH doesn't abort the test on failure. 57811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, EXPECT_DEATH) { 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool aborted = true; 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted), 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "failed to die"); 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(aborted); 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEATH does abort the test on failure. 58611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ASSERT_DEATH) { 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool aborted; 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert aborted = true; 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert aborted = false; 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "failed to die"); 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(aborted); 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEATH evaluates the arguments exactly once. 59711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, SingleEvaluation) { 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int x = 3; 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIf((++x) == 4), "DieIf"); 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* regex = "DieIf"; 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* regex_save = regex; 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieIfLessThan(3, 4), regex++); 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(regex_save + 1, regex); 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that run-away death tests are reported as failures. 60811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, RunawayIsFailure) { 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"), 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "failed to die."); 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that death tests report executing 'return' in the statement as 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// failure. 61511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ReturnIsFailure) { 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"), 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "illegal return in test statement."); 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// message to it, and in debug mode it: 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1. Asserts on death. 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 2. Has no side effect. 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// And in opt mode, it: 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1. Has side effects but does not assert. 62711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, TestExpectDebugDeath) { 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int sideeffect = 0; 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Must accept a streamed message"; 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef NDEBUG 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Checks that the assignment occurs in opt mode (sideeffect). 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(12, sideeffect); 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Checks that the assignment does not occur in dbg mode (no sideeffect). 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, sideeffect); 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// message to it, and in debug mode it: 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1. Asserts on death. 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 2. Has no side effect. 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// And in opt mode, it: 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1. Has side effects but does not assert. 65311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, TestAssertDebugDeath) { 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int sideeffect = 0; 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Must accept a streamed message"; 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef NDEBUG 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Checks that the assignment occurs in opt mode (sideeffect). 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(12, sideeffect); 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Checks that the assignment does not occur in dbg mode (no sideeffect). 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, sideeffect); 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef NDEBUG 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectDebugDeathHelper(bool* aborted) { 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = true; 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail."; 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = false; 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 68111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) { 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("This test should be considered failing if it shows " 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "any pop-up dialogs.\n"); 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stdout); 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH({ 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(catch_exceptions) = false; 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert abort(); 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the function. 69511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) { 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool aborted = true; 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), ""); 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(aborted); 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid AssertDebugDeathHelper(bool* aborted) { 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = true; 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEBUG_DEATH(return, "") << "This is expected to fail."; 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = false; 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// failure. 70911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, AssertDebugDeathAborts) { 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool aborted; 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert aborted = false; 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(aborted); 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // _NDEBUG 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the *_EXIT family of macros, using a variety of predicates. 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void TestExitMacros() { 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), ""); 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Of all signals effects on the process exit code, only those of SIGABRT 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // are documented on Windows. 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx. 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar"; 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo"; 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar"; 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "") 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is expected, too."; 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected, too."); 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "") 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is expected."; 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ExitMacros) { 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestExitMacros(); 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, ExitMacrosUsingFork) { 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_use_fork) = true; 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestExitMacros(); 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, InvalidStyle) { 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "rococo"; 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(0), "") << "This failure is expected."; 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DeathTestFailedOutput) { 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieWithMessage("death\n"), 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected message"), 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Actual msg:\n" 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] death\n"); 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) { 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH({ 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fprintf(stderr, "returning\n"); 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stderr); 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""), 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Result: illegal return in test statement.\n" 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Error msg:\n" 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] returning\n"); 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) { 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"), 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::ExitedWithCode(3), 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected message"), 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Result: died but not with expected exit code:\n" 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Exited with exit status 1\n" 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Actual msg:\n" 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] exiting with rc 1\n"); 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) { 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "line 1\nxyz\nline 3\n"), 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Actual msg:\n" 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] line 1\n" 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] line 2\n" 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "[ DEATH ] line 3\n"); 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) { 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "line 1\nline 2\nline 3\n"); 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A DeathTestFactory that returns MockDeathTests. 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MockDeathTestFactory : public DeathTestFactory { 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MockDeathTestFactory(); 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual bool Create(const char* statement, 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::testing::internal::RE* regex, 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* file, int line, DeathTest** test); 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sets the parameters for subsequent calls to Create. 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void SetParameters(bool create, DeathTest::TestRole role, 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int status, bool passed); 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Accessors. 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int AssumeRoleCalls() const { return assume_role_calls_; } 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int WaitCalls() const { return wait_calls_; } 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int PassedCalls() const { return passed_args_.size(); } 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool PassedArgument(int n) const { return passed_args_[n]; } 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int AbortCalls() const { return abort_args_.size(); } 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTest::AbortReason AbortArgument(int n) const { 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return abort_args_[n]; 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool TestDeleted() const { return test_deleted_; } 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class MockDeathTest; 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If true, Create will return a MockDeathTest; otherwise it returns 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // NULL. 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool create_; 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The value a MockDeathTest will return from its AssumeRole method. 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTest::TestRole role_; 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The value a MockDeathTest will return from its Wait method. 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int status_; 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The value a MockDeathTest will return from its Passed method. 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool passed_; 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Number of times AssumeRole was called. 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int assume_role_calls_; 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Number of times Wait was called. 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int wait_calls_; 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The arguments to the calls to Passed since the last call to 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // SetParameters. 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<bool> passed_args_; 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The arguments to the calls to Abort since the last call to 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // SetParameters. 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<DeathTest::AbortReason> abort_args_; 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // True if the last MockDeathTest returned by Create has been 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // deleted. 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool test_deleted_; 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A DeathTest implementation useful in testing. It returns values set 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// at its creation from its various inherited DeathTest methods, and 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// reports calls to those methods to its parent MockDeathTestFactory 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// object. 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MockDeathTest : public DeathTest { 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MockDeathTest(MockDeathTestFactory *parent, 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestRole role, int status, bool passed) : 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert parent_(parent), role_(role), status_(status), passed_(passed) { 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~MockDeathTest() { 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert parent_->test_deleted_ = true; 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual TestRole AssumeRole() { 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++parent_->assume_role_calls_; 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return role_; 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual int Wait() { 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++parent_->wait_calls_; 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return status_; 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual bool Passed(bool exit_status_ok) { 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert parent_->passed_args_.push_back(exit_status_ok); 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return passed_; 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Abort(AbortReason reason) { 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert parent_->abort_args_.push_back(reason); 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MockDeathTestFactory* const parent_; 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestRole role_; 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int status_; 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool passed_; 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MockDeathTestFactory constructor. 90411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertMockDeathTestFactory::MockDeathTestFactory() 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : create_(true), 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert role_(DeathTest::OVERSEE_TEST), 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert status_(0), 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert passed_(true), 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assume_role_calls_(0), 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wait_calls_(0), 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert passed_args_(), 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert abort_args_() { 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sets the parameters for subsequent calls to Create. 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid MockDeathTestFactory::SetParameters(bool create, 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTest::TestRole role, 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int status, bool passed) { 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert create_ = create; 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert role_ = role; 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert status_ = status; 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert passed_ = passed; 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assume_role_calls_ = 0; 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wait_calls_ = 0; 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert passed_args_.clear(); 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert abort_args_.clear(); 92911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sets test to NULL (if create_ is false) or to the address of a new 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// MockDeathTest object with parameters taken from the last call 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// to SetParameters (if create_ is true). Always returns true. 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool MockDeathTestFactory::Create(const char* /*statement*/, 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::testing::internal::RE* /*regex*/, 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* /*file*/, 93811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int /*line*/, 93911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DeathTest** test) { 94011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_deleted_ = false; 94111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (create_) { 94211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *test = new MockDeathTest(this, role_, status_, passed_); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 94411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *test = NULL; 94511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 94611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 94711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 94811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro. 95011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// It installs a MockDeathTestFactory that is used for the duration 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of the test case. 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MacroLogicDeathTest : public testing::Test { 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static testing::internal::ReplaceDeathTestFactory* replacer_; 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static MockDeathTestFactory* factory_; 95611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_ = new MockDeathTestFactory; 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_); 96011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TearDownTestCase() { 96311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete replacer_; 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert replacer_ = NULL; 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete factory_; 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_ = NULL; 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Runs a death test that breaks the rules by returning. Such a death 97011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test cannot be run directly from a test routine that uses a 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // MockDeathTest, or the remainder of the routine will not be executed. 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void RunReturningDeathTest(bool* flag) { 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH({ // NOLINT 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *flag = true; 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 97911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttesting::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert = NULL; 98211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertMockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL; 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Test that nothing happens when the factory doesn't return a DeathTest: 98611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(MacroLogicDeathTest, NothingHappens) { 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool flag = false; 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true); 98911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(flag = true, ""); 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(flag); 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->AssumeRoleCalls()); 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->WaitCalls()); 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->PassedCalls()); 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->AbortCalls()); 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(factory_->TestDeleted()); 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Test that the parent process doesn't run the death test code, 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and that the Passed method returns false when the (simulated) 100011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// child process exits with status 0: 100111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) { 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool flag = false; 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true); 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(flag = true, ""); 100511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(flag); 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->AssumeRoleCalls()); 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->WaitCalls()); 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, factory_->PassedCalls()); 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(factory_->PassedArgument(0)); 101011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->AbortCalls()); 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(factory_->TestDeleted()); 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the Passed method was given the argument "true" when 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the (simulated) child process exits with status 1: 101611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) { 101711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool flag = false; 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true); 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(flag = true, ""); 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(flag); 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->AssumeRoleCalls()); 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->WaitCalls()); 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, factory_->PassedCalls()); 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(factory_->PassedArgument(0)); 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->AbortCalls()); 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(factory_->TestDeleted()); 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the (simulated) child process executes the death test 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// code, and is aborted with the correct AbortReason if it 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// executes a return statement. 103211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(MacroLogicDeathTest, ChildPerformsReturn) { 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool flag = false; 103411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RunReturningDeathTest(&flag); 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(flag); 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->AssumeRoleCalls()); 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->WaitCalls()); 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->PassedCalls()); 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->AbortCalls()); 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->AbortArgument(0)); 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(factory_->TestDeleted()); 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the (simulated) child process is aborted with the 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// correct AbortReason if it does not die. 104811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(MacroLogicDeathTest, ChildDoesNotDie) { 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool flag = false; 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(flag = true, ""); 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(flag); 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, factory_->AssumeRoleCalls()); 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->WaitCalls()); 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, factory_->PassedCalls()); 105611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This time there are two calls to Abort: one since the test didn't 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // die, and another from the ReturnSentinel when it's destroyed. The 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // sentinel normally isn't destroyed if a test doesn't die, since 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // _exit(2) is called in that case by ForkingDeathTest, but not by 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // our MockDeathTest. 106111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, factory_->AbortCalls()); 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->AbortArgument(0)); 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert factory_->AbortArgument(1)); 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(factory_->TestDeleted()); 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a successful death test does not register a successful 107011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// test part. 107111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessRegistrationDeathTest, NoSuccessPart) { 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), ""); 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsDeathTest, DeathTest) { 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(1), "") << "unexpected failure"; 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(1), "") << "unexpected failure"; 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH(_exit(0), "") << "expected failure"; 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "expected failure"); 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 108311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH(_exit(0), "") << "expected failure"; 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "expected failure"); 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that GetLastErrnoDescription returns an empty string when the 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// last error is 0 and non-empty string when it is non-zero. 108911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) { 109011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert errno = ENOENT; 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE("", GetLastErrnoDescription().c_str()); 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert errno = 0; 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GetLastErrnoDescription().c_str()); 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 109711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AutoHandleTest, AutoHandleWorks) { 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(INVALID_HANDLE_VALUE, handle); 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that the AutoHandle is correctly initialized with a handle. 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::AutoHandle auto_handle(handle); 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(handle, auto_handle.Get()); 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that Reset assigns INVALID_HANDLE_VALUE. 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Note that this cannot verify whether the original handle is closed. 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert auto_handle.Reset(); 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get()); 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that Reset assigns the new handle. 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Note that this cannot verify whether the original handle is closed. 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(INVALID_HANDLE_VALUE, handle); 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert auto_handle.Reset(handle); 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(handle, auto_handle.Get()); 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default. 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::AutoHandle auto_handle2; 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get()); 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef unsigned __int64 BiggestParsable; 112511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef signed __int64 BiggestSignedParsable; 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst BiggestParsable kBiggestParsableMax = ULLONG_MAX; 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX; 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef unsigned long long BiggestParsable; 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef signed long long BiggestSignedParsable; 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst BiggestParsable kBiggestParsableMax = 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::numeric_limits<BiggestParsable>::max(); 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst BiggestSignedParsable kBiggestSignedParsableMax = 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::numeric_limits<BiggestSignedParsable>::max(); 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseNaturalNumberTest, RejectsInvalidFormat) { 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert BiggestParsable result = 0; 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Rejects non-numbers. 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber("non-number string", &result)); 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Rejects numbers with whitespace prefix. 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber(" 123", &result)); 114511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Rejects negative numbers. 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber("-123", &result)); 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Rejects numbers starting with a plus sign. 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber("+123", &result)); 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert errno = 0; 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseNaturalNumberTest, RejectsOverflownNumbers) { 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert BiggestParsable result = 0; 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result)); 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert signed char char_result = 0; 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseNaturalNumber("200", &char_result)); 116111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert errno = 0; 116211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 116311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseNaturalNumberTest, AcceptsValidNumbers) { 116511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert BiggestParsable result = 0; 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert result = 0; 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ParseNaturalNumber("123", &result)); 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123U, result); 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Check 0 as an edge case. 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert result = 1; 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ParseNaturalNumber("0", &result)); 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0U, result); 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert result = 1; 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ParseNaturalNumber("00000", &result)); 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0U, result); 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseNaturalNumberTest, AcceptsTypeLimits) { 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << kBiggestParsableMax; 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert BiggestParsable result = 0; 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result)); 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kBiggestParsableMax, result); 118811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg2; 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg2 << kBiggestSignedParsableMax; 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert BiggestSignedParsable signed_result = 0; 119311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result)); 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kBiggestSignedParsableMax, signed_result); 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg3; 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg3 << INT_MAX; 119811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int int_result = 0; 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result)); 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(INT_MAX, int_result); 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg4; 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg4 << UINT_MAX; 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned int uint_result = 0; 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result)); 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(UINT_MAX, uint_result); 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseNaturalNumberTest, WorksForShorterIntegers) { 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert short short_result = 0; 121311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ParseNaturalNumber("123", &short_result)); 121411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, short_result); 121511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert signed char char_result = 0; 121711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ParseNaturalNumber("123", &char_result)); 121811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, char_result); 121911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 122011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS 122211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EnvironmentTest, HandleFitsIntoSizeT) { 122311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TODO(vladl@google.com): Remove this test after this condition is verified 122411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // in a static assertion in gtest-death-test.cc in the function 122511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // GetStatusFileDescriptor. 122611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t)); 122711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 122811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS 122911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger 123111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// failures when death tests are available on the system. 123211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) { 123311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"), 123411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "death inside CondDeathTestExpectMacro"); 123511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"), 123611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "death inside CondDeathTestAssertMacro"); 123711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Empty statement will not crash, which must trigger a failure. 123911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), ""); 124011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), ""); 124111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 124211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 124411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CaptureStderr; 124611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetCapturedStderr; 124711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still 124911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// defined but do not trigger failures when death tests are not available on 125011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the system. 125111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) { 125211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Empty statement will not crash, but that should not trigger a failure 125311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // when death tests are not supported. 125411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CaptureStderr(); 125511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(;, ""); 125611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string output = GetCapturedStderr(); 125711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != strstr(output.c_str(), 125811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Death tests are not supported on this platform")); 125911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 126011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The streamed message should not be printed as there is no test failure. 126211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CaptureStderr(); 126311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; 126411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert output = GetCapturedStderr(); 126511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 126611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CaptureStderr(); 126811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(;, ""); // NOLINT 126911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert output = GetCapturedStderr(); 127011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != strstr(output.c_str(), 127111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Death tests are not supported on this platform")); 127211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 127311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CaptureStderr(); 127511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; // NOLINT 127611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert output = GetCapturedStderr(); 127711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 127811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 127911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 128011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid FuncWithAssert(int* n) { 128111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(return;, ""); 128211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*n)++; 128311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 128411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 128511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current 128611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function (as ASSERT_DEATH does) if death tests are not supported. 128711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) { 128811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 128911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FuncWithAssert(&n); 129011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n); 129111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 129211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_DEATH_TEST 129311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the death test macros expand to code which may or may not 129511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be followed by operator<<, and that in either case the complete text 129611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// comprises only a single C++ statement. 129711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 129811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The syntax should work whether death tests are available or not. 129911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) { 130011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 130111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This would fail if executed; this is a compilation test only 130211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(return, ""); 130311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 130511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(_exit(1), ""); 130611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 130711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This empty "else" branch is meant to ensure that EXPECT_DEATH 130811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // doesn't expand into an "if" statement without an "else" 130911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 131011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 131211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die"; 131311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 131511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 131611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 131711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3; 131811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 131911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 132011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that conditional death test macros expand to code which interacts 132111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// well with switch statements. 132211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) { 132311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Microsoft compiler usually complains about switch statements without 132411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// case labels. We suppress that warning for this test. 132511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _MSC_VER 132611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(push) 132711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(disable: 4065) 132811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // _MSC_VER 132911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 133111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 133211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") 133311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "exit in default switch handler"; 133411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 133611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 0: 133711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case"; 133811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _MSC_VER 134011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(pop) 134111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // _MSC_VER 134211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 134311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) { 134511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "fast"; 134611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(InDeathTestChild()); 134711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH({ 134811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 134911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stderr); 135011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(1); 135111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Inside"); 135211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 135311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) { 135511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::GTEST_FLAG(death_test_style) = "threadsafe"; 135611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(InDeathTestChild()); 135711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH({ 135811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 135911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fflush(stderr); 136011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _exit(1); 136111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Inside"); 136211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 136311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a test case whose name ends with "DeathTest" works fine 136511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// on Windows. 136611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NotADeathTest, Test) { 136711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED(); 136811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 1369