1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2005, Google Inc. 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Author: wan@google.com (Zhanyong Wan) 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests for death tests. 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-death-test.h> 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest.h> 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/internal/gtest-filepath.h> 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 38d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleusing testing::internal::AlwaysFalse; 39d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleusing testing::internal::AlwaysTrue; 40d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_DEATH_TEST 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <direct.h> // For chdir(). 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <unistd.h> 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <sys/wait.h> // For waitpid. 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <limits> // For std::numeric_limits. 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <limits.h> 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <signal.h> 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdio.h> 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest-spi.h> 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Indicates that this translation unit is part of Google Test's 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implementation. It must come before gtest-internal-inl.h is 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// included, or there will be a compiler error. This trick is to 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// prevent a user from accidentally including gtest-internal-inl.h in 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// his code. 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_IMPLEMENTATION_ 1 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include "src/gtest-internal-inl.h" 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GTEST_IMPLEMENTATION_ 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace posix = ::testing::internal::posix; 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::Message; 69fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::DeathTest; 70fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::DeathTestFactory; 71fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::FilePath; 72fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::GetLastErrnoDescription; 73fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::GetUnitTestImpl; 74fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::ParseNaturalNumber; 75fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::String; 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace testing { 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A helper class whose objects replace the death test factory for a 81fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// single UnitTest object during their lifetimes. 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass ReplaceDeathTestFactory { 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory) 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : unit_test_impl_(GetUnitTestImpl()) { 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville old_factory_ = unit_test_impl_->death_test_factory_.release(); 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unit_test_impl_->death_test_factory_.reset(new_factory); 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~ReplaceDeathTestFactory() { 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unit_test_impl_->death_test_factory_.release(); 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unit_test_impl_->death_test_factory_.reset(old_factory_); 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Prevents copying ReplaceDeathTestFactory objects. 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ReplaceDeathTestFactory(const ReplaceDeathTestFactory&); 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(const ReplaceDeathTestFactory&); 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville UnitTestImpl* unit_test_impl_; 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTestFactory* old_factory_; 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace testing 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1060ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonvoid DieInside(const char* function) { 1070ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson fprintf(stderr, "death inside %s().", function); 1080ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson fflush(stderr); 1090ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // We call _exit() instead of exit(), as the former is a direct 1100ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // system call and thus safer in the presence of threads. exit() 1110ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // will invoke user-defined exit-hooks, which may do dangerous 1120ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // things that conflict with death tests. 1130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // 1140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // Some compilers can recognize that _exit() never returns and issue the 1150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // 'unreachable code' warning for code following this function, unless 1160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson // fooled by a fake condition. 1170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (AlwaysTrue()) 1180ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson _exit(1); 1190ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson} 1200ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that death tests work. 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestForDeathTest : public testing::Test { 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville protected: 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {} 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~TestForDeathTest() { 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville posix::ChDir(original_dir_.c_str()); 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A static member function that's expected to die. 1320ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson static void StaticMemberFunction() { DieInside("StaticMemberFunction"); } 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A method of the test fixture that may die. 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void MemberFunction() { 1360ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (should_die_) 1370ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("MemberFunction"); 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // True iff MemberFunction() should die. 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_die_; 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const FilePath original_dir_; 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A class with a member function that may die. 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MayDie { 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit MayDie(bool should_die) : should_die_(should_die) {} 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // A member function that may die. 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void MemberFunction() const { 1520ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (should_die_) 1530ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("MayDie::MemberFunction"); 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // True iff MemberFunction() should die. 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool should_die_; 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A global function that's expected to die. 1620ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidsonvoid GlobalFunction() { DieInside("GlobalFunction"); } 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A non-void function that's expected to die. 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleint NonVoidFunction() { 1660ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("NonVoidFunction"); 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return 1; 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A unary function that may die. 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid DieIf(bool should_die) { 1720ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson if (should_die) 1730ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("DieIf"); 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A binary function that may die. 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool DieIfLessThan(int x, int y) { 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (x < y) { 1790ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("DieIfLessThan"); 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return true; 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid DeathTestSubroutine() { 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Death in dbg, not opt. 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleint DieInDebugElse12(int* sideeffect) { 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (sideeffect) *sideeffect = 12; 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef NDEBUG 1940ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson DieInside("DieInDebugElse12"); 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // NDEBUG 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return 12; 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests the ExitedWithCode predicate. 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ExitStatusPredicateTest, ExitedWithCode) { 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // On Windows, the process's exit code is the same as its exit status, 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // so the predicate just compares the its input with its parameter. 205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(testing::ExitedWithCode(0)(0)); 206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(testing::ExitedWithCode(1)(1)); 207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(testing::ExitedWithCode(42)(42)); 208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(testing::ExitedWithCode(0)(1)); 209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(testing::ExitedWithCode(1)(0)); 210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the exit status of a process that calls _exit(2) with a 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// given exit code. This is a helper function for the 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ExitStatusPredicateTest test suite. 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic int NormalExitStatus(int exit_code) { 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville pid_t child_pid = fork(); 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (child_pid == 0) { 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville _exit(exit_code); 221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int status; 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville waitpid(child_pid, &status, 0); 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return status; 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Returns the exit status of a process that raises a given signal. 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the signal does not cause the process to die, then it returns 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instead the exit status of a process that exits normally with exit 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// code 1. This is a helper function for the ExitStatusPredicateTest 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// test suite. 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic int KilledExitStatus(int signum) { 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville pid_t child_pid = fork(); 234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (child_pid == 0) { 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raise(signum); 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville _exit(1); 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int status; 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville waitpid(child_pid, &status, 0); 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return status; 241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests the ExitedWithCode predicate. 244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ExitStatusPredicateTest, ExitedWithCode) { 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status0 = NormalExitStatus(0); 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status1 = NormalExitStatus(1); 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status42 = NormalExitStatus(42); 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::ExitedWithCode pred0(0); 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::ExitedWithCode pred1(1); 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::ExitedWithCode pred42(42); 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED1(pred0, status0); 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED1(pred1, status1); 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED1(pred42, status42); 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(pred0(status1)); 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(pred42(status0)); 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(pred1(status42)); 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests the KilledBySignal predicate. 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ExitStatusPredicateTest, KilledBySignal) { 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status_segv = KilledExitStatus(SIGSEGV); 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status_kill = KilledExitStatus(SIGKILL); 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::KilledBySignal pred_segv(SIGSEGV); 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::KilledBySignal pred_kill(SIGKILL); 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED1(pred_segv, status_segv); 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_PRED1(pred_kill, status_kill); 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(pred_segv(status_kill)); 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(pred_kill(status_segv)); 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the death test macros expand to code which may or may not 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be followed by operator<<, and that in either case the complete text 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// comprises only a single C++ statement. 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, SingleStatement) { 277d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This would fail if executed; this is a compilation test only 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(return, ""); 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 281d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysTrue()) 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), ""); 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville else 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This empty "else" branch is meant to ensure that EXPECT_DEATH 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // doesn't expand into an "if" statement without an "else" 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ; 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 288d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(return, "") << "did not die"; 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 291d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ; 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville else 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3; 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid DieWithEmbeddedNul() { 298d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville fprintf(stderr, "Hello%cmy null world.\n", '\0'); 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville fflush(stderr); 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville _exit(1); 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_USES_PCRE 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// message has a NUL character in it. 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, EmbeddedNulInMessage) { 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TODO(wan@google.com): <regex.h> doesn't support matching strings 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // with embedded NUL characters - find a way to workaround it. 309d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_DEATH(DieWithEmbeddedNul(), "my null world"); 310d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH(DieWithEmbeddedNul(), "my null world"); 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_USES_PCRE 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that death test macros expand to code which interacts well with switch 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// statements. 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, SwitchStatement) { 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Microsoft compiler usually complains about switch statements without 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// case labels. We suppress that warning for this test. 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(push) 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(disable: 4065) 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // _MSC_VER 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville switch (0) 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville default: 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(1), "") << "exit in default switch handler"; 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville switch (0) 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville case 0: 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), "") << "exit in switch case"; 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#pragma warning(pop) 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // _MSC_VER 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a static member function can be used in a "fast" style 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// death test. 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) { 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "fast"; 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a method of the test fixture can be used in a "fast" 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// style death test. 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, MemberFunctionFastStyle) { 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "fast"; 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville should_die_ = true; 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); } 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that death tests work even if the current directory has been 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// changed. 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, FastDeathTestInChangedDir) { 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "fast"; 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ChangeToRootDir(); 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ChangeToRootDir(); 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(1), ""); 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Repeats a representative sample of death tests in the "threadsafe" style: 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) { 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) { 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville should_die_ = true; 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) { 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < 3; ++i) 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i; 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) { 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ChangeToRootDir(); 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ChangeToRootDir(); 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(1), ""); 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, MixedStyles) { 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), ""); 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "fast"; 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), ""); 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace { 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillebool pthread_flag; 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid SetPthreadFlag() { 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville pthread_flag = true; 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 4130ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) { 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (!testing::GTEST_FLAG(death_test_use_fork)) { 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "threadsafe"; 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville pthread_flag = false; 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL)); 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(1), ""); 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(pthread_flag); 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 4250ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson#endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a method of another class can be used in a death test. 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, MethodOfAnotherClass) { 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const MayDie x(true); 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction"); 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a global function can be used in a death test. 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, GlobalFunction) { 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), "GlobalFunction"); 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that any value convertible to an RE works as a second 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// argument to EXPECT_DEATH. 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) { 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static const char regex_c_str[] = "GlobalFunction"; 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), regex_c_str); 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const testing::internal::RE regex(regex_c_str); 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), regex); 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_GLOBAL_STRING 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const string regex_str(regex_c_str); 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), regex_str); 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_GLOBAL_STRING 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::std::string regex_std_str(regex_c_str); 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(GlobalFunction(), regex_std_str); 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a non-void function can be used in a death test. 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, NonVoidFunction) { 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction"); 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that functions that take parameter(s) can be used in a death test. 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, FunctionWithParameter) { 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIf(true), "DieIf\\(\\)"); 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan"); 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, OutsideFixture) { 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTestSubroutine(); 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that death tests can be done inside a loop. 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, InsideLoop) { 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < 5; i++) { 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i; 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a compound statement can be used in a death test. 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, CompoundStatement) { 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH({ // NOLINT 482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int x = 2; 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int y = x + 1; 484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DieIfLessThan(x, y); 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "DieIfLessThan"); 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that code that doesn't die causes a death test to fail. 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, DoesNotDie) { 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"), 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "failed to die"); 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a death test fails when the error message isn't expected. 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ErrorMessageMismatch) { 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE({ // NOLINT 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message."; 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "died but not with expected error"); 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// On exit, *aborted will be true iff the EXPECT_DEATH() statement 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// aborted the function. 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid ExpectDeathTestHelper(bool* aborted) { 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = true; 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = false; 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEATH doesn't abort the test on failure. 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, EXPECT_DEATH) { 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool aborted = true; 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted), 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "failed to die"); 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(aborted); 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ASSERT_DEATH does abort the test on failure. 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ASSERT_DEATH) { 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool aborted; 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE({ // NOLINT 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville aborted = true; 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville aborted = false; 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "failed to die"); 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(aborted); 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEATH evaluates the arguments exactly once. 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, SingleEvaluation) { 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int x = 3; 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIf((++x) == 4), "DieIf"); 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* regex = "DieIf"; 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* regex_save = regex; 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(DieIfLessThan(3, 4), regex++); 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(regex_save + 1, regex); 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that run-away death tests are reported as failures. 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, Runaway) { 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"), 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "failed to die."); 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"), 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "illegal return in test statement."); 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEBUG_DEATH works as expected, 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// that is, in debug mode, it: 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. Asserts on death. 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 2. Has no side effect. 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// And in opt mode, it: 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. Has side effects but does not assert. 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, TestExpectDebugDeath) { 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int sideeffect = 0; 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "death.*DieInDebugElse12"); 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef NDEBUG 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Checks that the assignment occurs in opt mode (sideeffect). 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(12, sideeffect); 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Checks that the assignment does not occur in dbg mode (no sideeffect). 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, sideeffect); 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ASSERT_DEBUG_DEATH works as expected 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In debug mode: 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. Asserts on debug death. 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 2. Has no side effect. 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In opt mode: 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1. Has side effects and returns the expected value (12). 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, TestAssertDebugDeath) { 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int sideeffect = 0; 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEBUG_DEATH({ // NOLINT 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that the return value is 12 in opt mode. 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(12, DieInDebugElse12(&sideeffect)); 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that the side effect occurred in opt mode. 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(12, sideeffect); 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "death.*DieInDebugElse12"); 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef NDEBUG 590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Checks that the assignment occurs in opt mode (sideeffect). 591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(12, sideeffect); 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Checks that the assignment does not occur in dbg mode (no sideeffect). 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, sideeffect); 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef NDEBUG 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid ExpectDebugDeathHelper(bool* aborted) { 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = true; 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail."; 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = false; 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) { 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville printf("This test should be considered failing if it shows " 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "any pop-up dialogs.\n"); 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville fflush(stdout); 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH({ 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(catch_exceptions) = false; 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville abort(); 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, ""); 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(PopUpDeathTest, DoesNotShowPopUpOnThrow) { 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville printf("This test should be considered failing if it shows " 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "any pop-up dialogs.\n"); 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville fflush(stdout); 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH({ 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(catch_exceptions) = false; 625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville throw 1; 626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, ""); 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the function. 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) { 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool aborted = true; 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), ""); 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(aborted); 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid AssertDebugDeathHelper(bool* aborted) { 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = true; 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEBUG_DEATH(return, "") << "This is expected to fail."; 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *aborted = false; 642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// failure. 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, AssertDebugDeathAborts) { 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static bool aborted; 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville aborted = false; 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(aborted); 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // _NDEBUG 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests the *_EXIT family of macros, using a variety of predicates. 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic void TestExitMacros() { 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), ""); 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 660d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if GTEST_OS_WINDOWS 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Of all signals effects on the process exit code, only those of SIGABRT 662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // are documented on Windows. 663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx. 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), ""); 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo"; 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar"; 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE({ // NOLINT 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "") 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "This failure is expected, too."; 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "This failure is expected, too."); 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE({ // NOLINT 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "") 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "This failure is expected."; 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "This failure is expected."); 679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ExitMacros) { 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestExitMacros(); 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, ExitMacrosUsingFork) { 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_use_fork) = true; 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestExitMacros(); 688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(TestForDeathTest, InvalidStyle) { 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::GTEST_FLAG(death_test_style) = "rococo"; 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE({ // NOLINT 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(0), "") << "This failure is expected."; 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "This failure is expected."); 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A DeathTestFactory that returns MockDeathTests. 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MockDeathTestFactory : public DeathTestFactory { 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MockDeathTestFactory(); 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual bool Create(const char* statement, 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::testing::internal::RE* regex, 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* file, int line, DeathTest** test); 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sets the parameters for subsequent calls to Create. 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void SetParameters(bool create, DeathTest::TestRole role, 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int status, bool passed); 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Accessors. 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int AssumeRoleCalls() const { return assume_role_calls_; } 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int WaitCalls() const { return wait_calls_; } 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int PassedCalls() const { return passed_args_.size(); } 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool PassedArgument(int n) const { return passed_args_[n]; } 714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int AbortCalls() const { return abort_args_.size(); } 715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTest::AbortReason AbortArgument(int n) const { 716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return abort_args_[n]; 717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool TestDeleted() const { return test_deleted_; } 719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class MockDeathTest; 722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If true, Create will return a MockDeathTest; otherwise it returns 723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // NULL. 724fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool create_; 725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The value a MockDeathTest will return from its AssumeRole method. 726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTest::TestRole role_; 727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The value a MockDeathTest will return from its Wait method. 728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int status_; 729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The value a MockDeathTest will return from its Passed method. 730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool passed_; 731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Number of times AssumeRole was called. 733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int assume_role_calls_; 734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Number of times Wait was called. 735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int wait_calls_; 736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The arguments to the calls to Passed since the last call to 737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // SetParameters. 738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville std::vector<bool> passed_args_; 739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The arguments to the calls to Abort since the last call to 740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // SetParameters. 741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville std::vector<DeathTest::AbortReason> abort_args_; 742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // True if the last MockDeathTest returned by Create has been 743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // deleted. 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool test_deleted_; 745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A DeathTest implementation useful in testing. It returns values set 749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// at its creation from its various inherited DeathTest methods, and 750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// reports calls to those methods to its parent MockDeathTestFactory 751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// object. 752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MockDeathTest : public DeathTest { 753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MockDeathTest(MockDeathTestFactory *parent, 755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestRole role, int status, bool passed) : 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville parent_(parent), role_(role), status_(status), passed_(passed) { 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~MockDeathTest() { 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville parent_->test_deleted_ = true; 760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual TestRole AssumeRole() { 762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ++parent_->assume_role_calls_; 763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return role_; 764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual int Wait() { 766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ++parent_->wait_calls_; 767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return status_; 768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual bool Passed(bool exit_status_ok) { 770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville parent_->passed_args_.push_back(exit_status_ok); 771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return passed_; 772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void Abort(AbortReason reason) { 774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville parent_->abort_args_.push_back(reason); 775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 776fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 777fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MockDeathTestFactory* const parent_; 778fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const TestRole role_; 779fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int status_; 780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const bool passed_; 781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// MockDeathTestFactory constructor. 785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleMockDeathTestFactory::MockDeathTestFactory() 786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : create_(true), 787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville role_(DeathTest::OVERSEE_TEST), 788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville status_(0), 789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville passed_(true), 790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assume_role_calls_(0), 791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville wait_calls_(0), 792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville passed_args_(), 793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville abort_args_() { 794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Sets the parameters for subsequent calls to Create. 798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid MockDeathTestFactory::SetParameters(bool create, 799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTest::TestRole role, 800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int status, bool passed) { 801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville create_ = create; 802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville role_ = role; 803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville status_ = status; 804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville passed_ = passed; 805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assume_role_calls_ = 0; 807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville wait_calls_ = 0; 808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville passed_args_.clear(); 809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville abort_args_.clear(); 810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Sets test to NULL (if create_ is false) or to the address of a new 814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// MockDeathTest object with parameters taken from the last call 815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to SetParameters (if create_ is true). Always returns true. 816d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savillebool MockDeathTestFactory::Create(const char* /*statement*/, 817d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const ::testing::internal::RE* /*regex*/, 818d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville const char* /*file*/, 819d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int /*line*/, 820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DeathTest** test) { 821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_deleted_ = false; 822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (create_) { 823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *test = new MockDeathTest(this, role_, status_, passed_); 824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } else { 825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *test = NULL; 826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return true; 828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro. 831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// It installs a MockDeathTestFactory that is used for the duration 832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of the test case. 833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MacroLogicDeathTest : public testing::Test { 834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville protected: 835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static testing::internal::ReplaceDeathTestFactory* replacer_; 836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static MockDeathTestFactory* factory_; 837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 838fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void SetUpTestCase() { 839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_ = new MockDeathTestFactory; 840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_); 841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 843fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void TearDownTestCase() { 844fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete replacer_; 845fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville replacer_ = NULL; 846fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete factory_; 847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_ = NULL; 848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Runs a death test that breaks the rules by returning. Such a death 851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // test cannot be run directly from a test routine that uses a 852fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // MockDeathTest, or the remainder of the routine will not be executed. 853fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void RunReturningDeathTest(bool* flag) { 854fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH({ // NOLINT 855fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville *flag = true; 856fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return; 857fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, ""); 858fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 859fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 860fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 861fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletesting::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ 862fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville = NULL; 863fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleMockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL; 864fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 865fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 866fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test that nothing happens when the factory doesn't return a DeathTest: 867fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(MacroLogicDeathTest, NothingHappens) { 868fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool flag = false; 869fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true); 870fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(flag = true, ""); 871fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(flag); 872fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->AssumeRoleCalls()); 873fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->WaitCalls()); 874fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->PassedCalls()); 875fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->AbortCalls()); 876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(factory_->TestDeleted()); 877fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Test that the parent process doesn't run the death test code, 880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and that the Passed method returns false when the (simulated) 881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// child process exits with status 0: 882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) { 883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool flag = false; 884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true); 885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(flag = true, ""); 886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(flag); 887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->AssumeRoleCalls()); 888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->WaitCalls()); 889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EQ(1, factory_->PassedCalls()); 890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(factory_->PassedArgument(0)); 891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->AbortCalls()); 892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(factory_->TestDeleted()); 893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 895fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the Passed method was given the argument "true" when 896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the (simulated) child process exits with status 1: 897fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) { 898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool flag = false; 899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true); 900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(flag = true, ""); 901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(flag); 902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->AssumeRoleCalls()); 903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->WaitCalls()); 904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EQ(1, factory_->PassedCalls()); 905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(factory_->PassedArgument(0)); 906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->AbortCalls()); 907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(factory_->TestDeleted()); 908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the (simulated) child process executes the death test 911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// code, and is aborted with the correct AbortReason if it 912fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// executes a return statement. 913fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(MacroLogicDeathTest, ChildPerformsReturn) { 914fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool flag = false; 915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville RunReturningDeathTest(&flag); 917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(flag); 918fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->AssumeRoleCalls()); 919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->WaitCalls()); 920fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->PassedCalls()); 921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->AbortCalls()); 922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->AbortArgument(0)); 924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(factory_->TestDeleted()); 925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the (simulated) child process is aborted with the 928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// correct AbortReason if it does not die. 929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_F(MacroLogicDeathTest, ChildDoesNotDie) { 930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool flag = false; 931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(flag = true, ""); 933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(flag); 934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, factory_->AssumeRoleCalls()); 935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->WaitCalls()); 936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, factory_->PassedCalls()); 937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // This time there are two calls to Abort: one since the test didn't 938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // die, and another from the ReturnSentinel when it's destroyed. The 939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // sentinel normally isn't destroyed if a test doesn't die, since 940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // _exit(2) is called in that case by ForkingDeathTest, but not by 941fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // our MockDeathTest. 942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_EQ(2, factory_->AbortCalls()); 943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, 944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->AbortArgument(0)); 945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville factory_->AbortArgument(1)); 947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(factory_->TestDeleted()); 948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a successful death test does not register a successful 951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// test part. 952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(SuccessRegistrationDeathTest, NoSuccessPart) { 953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), ""); 954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 956fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(StreamingAssertionsDeathTest, DeathTest) { 958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(1), "") << "unexpected failure"; 959fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(1), "") << "unexpected failure"; 960fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE({ // NOLINT 961fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH(_exit(0), "") << "expected failure"; 962fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "expected failure"); 963fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE({ // NOLINT 964fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_DEATH(_exit(0), "") << "expected failure"; 965fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }, "expected failure"); 966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 967fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that GetLastErrnoDescription returns an empty string when the 969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// last error is 0 and non-empty string when it is non-zero. 970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) { 971fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville errno = ENOENT; 972fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STRNE("", GetLastErrnoDescription().c_str()); 973fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville errno = 0; 974fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STREQ("", GetLastErrnoDescription().c_str()); 975fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 976fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 977fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 978fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(AutoHandleTest, AutoHandleWorks) { 979fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 980fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_NE(INVALID_HANDLE_VALUE, handle); 981fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that the AutoHandle is correctly initialized with a handle. 983fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::internal::AutoHandle auto_handle(handle); 984fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(handle, auto_handle.Get()); 985fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 986fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that Reset assigns INVALID_HANDLE_VALUE. 987fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Note that this cannot verify whether the original handle is closed. 988fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville auto_handle.Reset(); 989fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get()); 990fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 991fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that Reset assigns the new handle. 992fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Note that this cannot verify whether the original handle is closed. 993fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 994fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_NE(INVALID_HANDLE_VALUE, handle); 995fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville auto_handle.Reset(handle); 996fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(handle, auto_handle.Get()); 997fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 998fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default. 999fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville testing::internal::AutoHandle auto_handle2; 1000fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get()); 1001fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1002fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1003fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1004fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned __int64 BiggestParsable; 1006fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef signed __int64 BiggestSignedParsable; 1007fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst BiggestParsable kBiggestParsableMax = ULLONG_MAX; 1008fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst BiggestParsable kBiggestSignedParsableMax = LLONG_MAX; 1009fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1010fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned long long BiggestParsable; 1011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef signed long long BiggestSignedParsable; 1012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst BiggestParsable kBiggestParsableMax = 1013fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::std::numeric_limits<BiggestParsable>::max(); 1014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst BiggestSignedParsable kBiggestSignedParsableMax = 1015fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::std::numeric_limits<BiggestSignedParsable>::max(); 1016fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1017fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1018fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParseNaturalNumberTest, RejectsInvalidFormat) { 1019fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestParsable result = 0; 1020fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1021fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Rejects non-numbers. 1022fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String("non-number string"), &result)); 1023fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1024fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Rejects numbers with whitespace prefix. 1025fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String(" 123"), &result)); 1026fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1027fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Rejects negative numbers. 1028fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String("-123"), &result)); 1029fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1030fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Rejects numbers starting with a plus sign. 1031fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String("+123"), &result)); 1032fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville errno = 0; 1033fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1034fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1035fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParseNaturalNumberTest, RejectsOverflownNumbers) { 1036fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestParsable result = 0; 1037fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1038fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String("99999999999999999999999"), &result)); 1039fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1040fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville signed char char_result = 0; 1041fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(ParseNaturalNumber(String("200"), &char_result)); 1042fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville errno = 0; 1043fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1044fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1045fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParseNaturalNumberTest, AcceptsValidNumbers) { 1046fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestParsable result = 0; 1047fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1048fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result = 0; 1049fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(ParseNaturalNumber(String("123"), &result)); 1050fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(123U, result); 1051fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1052fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Check 0 as an edge case. 1053fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result = 1; 1054fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(ParseNaturalNumber(String("0"), &result)); 1055fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0U, result); 1056fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1057fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result = 1; 1058fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result)); 1059fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0U, result); 1060fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1061fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1062fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParseNaturalNumberTest, AcceptsTypeLimits) { 1063fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg; 1064fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg << kBiggestParsableMax; 1065fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1066fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestParsable result = 0; 1067fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result)); 1068fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kBiggestParsableMax, result); 1069fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1070fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg2; 1071fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg2 << kBiggestSignedParsableMax; 1072fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1073fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville BiggestSignedParsable signed_result = 0; 1074fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result)); 1075fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kBiggestSignedParsableMax, signed_result); 1076fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1077fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg3; 1078fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg3 << INT_MAX; 1079fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1080fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int int_result = 0; 1081fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result)); 1082fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(INT_MAX, int_result); 1083fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1084fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg4; 1085fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg4 << UINT_MAX; 1086fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1087fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unsigned int uint_result = 0; 1088fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result)); 1089fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(UINT_MAX, uint_result); 1090fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1091fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1092fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParseNaturalNumberTest, WorksForShorterIntegers) { 1093fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville short short_result = 0; 1094fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(ParseNaturalNumber(String("123"), &short_result)); 1095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(123, short_result); 1096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville signed char char_result = 0; 1098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(ParseNaturalNumber(String("123"), &char_result)); 1099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(123, char_result); 1100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_OS_WINDOWS 1103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(EnvironmentTest, HandleFitsIntoSizeT) { 1104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // TODO(vladl@google.com): Remove this test after this condition is verified 1105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // in a static assertion in gtest-death-test.cc in the function 1106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // GetStatusFileDescriptor. 1107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t)); 1108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_OS_WINDOWS 1110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger 1112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// failures when death tests are available on the system. 1113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) { 11140ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"), 11150ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson "death inside CondDeathTestExpectMacro"); 11160ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"), 11170ddac1f3791efefb2cffdb425f0c600feb7a47e6Jeff Davidson "death inside CondDeathTestAssertMacro"); 1118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Empty statement will not crash, which must trigger a failure. 1120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), ""); 1121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), ""); 1122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 1125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::CaptureStderr; 1127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::GetCapturedStderr; 1128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing testing::internal::String; 1129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still 1131d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// defined but do not trigger failures when death tests are not available on 1132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the system. 1133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) { 1134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Empty statement will not crash, but that should not trigger a failure 1135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // when death tests are not supported. 1136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville CaptureStderr(); 1137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_DEATH_IF_SUPPORTED(;, ""); 1138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville String output = GetCapturedStderr(); 1139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(NULL != strstr(output.c_str(), 1140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "Death tests are not supported on this platform")); 1141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 1142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1143d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // The streamed message should not be printed as there is no test failure. 1144d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville CaptureStderr(); 1145d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; 1146d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville output = GetCapturedStderr(); 1147d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 1148d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville CaptureStderr(); 1150d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(;, ""); // NOLINT 1151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville output = GetCapturedStderr(); 1152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(NULL != strstr(output.c_str(), 1153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "Death tests are not supported on this platform")); 1154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 1155d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1156d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville CaptureStderr(); 1157d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; // NOLINT 1158d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville output = GetCapturedStderr(); 1159d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 1160d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville} 1161d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1162d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savillevoid FuncWithAssert(int* n) { 1163d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(return;, ""); 1164d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville (*n)++; 1165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1167d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current 1168d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// function (as ASSERT_DEATH does) if death tests are not supported. 1169d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink SavilleTEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) { 1170d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville int n = 0; 1171d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville FuncWithAssert(&n); 1172d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_EQ(1, n); 1173d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville} 1174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_DEATH_TEST 1175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1176d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Tests that the death test macros expand to code which may or may not 1177d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// be followed by operator<<, and that in either case the complete text 1178d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// comprises only a single C++ statement. 1179d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// 1180d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// The syntax should work whether death tests are available or not. 1181d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink SavilleTEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) { 1182d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 1183d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // This would fail if executed; this is a compilation test only 1184d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(return, ""); 1185d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1186d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysTrue()) 1187d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_DEATH_IF_SUPPORTED(_exit(1), ""); 1188d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville else 1189d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // This empty "else" branch is meant to ensure that EXPECT_DEATH 1190d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville // doesn't expand into an "if" statement without an "else" 1191d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ; // NOLINT 1192d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1193d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 1194d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die"; 1195d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1196d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville if (AlwaysFalse()) 1197d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ; // NOLINT 1198d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville else 1199d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3; 1200d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville} 1201d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1202d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Tests that conditional death test macros expand to code which interacts 1203d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// well with switch statements. 1204d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink SavilleTEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) { 1205d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Microsoft compiler usually complains about switch statements without 1206d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// case labels. We suppress that warning for this test. 1207d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifdef _MSC_VER 1208d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#pragma warning(push) 1209d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#pragma warning(disable: 4065) 1210d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // _MSC_VER 1211d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1212d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville switch (0) 1213d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville default: 1214d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") 1215d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville << "exit in default switch handler"; 1216d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1217d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville switch (0) 1218d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville case 0: 1219d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case"; 1220d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1221d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifdef _MSC_VER 1222d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#pragma warning(pop) 1223d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif // _MSC_VER 1224d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville} 1225d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a test case whose name ends with "DeathTest" works fine 1227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// on Windows. 1228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(NotADeathTest, Test) { 1229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville SUCCEED(); 1230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1231