113481Sgiacomo.travaglini@arm.com// Copyright 2005, Google Inc. 213481Sgiacomo.travaglini@arm.com// All rights reserved. 313481Sgiacomo.travaglini@arm.com// 413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 613481Sgiacomo.travaglini@arm.com// met: 713481Sgiacomo.travaglini@arm.com// 813481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1013481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1313481Sgiacomo.travaglini@arm.com// distribution. 1413481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 1713481Sgiacomo.travaglini@arm.com// 1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2913481Sgiacomo.travaglini@arm.com// 3013481Sgiacomo.travaglini@arm.com// Author: wan@google.com (Zhanyong Wan) 3113481Sgiacomo.travaglini@arm.com// 3213481Sgiacomo.travaglini@arm.com// Tests for death tests. 3313481Sgiacomo.travaglini@arm.com 3413481Sgiacomo.travaglini@arm.com#include "gtest/gtest-death-test.h" 3513481Sgiacomo.travaglini@arm.com#include "gtest/gtest.h" 3613481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-filepath.h" 3713481Sgiacomo.travaglini@arm.com 3813481Sgiacomo.travaglini@arm.comusing testing::internal::AlwaysFalse; 3913481Sgiacomo.travaglini@arm.comusing testing::internal::AlwaysTrue; 4013481Sgiacomo.travaglini@arm.com 4113481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST 4213481Sgiacomo.travaglini@arm.com 4313481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 4413481Sgiacomo.travaglini@arm.com# include <direct.h> // For chdir(). 4513481Sgiacomo.travaglini@arm.com# else 4613481Sgiacomo.travaglini@arm.com# include <unistd.h> 4713481Sgiacomo.travaglini@arm.com# include <sys/wait.h> // For waitpid. 4813481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 4913481Sgiacomo.travaglini@arm.com 5013481Sgiacomo.travaglini@arm.com# include <limits.h> 5113481Sgiacomo.travaglini@arm.com# include <signal.h> 5213481Sgiacomo.travaglini@arm.com# include <stdio.h> 5313481Sgiacomo.travaglini@arm.com 5413481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX 5513481Sgiacomo.travaglini@arm.com# include <sys/time.h> 5613481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_LINUX 5713481Sgiacomo.travaglini@arm.com 5813481Sgiacomo.travaglini@arm.com# include "gtest/gtest-spi.h" 5913481Sgiacomo.travaglini@arm.com 6013481Sgiacomo.travaglini@arm.com// Indicates that this translation unit is part of Google Test's 6113481Sgiacomo.travaglini@arm.com// implementation. It must come before gtest-internal-inl.h is 6213481Sgiacomo.travaglini@arm.com// included, or there will be a compiler error. This trick is to 6313481Sgiacomo.travaglini@arm.com// prevent a user from accidentally including gtest-internal-inl.h in 6413481Sgiacomo.travaglini@arm.com// his code. 6513481Sgiacomo.travaglini@arm.com# define GTEST_IMPLEMENTATION_ 1 6613481Sgiacomo.travaglini@arm.com# include "src/gtest-internal-inl.h" 6713481Sgiacomo.travaglini@arm.com# undef GTEST_IMPLEMENTATION_ 6813481Sgiacomo.travaglini@arm.com 6913481Sgiacomo.travaglini@arm.comnamespace posix = ::testing::internal::posix; 7013481Sgiacomo.travaglini@arm.com 7113481Sgiacomo.travaglini@arm.comusing testing::Message; 7213481Sgiacomo.travaglini@arm.comusing testing::internal::DeathTest; 7313481Sgiacomo.travaglini@arm.comusing testing::internal::DeathTestFactory; 7413481Sgiacomo.travaglini@arm.comusing testing::internal::FilePath; 7513481Sgiacomo.travaglini@arm.comusing testing::internal::GetLastErrnoDescription; 7613481Sgiacomo.travaglini@arm.comusing testing::internal::GetUnitTestImpl; 7713481Sgiacomo.travaglini@arm.comusing testing::internal::InDeathTestChild; 7813481Sgiacomo.travaglini@arm.comusing testing::internal::ParseNaturalNumber; 7913481Sgiacomo.travaglini@arm.com 8013481Sgiacomo.travaglini@arm.comnamespace testing { 8113481Sgiacomo.travaglini@arm.comnamespace internal { 8213481Sgiacomo.travaglini@arm.com 8313481Sgiacomo.travaglini@arm.com// A helper class whose objects replace the death test factory for a 8413481Sgiacomo.travaglini@arm.com// single UnitTest object during their lifetimes. 8513481Sgiacomo.travaglini@arm.comclass ReplaceDeathTestFactory { 8613481Sgiacomo.travaglini@arm.com public: 8713481Sgiacomo.travaglini@arm.com explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory) 8813481Sgiacomo.travaglini@arm.com : unit_test_impl_(GetUnitTestImpl()) { 8913481Sgiacomo.travaglini@arm.com old_factory_ = unit_test_impl_->death_test_factory_.release(); 9013481Sgiacomo.travaglini@arm.com unit_test_impl_->death_test_factory_.reset(new_factory); 9113481Sgiacomo.travaglini@arm.com } 9213481Sgiacomo.travaglini@arm.com 9313481Sgiacomo.travaglini@arm.com ~ReplaceDeathTestFactory() { 9413481Sgiacomo.travaglini@arm.com unit_test_impl_->death_test_factory_.release(); 9513481Sgiacomo.travaglini@arm.com unit_test_impl_->death_test_factory_.reset(old_factory_); 9613481Sgiacomo.travaglini@arm.com } 9713481Sgiacomo.travaglini@arm.com private: 9813481Sgiacomo.travaglini@arm.com // Prevents copying ReplaceDeathTestFactory objects. 9913481Sgiacomo.travaglini@arm.com ReplaceDeathTestFactory(const ReplaceDeathTestFactory&); 10013481Sgiacomo.travaglini@arm.com void operator=(const ReplaceDeathTestFactory&); 10113481Sgiacomo.travaglini@arm.com 10213481Sgiacomo.travaglini@arm.com UnitTestImpl* unit_test_impl_; 10313481Sgiacomo.travaglini@arm.com DeathTestFactory* old_factory_; 10413481Sgiacomo.travaglini@arm.com}; 10513481Sgiacomo.travaglini@arm.com 10613481Sgiacomo.travaglini@arm.com} // namespace internal 10713481Sgiacomo.travaglini@arm.com} // namespace testing 10813481Sgiacomo.travaglini@arm.com 10913481Sgiacomo.travaglini@arm.comvoid DieWithMessage(const ::std::string& message) { 11013481Sgiacomo.travaglini@arm.com fprintf(stderr, "%s", message.c_str()); 11113481Sgiacomo.travaglini@arm.com fflush(stderr); // Make sure the text is printed before the process exits. 11213481Sgiacomo.travaglini@arm.com 11313481Sgiacomo.travaglini@arm.com // We call _exit() instead of exit(), as the former is a direct 11413481Sgiacomo.travaglini@arm.com // system call and thus safer in the presence of threads. exit() 11513481Sgiacomo.travaglini@arm.com // will invoke user-defined exit-hooks, which may do dangerous 11613481Sgiacomo.travaglini@arm.com // things that conflict with death tests. 11713481Sgiacomo.travaglini@arm.com // 11813481Sgiacomo.travaglini@arm.com // Some compilers can recognize that _exit() never returns and issue the 11913481Sgiacomo.travaglini@arm.com // 'unreachable code' warning for code following this function, unless 12013481Sgiacomo.travaglini@arm.com // fooled by a fake condition. 12113481Sgiacomo.travaglini@arm.com if (AlwaysTrue()) 12213481Sgiacomo.travaglini@arm.com _exit(1); 12313481Sgiacomo.travaglini@arm.com} 12413481Sgiacomo.travaglini@arm.com 12513481Sgiacomo.travaglini@arm.comvoid DieInside(const ::std::string& function) { 12613481Sgiacomo.travaglini@arm.com DieWithMessage("death inside " + function + "()."); 12713481Sgiacomo.travaglini@arm.com} 12813481Sgiacomo.travaglini@arm.com 12913481Sgiacomo.travaglini@arm.com// Tests that death tests work. 13013481Sgiacomo.travaglini@arm.com 13113481Sgiacomo.travaglini@arm.comclass TestForDeathTest : public testing::Test { 13213481Sgiacomo.travaglini@arm.com protected: 13313481Sgiacomo.travaglini@arm.com TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {} 13413481Sgiacomo.travaglini@arm.com 13513481Sgiacomo.travaglini@arm.com virtual ~TestForDeathTest() { 13613481Sgiacomo.travaglini@arm.com posix::ChDir(original_dir_.c_str()); 13713481Sgiacomo.travaglini@arm.com } 13813481Sgiacomo.travaglini@arm.com 13913481Sgiacomo.travaglini@arm.com // A static member function that's expected to die. 14013481Sgiacomo.travaglini@arm.com static void StaticMemberFunction() { DieInside("StaticMemberFunction"); } 14113481Sgiacomo.travaglini@arm.com 14213481Sgiacomo.travaglini@arm.com // A method of the test fixture that may die. 14313481Sgiacomo.travaglini@arm.com void MemberFunction() { 14413481Sgiacomo.travaglini@arm.com if (should_die_) 14513481Sgiacomo.travaglini@arm.com DieInside("MemberFunction"); 14613481Sgiacomo.travaglini@arm.com } 14713481Sgiacomo.travaglini@arm.com 14813481Sgiacomo.travaglini@arm.com // True iff MemberFunction() should die. 14913481Sgiacomo.travaglini@arm.com bool should_die_; 15013481Sgiacomo.travaglini@arm.com const FilePath original_dir_; 15113481Sgiacomo.travaglini@arm.com}; 15213481Sgiacomo.travaglini@arm.com 15313481Sgiacomo.travaglini@arm.com// A class with a member function that may die. 15413481Sgiacomo.travaglini@arm.comclass MayDie { 15513481Sgiacomo.travaglini@arm.com public: 15613481Sgiacomo.travaglini@arm.com explicit MayDie(bool should_die) : should_die_(should_die) {} 15713481Sgiacomo.travaglini@arm.com 15813481Sgiacomo.travaglini@arm.com // A member function that may die. 15913481Sgiacomo.travaglini@arm.com void MemberFunction() const { 16013481Sgiacomo.travaglini@arm.com if (should_die_) 16113481Sgiacomo.travaglini@arm.com DieInside("MayDie::MemberFunction"); 16213481Sgiacomo.travaglini@arm.com } 16313481Sgiacomo.travaglini@arm.com 16413481Sgiacomo.travaglini@arm.com private: 16513481Sgiacomo.travaglini@arm.com // True iff MemberFunction() should die. 16613481Sgiacomo.travaglini@arm.com bool should_die_; 16713481Sgiacomo.travaglini@arm.com}; 16813481Sgiacomo.travaglini@arm.com 16913481Sgiacomo.travaglini@arm.com// A global function that's expected to die. 17013481Sgiacomo.travaglini@arm.comvoid GlobalFunction() { DieInside("GlobalFunction"); } 17113481Sgiacomo.travaglini@arm.com 17213481Sgiacomo.travaglini@arm.com// A non-void function that's expected to die. 17313481Sgiacomo.travaglini@arm.comint NonVoidFunction() { 17413481Sgiacomo.travaglini@arm.com DieInside("NonVoidFunction"); 17513481Sgiacomo.travaglini@arm.com return 1; 17613481Sgiacomo.travaglini@arm.com} 17713481Sgiacomo.travaglini@arm.com 17813481Sgiacomo.travaglini@arm.com// A unary function that may die. 17913481Sgiacomo.travaglini@arm.comvoid DieIf(bool should_die) { 18013481Sgiacomo.travaglini@arm.com if (should_die) 18113481Sgiacomo.travaglini@arm.com DieInside("DieIf"); 18213481Sgiacomo.travaglini@arm.com} 18313481Sgiacomo.travaglini@arm.com 18413481Sgiacomo.travaglini@arm.com// A binary function that may die. 18513481Sgiacomo.travaglini@arm.combool DieIfLessThan(int x, int y) { 18613481Sgiacomo.travaglini@arm.com if (x < y) { 18713481Sgiacomo.travaglini@arm.com DieInside("DieIfLessThan"); 18813481Sgiacomo.travaglini@arm.com } 18913481Sgiacomo.travaglini@arm.com return true; 19013481Sgiacomo.travaglini@arm.com} 19113481Sgiacomo.travaglini@arm.com 19213481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 19313481Sgiacomo.travaglini@arm.comvoid DeathTestSubroutine() { 19413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 19513481Sgiacomo.travaglini@arm.com ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction"); 19613481Sgiacomo.travaglini@arm.com} 19713481Sgiacomo.travaglini@arm.com 19813481Sgiacomo.travaglini@arm.com// Death in dbg, not opt. 19913481Sgiacomo.travaglini@arm.comint DieInDebugElse12(int* sideeffect) { 20013481Sgiacomo.travaglini@arm.com if (sideeffect) *sideeffect = 12; 20113481Sgiacomo.travaglini@arm.com 20213481Sgiacomo.travaglini@arm.com# ifndef NDEBUG 20313481Sgiacomo.travaglini@arm.com 20413481Sgiacomo.travaglini@arm.com DieInside("DieInDebugElse12"); 20513481Sgiacomo.travaglini@arm.com 20613481Sgiacomo.travaglini@arm.com# endif // NDEBUG 20713481Sgiacomo.travaglini@arm.com 20813481Sgiacomo.travaglini@arm.com return 12; 20913481Sgiacomo.travaglini@arm.com} 21013481Sgiacomo.travaglini@arm.com 21113481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 21213481Sgiacomo.travaglini@arm.com 21313481Sgiacomo.travaglini@arm.com// Tests the ExitedWithCode predicate. 21413481Sgiacomo.travaglini@arm.comTEST(ExitStatusPredicateTest, ExitedWithCode) { 21513481Sgiacomo.travaglini@arm.com // On Windows, the process's exit code is the same as its exit status, 21613481Sgiacomo.travaglini@arm.com // so the predicate just compares the its input with its parameter. 21713481Sgiacomo.travaglini@arm.com EXPECT_TRUE(testing::ExitedWithCode(0)(0)); 21813481Sgiacomo.travaglini@arm.com EXPECT_TRUE(testing::ExitedWithCode(1)(1)); 21913481Sgiacomo.travaglini@arm.com EXPECT_TRUE(testing::ExitedWithCode(42)(42)); 22013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(testing::ExitedWithCode(0)(1)); 22113481Sgiacomo.travaglini@arm.com EXPECT_FALSE(testing::ExitedWithCode(1)(0)); 22213481Sgiacomo.travaglini@arm.com} 22313481Sgiacomo.travaglini@arm.com 22413481Sgiacomo.travaglini@arm.com# else 22513481Sgiacomo.travaglini@arm.com 22613481Sgiacomo.travaglini@arm.com// Returns the exit status of a process that calls _exit(2) with a 22713481Sgiacomo.travaglini@arm.com// given exit code. This is a helper function for the 22813481Sgiacomo.travaglini@arm.com// ExitStatusPredicateTest test suite. 22913481Sgiacomo.travaglini@arm.comstatic int NormalExitStatus(int exit_code) { 23013481Sgiacomo.travaglini@arm.com pid_t child_pid = fork(); 23113481Sgiacomo.travaglini@arm.com if (child_pid == 0) { 23213481Sgiacomo.travaglini@arm.com _exit(exit_code); 23313481Sgiacomo.travaglini@arm.com } 23413481Sgiacomo.travaglini@arm.com int status; 23513481Sgiacomo.travaglini@arm.com waitpid(child_pid, &status, 0); 23613481Sgiacomo.travaglini@arm.com return status; 23713481Sgiacomo.travaglini@arm.com} 23813481Sgiacomo.travaglini@arm.com 23913481Sgiacomo.travaglini@arm.com// Returns the exit status of a process that raises a given signal. 24013481Sgiacomo.travaglini@arm.com// If the signal does not cause the process to die, then it returns 24113481Sgiacomo.travaglini@arm.com// instead the exit status of a process that exits normally with exit 24213481Sgiacomo.travaglini@arm.com// code 1. This is a helper function for the ExitStatusPredicateTest 24313481Sgiacomo.travaglini@arm.com// test suite. 24413481Sgiacomo.travaglini@arm.comstatic int KilledExitStatus(int signum) { 24513481Sgiacomo.travaglini@arm.com pid_t child_pid = fork(); 24613481Sgiacomo.travaglini@arm.com if (child_pid == 0) { 24713481Sgiacomo.travaglini@arm.com raise(signum); 24813481Sgiacomo.travaglini@arm.com _exit(1); 24913481Sgiacomo.travaglini@arm.com } 25013481Sgiacomo.travaglini@arm.com int status; 25113481Sgiacomo.travaglini@arm.com waitpid(child_pid, &status, 0); 25213481Sgiacomo.travaglini@arm.com return status; 25313481Sgiacomo.travaglini@arm.com} 25413481Sgiacomo.travaglini@arm.com 25513481Sgiacomo.travaglini@arm.com// Tests the ExitedWithCode predicate. 25613481Sgiacomo.travaglini@arm.comTEST(ExitStatusPredicateTest, ExitedWithCode) { 25713481Sgiacomo.travaglini@arm.com const int status0 = NormalExitStatus(0); 25813481Sgiacomo.travaglini@arm.com const int status1 = NormalExitStatus(1); 25913481Sgiacomo.travaglini@arm.com const int status42 = NormalExitStatus(42); 26013481Sgiacomo.travaglini@arm.com const testing::ExitedWithCode pred0(0); 26113481Sgiacomo.travaglini@arm.com const testing::ExitedWithCode pred1(1); 26213481Sgiacomo.travaglini@arm.com const testing::ExitedWithCode pred42(42); 26313481Sgiacomo.travaglini@arm.com EXPECT_PRED1(pred0, status0); 26413481Sgiacomo.travaglini@arm.com EXPECT_PRED1(pred1, status1); 26513481Sgiacomo.travaglini@arm.com EXPECT_PRED1(pred42, status42); 26613481Sgiacomo.travaglini@arm.com EXPECT_FALSE(pred0(status1)); 26713481Sgiacomo.travaglini@arm.com EXPECT_FALSE(pred42(status0)); 26813481Sgiacomo.travaglini@arm.com EXPECT_FALSE(pred1(status42)); 26913481Sgiacomo.travaglini@arm.com} 27013481Sgiacomo.travaglini@arm.com 27113481Sgiacomo.travaglini@arm.com// Tests the KilledBySignal predicate. 27213481Sgiacomo.travaglini@arm.comTEST(ExitStatusPredicateTest, KilledBySignal) { 27313481Sgiacomo.travaglini@arm.com const int status_segv = KilledExitStatus(SIGSEGV); 27413481Sgiacomo.travaglini@arm.com const int status_kill = KilledExitStatus(SIGKILL); 27513481Sgiacomo.travaglini@arm.com const testing::KilledBySignal pred_segv(SIGSEGV); 27613481Sgiacomo.travaglini@arm.com const testing::KilledBySignal pred_kill(SIGKILL); 27713481Sgiacomo.travaglini@arm.com EXPECT_PRED1(pred_segv, status_segv); 27813481Sgiacomo.travaglini@arm.com EXPECT_PRED1(pred_kill, status_kill); 27913481Sgiacomo.travaglini@arm.com EXPECT_FALSE(pred_segv(status_kill)); 28013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(pred_kill(status_segv)); 28113481Sgiacomo.travaglini@arm.com} 28213481Sgiacomo.travaglini@arm.com 28313481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 28413481Sgiacomo.travaglini@arm.com 28513481Sgiacomo.travaglini@arm.com// Tests that the death test macros expand to code which may or may not 28613481Sgiacomo.travaglini@arm.com// be followed by operator<<, and that in either case the complete text 28713481Sgiacomo.travaglini@arm.com// comprises only a single C++ statement. 28813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, SingleStatement) { 28913481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 29013481Sgiacomo.travaglini@arm.com // This would fail if executed; this is a compilation test only 29113481Sgiacomo.travaglini@arm.com ASSERT_DEATH(return, ""); 29213481Sgiacomo.travaglini@arm.com 29313481Sgiacomo.travaglini@arm.com if (AlwaysTrue()) 29413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 29513481Sgiacomo.travaglini@arm.com else 29613481Sgiacomo.travaglini@arm.com // This empty "else" branch is meant to ensure that EXPECT_DEATH 29713481Sgiacomo.travaglini@arm.com // doesn't expand into an "if" statement without an "else" 29813481Sgiacomo.travaglini@arm.com ; 29913481Sgiacomo.travaglini@arm.com 30013481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 30113481Sgiacomo.travaglini@arm.com ASSERT_DEATH(return, "") << "did not die"; 30213481Sgiacomo.travaglini@arm.com 30313481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 30413481Sgiacomo.travaglini@arm.com ; 30513481Sgiacomo.travaglini@arm.com else 30613481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3; 30713481Sgiacomo.travaglini@arm.com} 30813481Sgiacomo.travaglini@arm.com 30913481Sgiacomo.travaglini@arm.comvoid DieWithEmbeddedNul() { 31013481Sgiacomo.travaglini@arm.com fprintf(stderr, "Hello%cmy null world.\n", '\0'); 31113481Sgiacomo.travaglini@arm.com fflush(stderr); 31213481Sgiacomo.travaglini@arm.com _exit(1); 31313481Sgiacomo.travaglini@arm.com} 31413481Sgiacomo.travaglini@arm.com 31513481Sgiacomo.travaglini@arm.com# if GTEST_USES_PCRE 31613481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error 31713481Sgiacomo.travaglini@arm.com// message has a NUL character in it. 31813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, EmbeddedNulInMessage) { 31913481Sgiacomo.travaglini@arm.com // TODO(wan@google.com): <regex.h> doesn't support matching strings 32013481Sgiacomo.travaglini@arm.com // with embedded NUL characters - find a way to workaround it. 32113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieWithEmbeddedNul(), "my null world"); 32213481Sgiacomo.travaglini@arm.com ASSERT_DEATH(DieWithEmbeddedNul(), "my null world"); 32313481Sgiacomo.travaglini@arm.com} 32413481Sgiacomo.travaglini@arm.com# endif // GTEST_USES_PCRE 32513481Sgiacomo.travaglini@arm.com 32613481Sgiacomo.travaglini@arm.com// Tests that death test macros expand to code which interacts well with switch 32713481Sgiacomo.travaglini@arm.com// statements. 32813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, SwitchStatement) { 32913481Sgiacomo.travaglini@arm.com // Microsoft compiler usually complains about switch statements without 33013481Sgiacomo.travaglini@arm.com // case labels. We suppress that warning for this test. 33113481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065) 33213481Sgiacomo.travaglini@arm.com 33313481Sgiacomo.travaglini@arm.com switch (0) 33413481Sgiacomo.travaglini@arm.com default: 33513481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(1), "") << "exit in default switch handler"; 33613481Sgiacomo.travaglini@arm.com 33713481Sgiacomo.travaglini@arm.com switch (0) 33813481Sgiacomo.travaglini@arm.com case 0: 33913481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), "") << "exit in switch case"; 34013481Sgiacomo.travaglini@arm.com 34113481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 34213481Sgiacomo.travaglini@arm.com} 34313481Sgiacomo.travaglini@arm.com 34413481Sgiacomo.travaglini@arm.com// Tests that a static member function can be used in a "fast" style 34513481Sgiacomo.travaglini@arm.com// death test. 34613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) { 34713481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 34813481Sgiacomo.travaglini@arm.com ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 34913481Sgiacomo.travaglini@arm.com} 35013481Sgiacomo.travaglini@arm.com 35113481Sgiacomo.travaglini@arm.com// Tests that a method of the test fixture can be used in a "fast" 35213481Sgiacomo.travaglini@arm.com// style death test. 35313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, MemberFunctionFastStyle) { 35413481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 35513481Sgiacomo.travaglini@arm.com should_die_ = true; 35613481Sgiacomo.travaglini@arm.com EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 35713481Sgiacomo.travaglini@arm.com} 35813481Sgiacomo.travaglini@arm.com 35913481Sgiacomo.travaglini@arm.comvoid ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); } 36013481Sgiacomo.travaglini@arm.com 36113481Sgiacomo.travaglini@arm.com// Tests that death tests work even if the current directory has been 36213481Sgiacomo.travaglini@arm.com// changed. 36313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, FastDeathTestInChangedDir) { 36413481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 36513481Sgiacomo.travaglini@arm.com 36613481Sgiacomo.travaglini@arm.com ChangeToRootDir(); 36713481Sgiacomo.travaglini@arm.com EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 36813481Sgiacomo.travaglini@arm.com 36913481Sgiacomo.travaglini@arm.com ChangeToRootDir(); 37013481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(1), ""); 37113481Sgiacomo.travaglini@arm.com} 37213481Sgiacomo.travaglini@arm.com 37313481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX 37413481Sgiacomo.travaglini@arm.comvoid SigprofAction(int, siginfo_t*, void*) { /* no op */ } 37513481Sgiacomo.travaglini@arm.com 37613481Sgiacomo.travaglini@arm.com// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms). 37713481Sgiacomo.travaglini@arm.comvoid SetSigprofActionAndTimer() { 37813481Sgiacomo.travaglini@arm.com struct itimerval timer; 37913481Sgiacomo.travaglini@arm.com timer.it_interval.tv_sec = 0; 38013481Sgiacomo.travaglini@arm.com timer.it_interval.tv_usec = 1; 38113481Sgiacomo.travaglini@arm.com timer.it_value = timer.it_interval; 38213481Sgiacomo.travaglini@arm.com ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 38313481Sgiacomo.travaglini@arm.com struct sigaction signal_action; 38413481Sgiacomo.travaglini@arm.com memset(&signal_action, 0, sizeof(signal_action)); 38513481Sgiacomo.travaglini@arm.com sigemptyset(&signal_action.sa_mask); 38613481Sgiacomo.travaglini@arm.com signal_action.sa_sigaction = SigprofAction; 38713481Sgiacomo.travaglini@arm.com signal_action.sa_flags = SA_RESTART | SA_SIGINFO; 38813481Sgiacomo.travaglini@arm.com ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL)); 38913481Sgiacomo.travaglini@arm.com} 39013481Sgiacomo.travaglini@arm.com 39113481Sgiacomo.travaglini@arm.com// Disables ITIMER_PROF timer and ignores SIGPROF signal. 39213481Sgiacomo.travaglini@arm.comvoid DisableSigprofActionAndTimer(struct sigaction* old_signal_action) { 39313481Sgiacomo.travaglini@arm.com struct itimerval timer; 39413481Sgiacomo.travaglini@arm.com timer.it_interval.tv_sec = 0; 39513481Sgiacomo.travaglini@arm.com timer.it_interval.tv_usec = 0; 39613481Sgiacomo.travaglini@arm.com timer.it_value = timer.it_interval; 39713481Sgiacomo.travaglini@arm.com ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); 39813481Sgiacomo.travaglini@arm.com struct sigaction signal_action; 39913481Sgiacomo.travaglini@arm.com memset(&signal_action, 0, sizeof(signal_action)); 40013481Sgiacomo.travaglini@arm.com sigemptyset(&signal_action.sa_mask); 40113481Sgiacomo.travaglini@arm.com signal_action.sa_handler = SIG_IGN; 40213481Sgiacomo.travaglini@arm.com ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action)); 40313481Sgiacomo.travaglini@arm.com} 40413481Sgiacomo.travaglini@arm.com 40513481Sgiacomo.travaglini@arm.com// Tests that death tests work when SIGPROF handler and timer are set. 40613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, FastSigprofActionSet) { 40713481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 40813481Sgiacomo.travaglini@arm.com SetSigprofActionAndTimer(); 40913481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 41013481Sgiacomo.travaglini@arm.com struct sigaction old_signal_action; 41113481Sgiacomo.travaglini@arm.com DisableSigprofActionAndTimer(&old_signal_action); 41213481Sgiacomo.travaglini@arm.com EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 41313481Sgiacomo.travaglini@arm.com} 41413481Sgiacomo.travaglini@arm.com 41513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) { 41613481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 41713481Sgiacomo.travaglini@arm.com SetSigprofActionAndTimer(); 41813481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 41913481Sgiacomo.travaglini@arm.com struct sigaction old_signal_action; 42013481Sgiacomo.travaglini@arm.com DisableSigprofActionAndTimer(&old_signal_action); 42113481Sgiacomo.travaglini@arm.com EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction); 42213481Sgiacomo.travaglini@arm.com} 42313481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_LINUX 42413481Sgiacomo.travaglini@arm.com 42513481Sgiacomo.travaglini@arm.com// Repeats a representative sample of death tests in the "threadsafe" style: 42613481Sgiacomo.travaglini@arm.com 42713481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) { 42813481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 42913481Sgiacomo.travaglini@arm.com ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember"); 43013481Sgiacomo.travaglini@arm.com} 43113481Sgiacomo.travaglini@arm.com 43213481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) { 43313481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 43413481Sgiacomo.travaglini@arm.com should_die_ = true; 43513481Sgiacomo.travaglini@arm.com EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction"); 43613481Sgiacomo.travaglini@arm.com} 43713481Sgiacomo.travaglini@arm.com 43813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) { 43913481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 44013481Sgiacomo.travaglini@arm.com 44113481Sgiacomo.travaglini@arm.com for (int i = 0; i < 3; ++i) 44213481Sgiacomo.travaglini@arm.com EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i; 44313481Sgiacomo.travaglini@arm.com} 44413481Sgiacomo.travaglini@arm.com 44513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) { 44613481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 44713481Sgiacomo.travaglini@arm.com 44813481Sgiacomo.travaglini@arm.com ChangeToRootDir(); 44913481Sgiacomo.travaglini@arm.com EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 45013481Sgiacomo.travaglini@arm.com 45113481Sgiacomo.travaglini@arm.com ChangeToRootDir(); 45213481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(1), ""); 45313481Sgiacomo.travaglini@arm.com} 45413481Sgiacomo.travaglini@arm.com 45513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, MixedStyles) { 45613481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 45713481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 45813481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 45913481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 46013481Sgiacomo.travaglini@arm.com} 46113481Sgiacomo.travaglini@arm.com 46213481Sgiacomo.travaglini@arm.com# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 46313481Sgiacomo.travaglini@arm.com 46413481Sgiacomo.travaglini@arm.comnamespace { 46513481Sgiacomo.travaglini@arm.com 46613481Sgiacomo.travaglini@arm.combool pthread_flag; 46713481Sgiacomo.travaglini@arm.com 46813481Sgiacomo.travaglini@arm.comvoid SetPthreadFlag() { 46913481Sgiacomo.travaglini@arm.com pthread_flag = true; 47013481Sgiacomo.travaglini@arm.com} 47113481Sgiacomo.travaglini@arm.com 47213481Sgiacomo.travaglini@arm.com} // namespace 47313481Sgiacomo.travaglini@arm.com 47413481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) { 47513481Sgiacomo.travaglini@arm.com if (!testing::GTEST_FLAG(death_test_use_fork)) { 47613481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 47713481Sgiacomo.travaglini@arm.com pthread_flag = false; 47813481Sgiacomo.travaglini@arm.com ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL)); 47913481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(1), ""); 48013481Sgiacomo.travaglini@arm.com ASSERT_FALSE(pthread_flag); 48113481Sgiacomo.travaglini@arm.com } 48213481Sgiacomo.travaglini@arm.com} 48313481Sgiacomo.travaglini@arm.com 48413481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD 48513481Sgiacomo.travaglini@arm.com 48613481Sgiacomo.travaglini@arm.com// Tests that a method of another class can be used in a death test. 48713481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, MethodOfAnotherClass) { 48813481Sgiacomo.travaglini@arm.com const MayDie x(true); 48913481Sgiacomo.travaglini@arm.com ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction"); 49013481Sgiacomo.travaglini@arm.com} 49113481Sgiacomo.travaglini@arm.com 49213481Sgiacomo.travaglini@arm.com// Tests that a global function can be used in a death test. 49313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, GlobalFunction) { 49413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), "GlobalFunction"); 49513481Sgiacomo.travaglini@arm.com} 49613481Sgiacomo.travaglini@arm.com 49713481Sgiacomo.travaglini@arm.com// Tests that any value convertible to an RE works as a second 49813481Sgiacomo.travaglini@arm.com// argument to EXPECT_DEATH. 49913481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) { 50013481Sgiacomo.travaglini@arm.com static const char regex_c_str[] = "GlobalFunction"; 50113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), regex_c_str); 50213481Sgiacomo.travaglini@arm.com 50313481Sgiacomo.travaglini@arm.com const testing::internal::RE regex(regex_c_str); 50413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), regex); 50513481Sgiacomo.travaglini@arm.com 50613481Sgiacomo.travaglini@arm.com# if GTEST_HAS_GLOBAL_STRING 50713481Sgiacomo.travaglini@arm.com 50813481Sgiacomo.travaglini@arm.com const string regex_str(regex_c_str); 50913481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), regex_str); 51013481Sgiacomo.travaglini@arm.com 51113481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_GLOBAL_STRING 51213481Sgiacomo.travaglini@arm.com 51313481Sgiacomo.travaglini@arm.com# if !GTEST_USES_PCRE 51413481Sgiacomo.travaglini@arm.com 51513481Sgiacomo.travaglini@arm.com const ::std::string regex_std_str(regex_c_str); 51613481Sgiacomo.travaglini@arm.com EXPECT_DEATH(GlobalFunction(), regex_std_str); 51713481Sgiacomo.travaglini@arm.com 51813481Sgiacomo.travaglini@arm.com# endif // !GTEST_USES_PCRE 51913481Sgiacomo.travaglini@arm.com} 52013481Sgiacomo.travaglini@arm.com 52113481Sgiacomo.travaglini@arm.com// Tests that a non-void function can be used in a death test. 52213481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, NonVoidFunction) { 52313481Sgiacomo.travaglini@arm.com ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction"); 52413481Sgiacomo.travaglini@arm.com} 52513481Sgiacomo.travaglini@arm.com 52613481Sgiacomo.travaglini@arm.com// Tests that functions that take parameter(s) can be used in a death test. 52713481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, FunctionWithParameter) { 52813481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIf(true), "DieIf\\(\\)"); 52913481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan"); 53013481Sgiacomo.travaglini@arm.com} 53113481Sgiacomo.travaglini@arm.com 53213481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture. 53313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, OutsideFixture) { 53413481Sgiacomo.travaglini@arm.com DeathTestSubroutine(); 53513481Sgiacomo.travaglini@arm.com} 53613481Sgiacomo.travaglini@arm.com 53713481Sgiacomo.travaglini@arm.com// Tests that death tests can be done inside a loop. 53813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, InsideLoop) { 53913481Sgiacomo.travaglini@arm.com for (int i = 0; i < 5; i++) { 54013481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i; 54113481Sgiacomo.travaglini@arm.com } 54213481Sgiacomo.travaglini@arm.com} 54313481Sgiacomo.travaglini@arm.com 54413481Sgiacomo.travaglini@arm.com// Tests that a compound statement can be used in a death test. 54513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, CompoundStatement) { 54613481Sgiacomo.travaglini@arm.com EXPECT_DEATH({ // NOLINT 54713481Sgiacomo.travaglini@arm.com const int x = 2; 54813481Sgiacomo.travaglini@arm.com const int y = x + 1; 54913481Sgiacomo.travaglini@arm.com DieIfLessThan(x, y); 55013481Sgiacomo.travaglini@arm.com }, 55113481Sgiacomo.travaglini@arm.com "DieIfLessThan"); 55213481Sgiacomo.travaglini@arm.com} 55313481Sgiacomo.travaglini@arm.com 55413481Sgiacomo.travaglini@arm.com// Tests that code that doesn't die causes a death test to fail. 55513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DoesNotDie) { 55613481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"), 55713481Sgiacomo.travaglini@arm.com "failed to die"); 55813481Sgiacomo.travaglini@arm.com} 55913481Sgiacomo.travaglini@arm.com 56013481Sgiacomo.travaglini@arm.com// Tests that a death test fails when the error message isn't expected. 56113481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ErrorMessageMismatch) { 56213481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE({ // NOLINT 56313481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message."; 56413481Sgiacomo.travaglini@arm.com }, "died but not with expected error"); 56513481Sgiacomo.travaglini@arm.com} 56613481Sgiacomo.travaglini@arm.com 56713481Sgiacomo.travaglini@arm.com// On exit, *aborted will be true iff the EXPECT_DEATH() statement 56813481Sgiacomo.travaglini@arm.com// aborted the function. 56913481Sgiacomo.travaglini@arm.comvoid ExpectDeathTestHelper(bool* aborted) { 57013481Sgiacomo.travaglini@arm.com *aborted = true; 57113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 57213481Sgiacomo.travaglini@arm.com *aborted = false; 57313481Sgiacomo.travaglini@arm.com} 57413481Sgiacomo.travaglini@arm.com 57513481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEATH doesn't abort the test on failure. 57613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, EXPECT_DEATH) { 57713481Sgiacomo.travaglini@arm.com bool aborted = true; 57813481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted), 57913481Sgiacomo.travaglini@arm.com "failed to die"); 58013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(aborted); 58113481Sgiacomo.travaglini@arm.com} 58213481Sgiacomo.travaglini@arm.com 58313481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEATH does abort the test on failure. 58413481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ASSERT_DEATH) { 58513481Sgiacomo.travaglini@arm.com static bool aborted; 58613481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE({ // NOLINT 58713481Sgiacomo.travaglini@arm.com aborted = true; 58813481Sgiacomo.travaglini@arm.com ASSERT_DEATH(DieIf(false), "DieIf"); // This assertion should fail. 58913481Sgiacomo.travaglini@arm.com aborted = false; 59013481Sgiacomo.travaglini@arm.com }, "failed to die"); 59113481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 59213481Sgiacomo.travaglini@arm.com} 59313481Sgiacomo.travaglini@arm.com 59413481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEATH evaluates the arguments exactly once. 59513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, SingleEvaluation) { 59613481Sgiacomo.travaglini@arm.com int x = 3; 59713481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIf((++x) == 4), "DieIf"); 59813481Sgiacomo.travaglini@arm.com 59913481Sgiacomo.travaglini@arm.com const char* regex = "DieIf"; 60013481Sgiacomo.travaglini@arm.com const char* regex_save = regex; 60113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieIfLessThan(3, 4), regex++); 60213481Sgiacomo.travaglini@arm.com EXPECT_EQ(regex_save + 1, regex); 60313481Sgiacomo.travaglini@arm.com} 60413481Sgiacomo.travaglini@arm.com 60513481Sgiacomo.travaglini@arm.com// Tests that run-away death tests are reported as failures. 60613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, RunawayIsFailure) { 60713481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"), 60813481Sgiacomo.travaglini@arm.com "failed to die."); 60913481Sgiacomo.travaglini@arm.com} 61013481Sgiacomo.travaglini@arm.com 61113481Sgiacomo.travaglini@arm.com// Tests that death tests report executing 'return' in the statement as 61213481Sgiacomo.travaglini@arm.com// failure. 61313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ReturnIsFailure) { 61413481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"), 61513481Sgiacomo.travaglini@arm.com "illegal return in test statement."); 61613481Sgiacomo.travaglini@arm.com} 61713481Sgiacomo.travaglini@arm.com 61813481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a 61913481Sgiacomo.travaglini@arm.com// message to it, and in debug mode it: 62013481Sgiacomo.travaglini@arm.com// 1. Asserts on death. 62113481Sgiacomo.travaglini@arm.com// 2. Has no side effect. 62213481Sgiacomo.travaglini@arm.com// 62313481Sgiacomo.travaglini@arm.com// And in opt mode, it: 62413481Sgiacomo.travaglini@arm.com// 1. Has side effects but does not assert. 62513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, TestExpectDebugDeath) { 62613481Sgiacomo.travaglini@arm.com int sideeffect = 0; 62713481Sgiacomo.travaglini@arm.com 62813481Sgiacomo.travaglini@arm.com EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 62913481Sgiacomo.travaglini@arm.com << "Must accept a streamed message"; 63013481Sgiacomo.travaglini@arm.com 63113481Sgiacomo.travaglini@arm.com# ifdef NDEBUG 63213481Sgiacomo.travaglini@arm.com 63313481Sgiacomo.travaglini@arm.com // Checks that the assignment occurs in opt mode (sideeffect). 63413481Sgiacomo.travaglini@arm.com EXPECT_EQ(12, sideeffect); 63513481Sgiacomo.travaglini@arm.com 63613481Sgiacomo.travaglini@arm.com# else 63713481Sgiacomo.travaglini@arm.com 63813481Sgiacomo.travaglini@arm.com // Checks that the assignment does not occur in dbg mode (no sideeffect). 63913481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, sideeffect); 64013481Sgiacomo.travaglini@arm.com 64113481Sgiacomo.travaglini@arm.com# endif 64213481Sgiacomo.travaglini@arm.com} 64313481Sgiacomo.travaglini@arm.com 64413481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a 64513481Sgiacomo.travaglini@arm.com// message to it, and in debug mode it: 64613481Sgiacomo.travaglini@arm.com// 1. Asserts on death. 64713481Sgiacomo.travaglini@arm.com// 2. Has no side effect. 64813481Sgiacomo.travaglini@arm.com// 64913481Sgiacomo.travaglini@arm.com// And in opt mode, it: 65013481Sgiacomo.travaglini@arm.com// 1. Has side effects but does not assert. 65113481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, TestAssertDebugDeath) { 65213481Sgiacomo.travaglini@arm.com int sideeffect = 0; 65313481Sgiacomo.travaglini@arm.com 65413481Sgiacomo.travaglini@arm.com ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12") 65513481Sgiacomo.travaglini@arm.com << "Must accept a streamed message"; 65613481Sgiacomo.travaglini@arm.com 65713481Sgiacomo.travaglini@arm.com# ifdef NDEBUG 65813481Sgiacomo.travaglini@arm.com 65913481Sgiacomo.travaglini@arm.com // Checks that the assignment occurs in opt mode (sideeffect). 66013481Sgiacomo.travaglini@arm.com EXPECT_EQ(12, sideeffect); 66113481Sgiacomo.travaglini@arm.com 66213481Sgiacomo.travaglini@arm.com# else 66313481Sgiacomo.travaglini@arm.com 66413481Sgiacomo.travaglini@arm.com // Checks that the assignment does not occur in dbg mode (no sideeffect). 66513481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, sideeffect); 66613481Sgiacomo.travaglini@arm.com 66713481Sgiacomo.travaglini@arm.com# endif 66813481Sgiacomo.travaglini@arm.com} 66913481Sgiacomo.travaglini@arm.com 67013481Sgiacomo.travaglini@arm.com# ifndef NDEBUG 67113481Sgiacomo.travaglini@arm.com 67213481Sgiacomo.travaglini@arm.comvoid ExpectDebugDeathHelper(bool* aborted) { 67313481Sgiacomo.travaglini@arm.com *aborted = true; 67413481Sgiacomo.travaglini@arm.com EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail."; 67513481Sgiacomo.travaglini@arm.com *aborted = false; 67613481Sgiacomo.travaglini@arm.com} 67713481Sgiacomo.travaglini@arm.com 67813481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 67913481Sgiacomo.travaglini@arm.comTEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) { 68013481Sgiacomo.travaglini@arm.com printf("This test should be considered failing if it shows " 68113481Sgiacomo.travaglini@arm.com "any pop-up dialogs.\n"); 68213481Sgiacomo.travaglini@arm.com fflush(stdout); 68313481Sgiacomo.travaglini@arm.com 68413481Sgiacomo.travaglini@arm.com EXPECT_DEATH({ 68513481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(catch_exceptions) = false; 68613481Sgiacomo.travaglini@arm.com abort(); 68713481Sgiacomo.travaglini@arm.com }, ""); 68813481Sgiacomo.travaglini@arm.com} 68913481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 69013481Sgiacomo.travaglini@arm.com 69113481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort 69213481Sgiacomo.travaglini@arm.com// the function. 69313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) { 69413481Sgiacomo.travaglini@arm.com bool aborted = true; 69513481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), ""); 69613481Sgiacomo.travaglini@arm.com EXPECT_FALSE(aborted); 69713481Sgiacomo.travaglini@arm.com} 69813481Sgiacomo.travaglini@arm.com 69913481Sgiacomo.travaglini@arm.comvoid AssertDebugDeathHelper(bool* aborted) { 70013481Sgiacomo.travaglini@arm.com *aborted = true; 70113481Sgiacomo.travaglini@arm.com GTEST_LOG_(INFO) << "Before ASSERT_DEBUG_DEATH"; 70213481Sgiacomo.travaglini@arm.com ASSERT_DEBUG_DEATH(GTEST_LOG_(INFO) << "In ASSERT_DEBUG_DEATH"; return, "") 70313481Sgiacomo.travaglini@arm.com << "This is expected to fail."; 70413481Sgiacomo.travaglini@arm.com GTEST_LOG_(INFO) << "After ASSERT_DEBUG_DEATH"; 70513481Sgiacomo.travaglini@arm.com *aborted = false; 70613481Sgiacomo.travaglini@arm.com} 70713481Sgiacomo.travaglini@arm.com 70813481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on 70913481Sgiacomo.travaglini@arm.com// failure. 71013481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts) { 71113481Sgiacomo.travaglini@arm.com static bool aborted; 71213481Sgiacomo.travaglini@arm.com aborted = false; 71313481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 71413481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 71513481Sgiacomo.travaglini@arm.com} 71613481Sgiacomo.travaglini@arm.com 71713481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts2) { 71813481Sgiacomo.travaglini@arm.com static bool aborted; 71913481Sgiacomo.travaglini@arm.com aborted = false; 72013481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 72113481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 72213481Sgiacomo.travaglini@arm.com} 72313481Sgiacomo.travaglini@arm.com 72413481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts3) { 72513481Sgiacomo.travaglini@arm.com static bool aborted; 72613481Sgiacomo.travaglini@arm.com aborted = false; 72713481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 72813481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 72913481Sgiacomo.travaglini@arm.com} 73013481Sgiacomo.travaglini@arm.com 73113481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts4) { 73213481Sgiacomo.travaglini@arm.com static bool aborted; 73313481Sgiacomo.travaglini@arm.com aborted = false; 73413481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 73513481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 73613481Sgiacomo.travaglini@arm.com} 73713481Sgiacomo.travaglini@arm.com 73813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts5) { 73913481Sgiacomo.travaglini@arm.com static bool aborted; 74013481Sgiacomo.travaglini@arm.com aborted = false; 74113481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 74213481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 74313481Sgiacomo.travaglini@arm.com} 74413481Sgiacomo.travaglini@arm.com 74513481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts6) { 74613481Sgiacomo.travaglini@arm.com static bool aborted; 74713481Sgiacomo.travaglini@arm.com aborted = false; 74813481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 74913481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 75013481Sgiacomo.travaglini@arm.com} 75113481Sgiacomo.travaglini@arm.com 75213481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts7) { 75313481Sgiacomo.travaglini@arm.com static bool aborted; 75413481Sgiacomo.travaglini@arm.com aborted = false; 75513481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 75613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 75713481Sgiacomo.travaglini@arm.com} 75813481Sgiacomo.travaglini@arm.com 75913481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts8) { 76013481Sgiacomo.travaglini@arm.com static bool aborted; 76113481Sgiacomo.travaglini@arm.com aborted = false; 76213481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 76313481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 76413481Sgiacomo.travaglini@arm.com} 76513481Sgiacomo.travaglini@arm.com 76613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts9) { 76713481Sgiacomo.travaglini@arm.com static bool aborted; 76813481Sgiacomo.travaglini@arm.com aborted = false; 76913481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 77013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 77113481Sgiacomo.travaglini@arm.com} 77213481Sgiacomo.travaglini@arm.com 77313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, AssertDebugDeathAborts10) { 77413481Sgiacomo.travaglini@arm.com static bool aborted; 77513481Sgiacomo.travaglini@arm.com aborted = false; 77613481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), ""); 77713481Sgiacomo.travaglini@arm.com EXPECT_TRUE(aborted); 77813481Sgiacomo.travaglini@arm.com} 77913481Sgiacomo.travaglini@arm.com 78013481Sgiacomo.travaglini@arm.com# endif // _NDEBUG 78113481Sgiacomo.travaglini@arm.com 78213481Sgiacomo.travaglini@arm.com// Tests the *_EXIT family of macros, using a variety of predicates. 78313481Sgiacomo.travaglini@arm.comstatic void TestExitMacros() { 78413481Sgiacomo.travaglini@arm.com EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); 78513481Sgiacomo.travaglini@arm.com ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), ""); 78613481Sgiacomo.travaglini@arm.com 78713481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 78813481Sgiacomo.travaglini@arm.com 78913481Sgiacomo.travaglini@arm.com // Of all signals effects on the process exit code, only those of SIGABRT 79013481Sgiacomo.travaglini@arm.com // are documented on Windows. 79113481Sgiacomo.travaglini@arm.com // See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx. 79213481Sgiacomo.travaglini@arm.com EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar"; 79313481Sgiacomo.travaglini@arm.com 79413481Sgiacomo.travaglini@arm.com# else 79513481Sgiacomo.travaglini@arm.com 79613481Sgiacomo.travaglini@arm.com EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo"; 79713481Sgiacomo.travaglini@arm.com ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar"; 79813481Sgiacomo.travaglini@arm.com 79913481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE({ // NOLINT 80013481Sgiacomo.travaglini@arm.com ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "") 80113481Sgiacomo.travaglini@arm.com << "This failure is expected, too."; 80213481Sgiacomo.travaglini@arm.com }, "This failure is expected, too."); 80313481Sgiacomo.travaglini@arm.com 80413481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 80513481Sgiacomo.travaglini@arm.com 80613481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE({ // NOLINT 80713481Sgiacomo.travaglini@arm.com EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "") 80813481Sgiacomo.travaglini@arm.com << "This failure is expected."; 80913481Sgiacomo.travaglini@arm.com }, "This failure is expected."); 81013481Sgiacomo.travaglini@arm.com} 81113481Sgiacomo.travaglini@arm.com 81213481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ExitMacros) { 81313481Sgiacomo.travaglini@arm.com TestExitMacros(); 81413481Sgiacomo.travaglini@arm.com} 81513481Sgiacomo.travaglini@arm.com 81613481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, ExitMacrosUsingFork) { 81713481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_use_fork) = true; 81813481Sgiacomo.travaglini@arm.com TestExitMacros(); 81913481Sgiacomo.travaglini@arm.com} 82013481Sgiacomo.travaglini@arm.com 82113481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, InvalidStyle) { 82213481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "rococo"; 82313481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE({ // NOLINT 82413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(0), "") << "This failure is expected."; 82513481Sgiacomo.travaglini@arm.com }, "This failure is expected."); 82613481Sgiacomo.travaglini@arm.com} 82713481Sgiacomo.travaglini@arm.com 82813481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DeathTestFailedOutput) { 82913481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 83013481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE( 83113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieWithMessage("death\n"), 83213481Sgiacomo.travaglini@arm.com "expected message"), 83313481Sgiacomo.travaglini@arm.com "Actual msg:\n" 83413481Sgiacomo.travaglini@arm.com "[ DEATH ] death\n"); 83513481Sgiacomo.travaglini@arm.com} 83613481Sgiacomo.travaglini@arm.com 83713481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) { 83813481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 83913481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE( 84013481Sgiacomo.travaglini@arm.com EXPECT_DEATH({ 84113481Sgiacomo.travaglini@arm.com fprintf(stderr, "returning\n"); 84213481Sgiacomo.travaglini@arm.com fflush(stderr); 84313481Sgiacomo.travaglini@arm.com return; 84413481Sgiacomo.travaglini@arm.com }, ""), 84513481Sgiacomo.travaglini@arm.com " Result: illegal return in test statement.\n" 84613481Sgiacomo.travaglini@arm.com " Error msg:\n" 84713481Sgiacomo.travaglini@arm.com "[ DEATH ] returning\n"); 84813481Sgiacomo.travaglini@arm.com} 84913481Sgiacomo.travaglini@arm.com 85013481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) { 85113481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 85213481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE( 85313481Sgiacomo.travaglini@arm.com EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"), 85413481Sgiacomo.travaglini@arm.com testing::ExitedWithCode(3), 85513481Sgiacomo.travaglini@arm.com "expected message"), 85613481Sgiacomo.travaglini@arm.com " Result: died but not with expected exit code:\n" 85713481Sgiacomo.travaglini@arm.com " Exited with exit status 1\n" 85813481Sgiacomo.travaglini@arm.com "Actual msg:\n" 85913481Sgiacomo.travaglini@arm.com "[ DEATH ] exiting with rc 1\n"); 86013481Sgiacomo.travaglini@arm.com} 86113481Sgiacomo.travaglini@arm.com 86213481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) { 86313481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 86413481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE( 86513481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 86613481Sgiacomo.travaglini@arm.com "line 1\nxyz\nline 3\n"), 86713481Sgiacomo.travaglini@arm.com "Actual msg:\n" 86813481Sgiacomo.travaglini@arm.com "[ DEATH ] line 1\n" 86913481Sgiacomo.travaglini@arm.com "[ DEATH ] line 2\n" 87013481Sgiacomo.travaglini@arm.com "[ DEATH ] line 3\n"); 87113481Sgiacomo.travaglini@arm.com} 87213481Sgiacomo.travaglini@arm.com 87313481Sgiacomo.travaglini@arm.comTEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) { 87413481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 87513481Sgiacomo.travaglini@arm.com EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"), 87613481Sgiacomo.travaglini@arm.com "line 1\nline 2\nline 3\n"); 87713481Sgiacomo.travaglini@arm.com} 87813481Sgiacomo.travaglini@arm.com 87913481Sgiacomo.travaglini@arm.com// A DeathTestFactory that returns MockDeathTests. 88013481Sgiacomo.travaglini@arm.comclass MockDeathTestFactory : public DeathTestFactory { 88113481Sgiacomo.travaglini@arm.com public: 88213481Sgiacomo.travaglini@arm.com MockDeathTestFactory(); 88313481Sgiacomo.travaglini@arm.com virtual bool Create(const char* statement, 88413481Sgiacomo.travaglini@arm.com const ::testing::internal::RE* regex, 88513481Sgiacomo.travaglini@arm.com const char* file, int line, DeathTest** test); 88613481Sgiacomo.travaglini@arm.com 88713481Sgiacomo.travaglini@arm.com // Sets the parameters for subsequent calls to Create. 88813481Sgiacomo.travaglini@arm.com void SetParameters(bool create, DeathTest::TestRole role, 88913481Sgiacomo.travaglini@arm.com int status, bool passed); 89013481Sgiacomo.travaglini@arm.com 89113481Sgiacomo.travaglini@arm.com // Accessors. 89213481Sgiacomo.travaglini@arm.com int AssumeRoleCalls() const { return assume_role_calls_; } 89313481Sgiacomo.travaglini@arm.com int WaitCalls() const { return wait_calls_; } 89413481Sgiacomo.travaglini@arm.com size_t PassedCalls() const { return passed_args_.size(); } 89513481Sgiacomo.travaglini@arm.com bool PassedArgument(int n) const { return passed_args_[n]; } 89613481Sgiacomo.travaglini@arm.com size_t AbortCalls() const { return abort_args_.size(); } 89713481Sgiacomo.travaglini@arm.com DeathTest::AbortReason AbortArgument(int n) const { 89813481Sgiacomo.travaglini@arm.com return abort_args_[n]; 89913481Sgiacomo.travaglini@arm.com } 90013481Sgiacomo.travaglini@arm.com bool TestDeleted() const { return test_deleted_; } 90113481Sgiacomo.travaglini@arm.com 90213481Sgiacomo.travaglini@arm.com private: 90313481Sgiacomo.travaglini@arm.com friend class MockDeathTest; 90413481Sgiacomo.travaglini@arm.com // If true, Create will return a MockDeathTest; otherwise it returns 90513481Sgiacomo.travaglini@arm.com // NULL. 90613481Sgiacomo.travaglini@arm.com bool create_; 90713481Sgiacomo.travaglini@arm.com // The value a MockDeathTest will return from its AssumeRole method. 90813481Sgiacomo.travaglini@arm.com DeathTest::TestRole role_; 90913481Sgiacomo.travaglini@arm.com // The value a MockDeathTest will return from its Wait method. 91013481Sgiacomo.travaglini@arm.com int status_; 91113481Sgiacomo.travaglini@arm.com // The value a MockDeathTest will return from its Passed method. 91213481Sgiacomo.travaglini@arm.com bool passed_; 91313481Sgiacomo.travaglini@arm.com 91413481Sgiacomo.travaglini@arm.com // Number of times AssumeRole was called. 91513481Sgiacomo.travaglini@arm.com int assume_role_calls_; 91613481Sgiacomo.travaglini@arm.com // Number of times Wait was called. 91713481Sgiacomo.travaglini@arm.com int wait_calls_; 91813481Sgiacomo.travaglini@arm.com // The arguments to the calls to Passed since the last call to 91913481Sgiacomo.travaglini@arm.com // SetParameters. 92013481Sgiacomo.travaglini@arm.com std::vector<bool> passed_args_; 92113481Sgiacomo.travaglini@arm.com // The arguments to the calls to Abort since the last call to 92213481Sgiacomo.travaglini@arm.com // SetParameters. 92313481Sgiacomo.travaglini@arm.com std::vector<DeathTest::AbortReason> abort_args_; 92413481Sgiacomo.travaglini@arm.com // True if the last MockDeathTest returned by Create has been 92513481Sgiacomo.travaglini@arm.com // deleted. 92613481Sgiacomo.travaglini@arm.com bool test_deleted_; 92713481Sgiacomo.travaglini@arm.com}; 92813481Sgiacomo.travaglini@arm.com 92913481Sgiacomo.travaglini@arm.com 93013481Sgiacomo.travaglini@arm.com// A DeathTest implementation useful in testing. It returns values set 93113481Sgiacomo.travaglini@arm.com// at its creation from its various inherited DeathTest methods, and 93213481Sgiacomo.travaglini@arm.com// reports calls to those methods to its parent MockDeathTestFactory 93313481Sgiacomo.travaglini@arm.com// object. 93413481Sgiacomo.travaglini@arm.comclass MockDeathTest : public DeathTest { 93513481Sgiacomo.travaglini@arm.com public: 93613481Sgiacomo.travaglini@arm.com MockDeathTest(MockDeathTestFactory *parent, 93713481Sgiacomo.travaglini@arm.com TestRole role, int status, bool passed) : 93813481Sgiacomo.travaglini@arm.com parent_(parent), role_(role), status_(status), passed_(passed) { 93913481Sgiacomo.travaglini@arm.com } 94013481Sgiacomo.travaglini@arm.com virtual ~MockDeathTest() { 94113481Sgiacomo.travaglini@arm.com parent_->test_deleted_ = true; 94213481Sgiacomo.travaglini@arm.com } 94313481Sgiacomo.travaglini@arm.com virtual TestRole AssumeRole() { 94413481Sgiacomo.travaglini@arm.com ++parent_->assume_role_calls_; 94513481Sgiacomo.travaglini@arm.com return role_; 94613481Sgiacomo.travaglini@arm.com } 94713481Sgiacomo.travaglini@arm.com virtual int Wait() { 94813481Sgiacomo.travaglini@arm.com ++parent_->wait_calls_; 94913481Sgiacomo.travaglini@arm.com return status_; 95013481Sgiacomo.travaglini@arm.com } 95113481Sgiacomo.travaglini@arm.com virtual bool Passed(bool exit_status_ok) { 95213481Sgiacomo.travaglini@arm.com parent_->passed_args_.push_back(exit_status_ok); 95313481Sgiacomo.travaglini@arm.com return passed_; 95413481Sgiacomo.travaglini@arm.com } 95513481Sgiacomo.travaglini@arm.com virtual void Abort(AbortReason reason) { 95613481Sgiacomo.travaglini@arm.com parent_->abort_args_.push_back(reason); 95713481Sgiacomo.travaglini@arm.com } 95813481Sgiacomo.travaglini@arm.com 95913481Sgiacomo.travaglini@arm.com private: 96013481Sgiacomo.travaglini@arm.com MockDeathTestFactory* const parent_; 96113481Sgiacomo.travaglini@arm.com const TestRole role_; 96213481Sgiacomo.travaglini@arm.com const int status_; 96313481Sgiacomo.travaglini@arm.com const bool passed_; 96413481Sgiacomo.travaglini@arm.com}; 96513481Sgiacomo.travaglini@arm.com 96613481Sgiacomo.travaglini@arm.com 96713481Sgiacomo.travaglini@arm.com// MockDeathTestFactory constructor. 96813481Sgiacomo.travaglini@arm.comMockDeathTestFactory::MockDeathTestFactory() 96913481Sgiacomo.travaglini@arm.com : create_(true), 97013481Sgiacomo.travaglini@arm.com role_(DeathTest::OVERSEE_TEST), 97113481Sgiacomo.travaglini@arm.com status_(0), 97213481Sgiacomo.travaglini@arm.com passed_(true), 97313481Sgiacomo.travaglini@arm.com assume_role_calls_(0), 97413481Sgiacomo.travaglini@arm.com wait_calls_(0), 97513481Sgiacomo.travaglini@arm.com passed_args_(), 97613481Sgiacomo.travaglini@arm.com abort_args_() { 97713481Sgiacomo.travaglini@arm.com} 97813481Sgiacomo.travaglini@arm.com 97913481Sgiacomo.travaglini@arm.com 98013481Sgiacomo.travaglini@arm.com// Sets the parameters for subsequent calls to Create. 98113481Sgiacomo.travaglini@arm.comvoid MockDeathTestFactory::SetParameters(bool create, 98213481Sgiacomo.travaglini@arm.com DeathTest::TestRole role, 98313481Sgiacomo.travaglini@arm.com int status, bool passed) { 98413481Sgiacomo.travaglini@arm.com create_ = create; 98513481Sgiacomo.travaglini@arm.com role_ = role; 98613481Sgiacomo.travaglini@arm.com status_ = status; 98713481Sgiacomo.travaglini@arm.com passed_ = passed; 98813481Sgiacomo.travaglini@arm.com 98913481Sgiacomo.travaglini@arm.com assume_role_calls_ = 0; 99013481Sgiacomo.travaglini@arm.com wait_calls_ = 0; 99113481Sgiacomo.travaglini@arm.com passed_args_.clear(); 99213481Sgiacomo.travaglini@arm.com abort_args_.clear(); 99313481Sgiacomo.travaglini@arm.com} 99413481Sgiacomo.travaglini@arm.com 99513481Sgiacomo.travaglini@arm.com 99613481Sgiacomo.travaglini@arm.com// Sets test to NULL (if create_ is false) or to the address of a new 99713481Sgiacomo.travaglini@arm.com// MockDeathTest object with parameters taken from the last call 99813481Sgiacomo.travaglini@arm.com// to SetParameters (if create_ is true). Always returns true. 99913481Sgiacomo.travaglini@arm.combool MockDeathTestFactory::Create(const char* /*statement*/, 100013481Sgiacomo.travaglini@arm.com const ::testing::internal::RE* /*regex*/, 100113481Sgiacomo.travaglini@arm.com const char* /*file*/, 100213481Sgiacomo.travaglini@arm.com int /*line*/, 100313481Sgiacomo.travaglini@arm.com DeathTest** test) { 100413481Sgiacomo.travaglini@arm.com test_deleted_ = false; 100513481Sgiacomo.travaglini@arm.com if (create_) { 100613481Sgiacomo.travaglini@arm.com *test = new MockDeathTest(this, role_, status_, passed_); 100713481Sgiacomo.travaglini@arm.com } else { 100813481Sgiacomo.travaglini@arm.com *test = NULL; 100913481Sgiacomo.travaglini@arm.com } 101013481Sgiacomo.travaglini@arm.com return true; 101113481Sgiacomo.travaglini@arm.com} 101213481Sgiacomo.travaglini@arm.com 101313481Sgiacomo.travaglini@arm.com// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro. 101413481Sgiacomo.travaglini@arm.com// It installs a MockDeathTestFactory that is used for the duration 101513481Sgiacomo.travaglini@arm.com// of the test case. 101613481Sgiacomo.travaglini@arm.comclass MacroLogicDeathTest : public testing::Test { 101713481Sgiacomo.travaglini@arm.com protected: 101813481Sgiacomo.travaglini@arm.com static testing::internal::ReplaceDeathTestFactory* replacer_; 101913481Sgiacomo.travaglini@arm.com static MockDeathTestFactory* factory_; 102013481Sgiacomo.travaglini@arm.com 102113481Sgiacomo.travaglini@arm.com static void SetUpTestCase() { 102213481Sgiacomo.travaglini@arm.com factory_ = new MockDeathTestFactory; 102313481Sgiacomo.travaglini@arm.com replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_); 102413481Sgiacomo.travaglini@arm.com } 102513481Sgiacomo.travaglini@arm.com 102613481Sgiacomo.travaglini@arm.com static void TearDownTestCase() { 102713481Sgiacomo.travaglini@arm.com delete replacer_; 102813481Sgiacomo.travaglini@arm.com replacer_ = NULL; 102913481Sgiacomo.travaglini@arm.com delete factory_; 103013481Sgiacomo.travaglini@arm.com factory_ = NULL; 103113481Sgiacomo.travaglini@arm.com } 103213481Sgiacomo.travaglini@arm.com 103313481Sgiacomo.travaglini@arm.com // Runs a death test that breaks the rules by returning. Such a death 103413481Sgiacomo.travaglini@arm.com // test cannot be run directly from a test routine that uses a 103513481Sgiacomo.travaglini@arm.com // MockDeathTest, or the remainder of the routine will not be executed. 103613481Sgiacomo.travaglini@arm.com static void RunReturningDeathTest(bool* flag) { 103713481Sgiacomo.travaglini@arm.com ASSERT_DEATH({ // NOLINT 103813481Sgiacomo.travaglini@arm.com *flag = true; 103913481Sgiacomo.travaglini@arm.com return; 104013481Sgiacomo.travaglini@arm.com }, ""); 104113481Sgiacomo.travaglini@arm.com } 104213481Sgiacomo.travaglini@arm.com}; 104313481Sgiacomo.travaglini@arm.com 104413481Sgiacomo.travaglini@arm.comtesting::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ 104513481Sgiacomo.travaglini@arm.com = NULL; 104613481Sgiacomo.travaglini@arm.comMockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL; 104713481Sgiacomo.travaglini@arm.com 104813481Sgiacomo.travaglini@arm.com 104913481Sgiacomo.travaglini@arm.com// Test that nothing happens when the factory doesn't return a DeathTest: 105013481Sgiacomo.travaglini@arm.comTEST_F(MacroLogicDeathTest, NothingHappens) { 105113481Sgiacomo.travaglini@arm.com bool flag = false; 105213481Sgiacomo.travaglini@arm.com factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true); 105313481Sgiacomo.travaglini@arm.com EXPECT_DEATH(flag = true, ""); 105413481Sgiacomo.travaglini@arm.com EXPECT_FALSE(flag); 105513481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, factory_->AssumeRoleCalls()); 105613481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, factory_->WaitCalls()); 105713481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->PassedCalls()); 105813481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->AbortCalls()); 105913481Sgiacomo.travaglini@arm.com EXPECT_FALSE(factory_->TestDeleted()); 106013481Sgiacomo.travaglini@arm.com} 106113481Sgiacomo.travaglini@arm.com 106213481Sgiacomo.travaglini@arm.com// Test that the parent process doesn't run the death test code, 106313481Sgiacomo.travaglini@arm.com// and that the Passed method returns false when the (simulated) 106413481Sgiacomo.travaglini@arm.com// child process exits with status 0: 106513481Sgiacomo.travaglini@arm.comTEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) { 106613481Sgiacomo.travaglini@arm.com bool flag = false; 106713481Sgiacomo.travaglini@arm.com factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true); 106813481Sgiacomo.travaglini@arm.com EXPECT_DEATH(flag = true, ""); 106913481Sgiacomo.travaglini@arm.com EXPECT_FALSE(flag); 107013481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->AssumeRoleCalls()); 107113481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->WaitCalls()); 107213481Sgiacomo.travaglini@arm.com ASSERT_EQ(1U, factory_->PassedCalls()); 107313481Sgiacomo.travaglini@arm.com EXPECT_FALSE(factory_->PassedArgument(0)); 107413481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->AbortCalls()); 107513481Sgiacomo.travaglini@arm.com EXPECT_TRUE(factory_->TestDeleted()); 107613481Sgiacomo.travaglini@arm.com} 107713481Sgiacomo.travaglini@arm.com 107813481Sgiacomo.travaglini@arm.com// Tests that the Passed method was given the argument "true" when 107913481Sgiacomo.travaglini@arm.com// the (simulated) child process exits with status 1: 108013481Sgiacomo.travaglini@arm.comTEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) { 108113481Sgiacomo.travaglini@arm.com bool flag = false; 108213481Sgiacomo.travaglini@arm.com factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true); 108313481Sgiacomo.travaglini@arm.com EXPECT_DEATH(flag = true, ""); 108413481Sgiacomo.travaglini@arm.com EXPECT_FALSE(flag); 108513481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->AssumeRoleCalls()); 108613481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->WaitCalls()); 108713481Sgiacomo.travaglini@arm.com ASSERT_EQ(1U, factory_->PassedCalls()); 108813481Sgiacomo.travaglini@arm.com EXPECT_TRUE(factory_->PassedArgument(0)); 108913481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->AbortCalls()); 109013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(factory_->TestDeleted()); 109113481Sgiacomo.travaglini@arm.com} 109213481Sgiacomo.travaglini@arm.com 109313481Sgiacomo.travaglini@arm.com// Tests that the (simulated) child process executes the death test 109413481Sgiacomo.travaglini@arm.com// code, and is aborted with the correct AbortReason if it 109513481Sgiacomo.travaglini@arm.com// executes a return statement. 109613481Sgiacomo.travaglini@arm.comTEST_F(MacroLogicDeathTest, ChildPerformsReturn) { 109713481Sgiacomo.travaglini@arm.com bool flag = false; 109813481Sgiacomo.travaglini@arm.com factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 109913481Sgiacomo.travaglini@arm.com RunReturningDeathTest(&flag); 110013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(flag); 110113481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->AssumeRoleCalls()); 110213481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, factory_->WaitCalls()); 110313481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->PassedCalls()); 110413481Sgiacomo.travaglini@arm.com EXPECT_EQ(1U, factory_->AbortCalls()); 110513481Sgiacomo.travaglini@arm.com EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 110613481Sgiacomo.travaglini@arm.com factory_->AbortArgument(0)); 110713481Sgiacomo.travaglini@arm.com EXPECT_TRUE(factory_->TestDeleted()); 110813481Sgiacomo.travaglini@arm.com} 110913481Sgiacomo.travaglini@arm.com 111013481Sgiacomo.travaglini@arm.com// Tests that the (simulated) child process is aborted with the 111113481Sgiacomo.travaglini@arm.com// correct AbortReason if it does not die. 111213481Sgiacomo.travaglini@arm.comTEST_F(MacroLogicDeathTest, ChildDoesNotDie) { 111313481Sgiacomo.travaglini@arm.com bool flag = false; 111413481Sgiacomo.travaglini@arm.com factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true); 111513481Sgiacomo.travaglini@arm.com EXPECT_DEATH(flag = true, ""); 111613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(flag); 111713481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, factory_->AssumeRoleCalls()); 111813481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, factory_->WaitCalls()); 111913481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, factory_->PassedCalls()); 112013481Sgiacomo.travaglini@arm.com // This time there are two calls to Abort: one since the test didn't 112113481Sgiacomo.travaglini@arm.com // die, and another from the ReturnSentinel when it's destroyed. The 112213481Sgiacomo.travaglini@arm.com // sentinel normally isn't destroyed if a test doesn't die, since 112313481Sgiacomo.travaglini@arm.com // _exit(2) is called in that case by ForkingDeathTest, but not by 112413481Sgiacomo.travaglini@arm.com // our MockDeathTest. 112513481Sgiacomo.travaglini@arm.com ASSERT_EQ(2U, factory_->AbortCalls()); 112613481Sgiacomo.travaglini@arm.com EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, 112713481Sgiacomo.travaglini@arm.com factory_->AbortArgument(0)); 112813481Sgiacomo.travaglini@arm.com EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT, 112913481Sgiacomo.travaglini@arm.com factory_->AbortArgument(1)); 113013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(factory_->TestDeleted()); 113113481Sgiacomo.travaglini@arm.com} 113213481Sgiacomo.travaglini@arm.com 113313481Sgiacomo.travaglini@arm.com// Tests that a successful death test does not register a successful 113413481Sgiacomo.travaglini@arm.com// test part. 113513481Sgiacomo.travaglini@arm.comTEST(SuccessRegistrationDeathTest, NoSuccessPart) { 113613481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), ""); 113713481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 113813481Sgiacomo.travaglini@arm.com} 113913481Sgiacomo.travaglini@arm.com 114013481Sgiacomo.travaglini@arm.comTEST(StreamingAssertionsDeathTest, DeathTest) { 114113481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(1), "") << "unexpected failure"; 114213481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(1), "") << "unexpected failure"; 114313481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE({ // NOLINT 114413481Sgiacomo.travaglini@arm.com EXPECT_DEATH(_exit(0), "") << "expected failure"; 114513481Sgiacomo.travaglini@arm.com }, "expected failure"); 114613481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE({ // NOLINT 114713481Sgiacomo.travaglini@arm.com ASSERT_DEATH(_exit(0), "") << "expected failure"; 114813481Sgiacomo.travaglini@arm.com }, "expected failure"); 114913481Sgiacomo.travaglini@arm.com} 115013481Sgiacomo.travaglini@arm.com 115113481Sgiacomo.travaglini@arm.com// Tests that GetLastErrnoDescription returns an empty string when the 115213481Sgiacomo.travaglini@arm.com// last error is 0 and non-empty string when it is non-zero. 115313481Sgiacomo.travaglini@arm.comTEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) { 115413481Sgiacomo.travaglini@arm.com errno = ENOENT; 115513481Sgiacomo.travaglini@arm.com EXPECT_STRNE("", GetLastErrnoDescription().c_str()); 115613481Sgiacomo.travaglini@arm.com errno = 0; 115713481Sgiacomo.travaglini@arm.com EXPECT_STREQ("", GetLastErrnoDescription().c_str()); 115813481Sgiacomo.travaglini@arm.com} 115913481Sgiacomo.travaglini@arm.com 116013481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 116113481Sgiacomo.travaglini@arm.comTEST(AutoHandleTest, AutoHandleWorks) { 116213481Sgiacomo.travaglini@arm.com HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 116313481Sgiacomo.travaglini@arm.com ASSERT_NE(INVALID_HANDLE_VALUE, handle); 116413481Sgiacomo.travaglini@arm.com 116513481Sgiacomo.travaglini@arm.com // Tests that the AutoHandle is correctly initialized with a handle. 116613481Sgiacomo.travaglini@arm.com testing::internal::AutoHandle auto_handle(handle); 116713481Sgiacomo.travaglini@arm.com EXPECT_EQ(handle, auto_handle.Get()); 116813481Sgiacomo.travaglini@arm.com 116913481Sgiacomo.travaglini@arm.com // Tests that Reset assigns INVALID_HANDLE_VALUE. 117013481Sgiacomo.travaglini@arm.com // Note that this cannot verify whether the original handle is closed. 117113481Sgiacomo.travaglini@arm.com auto_handle.Reset(); 117213481Sgiacomo.travaglini@arm.com EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get()); 117313481Sgiacomo.travaglini@arm.com 117413481Sgiacomo.travaglini@arm.com // Tests that Reset assigns the new handle. 117513481Sgiacomo.travaglini@arm.com // Note that this cannot verify whether the original handle is closed. 117613481Sgiacomo.travaglini@arm.com handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); 117713481Sgiacomo.travaglini@arm.com ASSERT_NE(INVALID_HANDLE_VALUE, handle); 117813481Sgiacomo.travaglini@arm.com auto_handle.Reset(handle); 117913481Sgiacomo.travaglini@arm.com EXPECT_EQ(handle, auto_handle.Get()); 118013481Sgiacomo.travaglini@arm.com 118113481Sgiacomo.travaglini@arm.com // Tests that AutoHandle contains INVALID_HANDLE_VALUE by default. 118213481Sgiacomo.travaglini@arm.com testing::internal::AutoHandle auto_handle2; 118313481Sgiacomo.travaglini@arm.com EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get()); 118413481Sgiacomo.travaglini@arm.com} 118513481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 118613481Sgiacomo.travaglini@arm.com 118713481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 118813481Sgiacomo.travaglini@arm.comtypedef unsigned __int64 BiggestParsable; 118913481Sgiacomo.travaglini@arm.comtypedef signed __int64 BiggestSignedParsable; 119013481Sgiacomo.travaglini@arm.com# else 119113481Sgiacomo.travaglini@arm.comtypedef unsigned long long BiggestParsable; 119213481Sgiacomo.travaglini@arm.comtypedef signed long long BiggestSignedParsable; 119313481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 119413481Sgiacomo.travaglini@arm.com 119513481Sgiacomo.travaglini@arm.com// We cannot use std::numeric_limits<T>::max() as it clashes with the 119613481Sgiacomo.travaglini@arm.com// max() macro defined by <windows.h>. 119713481Sgiacomo.travaglini@arm.comconst BiggestParsable kBiggestParsableMax = ULLONG_MAX; 119813481Sgiacomo.travaglini@arm.comconst BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX; 119913481Sgiacomo.travaglini@arm.com 120013481Sgiacomo.travaglini@arm.comTEST(ParseNaturalNumberTest, RejectsInvalidFormat) { 120113481Sgiacomo.travaglini@arm.com BiggestParsable result = 0; 120213481Sgiacomo.travaglini@arm.com 120313481Sgiacomo.travaglini@arm.com // Rejects non-numbers. 120413481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber("non-number string", &result)); 120513481Sgiacomo.travaglini@arm.com 120613481Sgiacomo.travaglini@arm.com // Rejects numbers with whitespace prefix. 120713481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber(" 123", &result)); 120813481Sgiacomo.travaglini@arm.com 120913481Sgiacomo.travaglini@arm.com // Rejects negative numbers. 121013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber("-123", &result)); 121113481Sgiacomo.travaglini@arm.com 121213481Sgiacomo.travaglini@arm.com // Rejects numbers starting with a plus sign. 121313481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber("+123", &result)); 121413481Sgiacomo.travaglini@arm.com errno = 0; 121513481Sgiacomo.travaglini@arm.com} 121613481Sgiacomo.travaglini@arm.com 121713481Sgiacomo.travaglini@arm.comTEST(ParseNaturalNumberTest, RejectsOverflownNumbers) { 121813481Sgiacomo.travaglini@arm.com BiggestParsable result = 0; 121913481Sgiacomo.travaglini@arm.com 122013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result)); 122113481Sgiacomo.travaglini@arm.com 122213481Sgiacomo.travaglini@arm.com signed char char_result = 0; 122313481Sgiacomo.travaglini@arm.com EXPECT_FALSE(ParseNaturalNumber("200", &char_result)); 122413481Sgiacomo.travaglini@arm.com errno = 0; 122513481Sgiacomo.travaglini@arm.com} 122613481Sgiacomo.travaglini@arm.com 122713481Sgiacomo.travaglini@arm.comTEST(ParseNaturalNumberTest, AcceptsValidNumbers) { 122813481Sgiacomo.travaglini@arm.com BiggestParsable result = 0; 122913481Sgiacomo.travaglini@arm.com 123013481Sgiacomo.travaglini@arm.com result = 0; 123113481Sgiacomo.travaglini@arm.com ASSERT_TRUE(ParseNaturalNumber("123", &result)); 123213481Sgiacomo.travaglini@arm.com EXPECT_EQ(123U, result); 123313481Sgiacomo.travaglini@arm.com 123413481Sgiacomo.travaglini@arm.com // Check 0 as an edge case. 123513481Sgiacomo.travaglini@arm.com result = 1; 123613481Sgiacomo.travaglini@arm.com ASSERT_TRUE(ParseNaturalNumber("0", &result)); 123713481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, result); 123813481Sgiacomo.travaglini@arm.com 123913481Sgiacomo.travaglini@arm.com result = 1; 124013481Sgiacomo.travaglini@arm.com ASSERT_TRUE(ParseNaturalNumber("00000", &result)); 124113481Sgiacomo.travaglini@arm.com EXPECT_EQ(0U, result); 124213481Sgiacomo.travaglini@arm.com} 124313481Sgiacomo.travaglini@arm.com 124413481Sgiacomo.travaglini@arm.comTEST(ParseNaturalNumberTest, AcceptsTypeLimits) { 124513481Sgiacomo.travaglini@arm.com Message msg; 124613481Sgiacomo.travaglini@arm.com msg << kBiggestParsableMax; 124713481Sgiacomo.travaglini@arm.com 124813481Sgiacomo.travaglini@arm.com BiggestParsable result = 0; 124913481Sgiacomo.travaglini@arm.com EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result)); 125013481Sgiacomo.travaglini@arm.com EXPECT_EQ(kBiggestParsableMax, result); 125113481Sgiacomo.travaglini@arm.com 125213481Sgiacomo.travaglini@arm.com Message msg2; 125313481Sgiacomo.travaglini@arm.com msg2 << kBiggestSignedParsableMax; 125413481Sgiacomo.travaglini@arm.com 125513481Sgiacomo.travaglini@arm.com BiggestSignedParsable signed_result = 0; 125613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result)); 125713481Sgiacomo.travaglini@arm.com EXPECT_EQ(kBiggestSignedParsableMax, signed_result); 125813481Sgiacomo.travaglini@arm.com 125913481Sgiacomo.travaglini@arm.com Message msg3; 126013481Sgiacomo.travaglini@arm.com msg3 << INT_MAX; 126113481Sgiacomo.travaglini@arm.com 126213481Sgiacomo.travaglini@arm.com int int_result = 0; 126313481Sgiacomo.travaglini@arm.com EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result)); 126413481Sgiacomo.travaglini@arm.com EXPECT_EQ(INT_MAX, int_result); 126513481Sgiacomo.travaglini@arm.com 126613481Sgiacomo.travaglini@arm.com Message msg4; 126713481Sgiacomo.travaglini@arm.com msg4 << UINT_MAX; 126813481Sgiacomo.travaglini@arm.com 126913481Sgiacomo.travaglini@arm.com unsigned int uint_result = 0; 127013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result)); 127113481Sgiacomo.travaglini@arm.com EXPECT_EQ(UINT_MAX, uint_result); 127213481Sgiacomo.travaglini@arm.com} 127313481Sgiacomo.travaglini@arm.com 127413481Sgiacomo.travaglini@arm.comTEST(ParseNaturalNumberTest, WorksForShorterIntegers) { 127513481Sgiacomo.travaglini@arm.com short short_result = 0; 127613481Sgiacomo.travaglini@arm.com ASSERT_TRUE(ParseNaturalNumber("123", &short_result)); 127713481Sgiacomo.travaglini@arm.com EXPECT_EQ(123, short_result); 127813481Sgiacomo.travaglini@arm.com 127913481Sgiacomo.travaglini@arm.com signed char char_result = 0; 128013481Sgiacomo.travaglini@arm.com ASSERT_TRUE(ParseNaturalNumber("123", &char_result)); 128113481Sgiacomo.travaglini@arm.com EXPECT_EQ(123, char_result); 128213481Sgiacomo.travaglini@arm.com} 128313481Sgiacomo.travaglini@arm.com 128413481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS 128513481Sgiacomo.travaglini@arm.comTEST(EnvironmentTest, HandleFitsIntoSizeT) { 128613481Sgiacomo.travaglini@arm.com // TODO(vladl@google.com): Remove this test after this condition is verified 128713481Sgiacomo.travaglini@arm.com // in a static assertion in gtest-death-test.cc in the function 128813481Sgiacomo.travaglini@arm.com // GetStatusFileDescriptor. 128913481Sgiacomo.travaglini@arm.com ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t)); 129013481Sgiacomo.travaglini@arm.com} 129113481Sgiacomo.travaglini@arm.com# endif // GTEST_OS_WINDOWS 129213481Sgiacomo.travaglini@arm.com 129313481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger 129413481Sgiacomo.travaglini@arm.com// failures when death tests are available on the system. 129513481Sgiacomo.travaglini@arm.comTEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) { 129613481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"), 129713481Sgiacomo.travaglini@arm.com "death inside CondDeathTestExpectMacro"); 129813481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"), 129913481Sgiacomo.travaglini@arm.com "death inside CondDeathTestAssertMacro"); 130013481Sgiacomo.travaglini@arm.com 130113481Sgiacomo.travaglini@arm.com // Empty statement will not crash, which must trigger a failure. 130213481Sgiacomo.travaglini@arm.com EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), ""); 130313481Sgiacomo.travaglini@arm.com EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), ""); 130413481Sgiacomo.travaglini@arm.com} 130513481Sgiacomo.travaglini@arm.com 130613481Sgiacomo.travaglini@arm.comTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) { 130713481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "fast"; 130813481Sgiacomo.travaglini@arm.com EXPECT_FALSE(InDeathTestChild()); 130913481Sgiacomo.travaglini@arm.com EXPECT_DEATH({ 131013481Sgiacomo.travaglini@arm.com fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 131113481Sgiacomo.travaglini@arm.com fflush(stderr); 131213481Sgiacomo.travaglini@arm.com _exit(1); 131313481Sgiacomo.travaglini@arm.com }, "Inside"); 131413481Sgiacomo.travaglini@arm.com} 131513481Sgiacomo.travaglini@arm.com 131613481Sgiacomo.travaglini@arm.comTEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) { 131713481Sgiacomo.travaglini@arm.com testing::GTEST_FLAG(death_test_style) = "threadsafe"; 131813481Sgiacomo.travaglini@arm.com EXPECT_FALSE(InDeathTestChild()); 131913481Sgiacomo.travaglini@arm.com EXPECT_DEATH({ 132013481Sgiacomo.travaglini@arm.com fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside"); 132113481Sgiacomo.travaglini@arm.com fflush(stderr); 132213481Sgiacomo.travaglini@arm.com _exit(1); 132313481Sgiacomo.travaglini@arm.com }, "Inside"); 132413481Sgiacomo.travaglini@arm.com} 132513481Sgiacomo.travaglini@arm.com 132613481Sgiacomo.travaglini@arm.com#else // !GTEST_HAS_DEATH_TEST follows 132713481Sgiacomo.travaglini@arm.com 132813481Sgiacomo.travaglini@arm.comusing testing::internal::CaptureStderr; 132913481Sgiacomo.travaglini@arm.comusing testing::internal::GetCapturedStderr; 133013481Sgiacomo.travaglini@arm.com 133113481Sgiacomo.travaglini@arm.com// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still 133213481Sgiacomo.travaglini@arm.com// defined but do not trigger failures when death tests are not available on 133313481Sgiacomo.travaglini@arm.com// the system. 133413481Sgiacomo.travaglini@arm.comTEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) { 133513481Sgiacomo.travaglini@arm.com // Empty statement will not crash, but that should not trigger a failure 133613481Sgiacomo.travaglini@arm.com // when death tests are not supported. 133713481Sgiacomo.travaglini@arm.com CaptureStderr(); 133813481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(;, ""); 133913481Sgiacomo.travaglini@arm.com std::string output = GetCapturedStderr(); 134013481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL != strstr(output.c_str(), 134113481Sgiacomo.travaglini@arm.com "Death tests are not supported on this platform")); 134213481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 134313481Sgiacomo.travaglini@arm.com 134413481Sgiacomo.travaglini@arm.com // The streamed message should not be printed as there is no test failure. 134513481Sgiacomo.travaglini@arm.com CaptureStderr(); 134613481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; 134713481Sgiacomo.travaglini@arm.com output = GetCapturedStderr(); 134813481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 134913481Sgiacomo.travaglini@arm.com 135013481Sgiacomo.travaglini@arm.com CaptureStderr(); 135113481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(;, ""); // NOLINT 135213481Sgiacomo.travaglini@arm.com output = GetCapturedStderr(); 135313481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL != strstr(output.c_str(), 135413481Sgiacomo.travaglini@arm.com "Death tests are not supported on this platform")); 135513481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL != strstr(output.c_str(), ";")); 135613481Sgiacomo.travaglini@arm.com 135713481Sgiacomo.travaglini@arm.com CaptureStderr(); 135813481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; // NOLINT 135913481Sgiacomo.travaglini@arm.com output = GetCapturedStderr(); 136013481Sgiacomo.travaglini@arm.com ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message")); 136113481Sgiacomo.travaglini@arm.com} 136213481Sgiacomo.travaglini@arm.com 136313481Sgiacomo.travaglini@arm.comvoid FuncWithAssert(int* n) { 136413481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(return;, ""); 136513481Sgiacomo.travaglini@arm.com (*n)++; 136613481Sgiacomo.travaglini@arm.com} 136713481Sgiacomo.travaglini@arm.com 136813481Sgiacomo.travaglini@arm.com// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current 136913481Sgiacomo.travaglini@arm.com// function (as ASSERT_DEATH does) if death tests are not supported. 137013481Sgiacomo.travaglini@arm.comTEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) { 137113481Sgiacomo.travaglini@arm.com int n = 0; 137213481Sgiacomo.travaglini@arm.com FuncWithAssert(&n); 137313481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, n); 137413481Sgiacomo.travaglini@arm.com} 137513481Sgiacomo.travaglini@arm.com 137613481Sgiacomo.travaglini@arm.com#endif // !GTEST_HAS_DEATH_TEST 137713481Sgiacomo.travaglini@arm.com 137813481Sgiacomo.travaglini@arm.com// Tests that the death test macros expand to code which may or may not 137913481Sgiacomo.travaglini@arm.com// be followed by operator<<, and that in either case the complete text 138013481Sgiacomo.travaglini@arm.com// comprises only a single C++ statement. 138113481Sgiacomo.travaglini@arm.com// 138213481Sgiacomo.travaglini@arm.com// The syntax should work whether death tests are available or not. 138313481Sgiacomo.travaglini@arm.comTEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) { 138413481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 138513481Sgiacomo.travaglini@arm.com // This would fail if executed; this is a compilation test only 138613481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(return, ""); 138713481Sgiacomo.travaglini@arm.com 138813481Sgiacomo.travaglini@arm.com if (AlwaysTrue()) 138913481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(_exit(1), ""); 139013481Sgiacomo.travaglini@arm.com else 139113481Sgiacomo.travaglini@arm.com // This empty "else" branch is meant to ensure that EXPECT_DEATH 139213481Sgiacomo.travaglini@arm.com // doesn't expand into an "if" statement without an "else" 139313481Sgiacomo.travaglini@arm.com ; // NOLINT 139413481Sgiacomo.travaglini@arm.com 139513481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 139613481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die"; 139713481Sgiacomo.travaglini@arm.com 139813481Sgiacomo.travaglini@arm.com if (AlwaysFalse()) 139913481Sgiacomo.travaglini@arm.com ; // NOLINT 140013481Sgiacomo.travaglini@arm.com else 140113481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3; 140213481Sgiacomo.travaglini@arm.com} 140313481Sgiacomo.travaglini@arm.com 140413481Sgiacomo.travaglini@arm.com// Tests that conditional death test macros expand to code which interacts 140513481Sgiacomo.travaglini@arm.com// well with switch statements. 140613481Sgiacomo.travaglini@arm.comTEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) { 140713481Sgiacomo.travaglini@arm.com // Microsoft compiler usually complains about switch statements without 140813481Sgiacomo.travaglini@arm.com // case labels. We suppress that warning for this test. 140913481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065) 141013481Sgiacomo.travaglini@arm.com 141113481Sgiacomo.travaglini@arm.com switch (0) 141213481Sgiacomo.travaglini@arm.com default: 141313481Sgiacomo.travaglini@arm.com ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") 141413481Sgiacomo.travaglini@arm.com << "exit in default switch handler"; 141513481Sgiacomo.travaglini@arm.com 141613481Sgiacomo.travaglini@arm.com switch (0) 141713481Sgiacomo.travaglini@arm.com case 0: 141813481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case"; 141913481Sgiacomo.travaglini@arm.com 142013481Sgiacomo.travaglini@arm.com GTEST_DISABLE_MSC_WARNINGS_POP_() 142113481Sgiacomo.travaglini@arm.com} 142213481Sgiacomo.travaglini@arm.com 142313481Sgiacomo.travaglini@arm.com// Tests that a test case whose name ends with "DeathTest" works fine 142413481Sgiacomo.travaglini@arm.com// on Windows. 142513481Sgiacomo.travaglini@arm.comTEST(NotADeathTest, Test) { 142613481Sgiacomo.travaglini@arm.com SUCCEED(); 142713481Sgiacomo.travaglini@arm.com} 1428