summaryrefslogtreecommitdiff
path: root/test/gtest-death-test_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'test/gtest-death-test_test.cc')
-rw-r--r--test/gtest-death-test_test.cc153
1 files changed, 112 insertions, 41 deletions
diff --git a/test/gtest-death-test_test.cc b/test/gtest-death-test_test.cc
index bcf8e2a..c2d26df 100644
--- a/test/gtest-death-test_test.cc
+++ b/test/gtest-death-test_test.cc
@@ -45,13 +45,16 @@ using testing::internal::AlwaysTrue;
# else
# include <unistd.h>
# include <sys/wait.h> // For waitpid.
-# include <limits> // For std::numeric_limits.
# endif // GTEST_OS_WINDOWS
# include <limits.h>
# include <signal.h>
# include <stdio.h>
+# if GTEST_OS_LINUX
+# include <sys/time.h>
+# endif // GTEST_OS_LINUX
+
# include "gtest/gtest-spi.h"
// Indicates that this translation unit is part of Google Test's
@@ -71,8 +74,8 @@ using testing::internal::DeathTestFactory;
using testing::internal::FilePath;
using testing::internal::GetLastErrnoDescription;
using testing::internal::GetUnitTestImpl;
+using testing::internal::InDeathTestChild;
using testing::internal::ParseNaturalNumber;
-using testing::internal::String;
namespace testing {
namespace internal {
@@ -372,6 +375,58 @@ TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
ASSERT_DEATH(_exit(1), "");
}
+# if GTEST_OS_LINUX
+void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
+
+// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
+void SetSigprofActionAndTimer() {
+ struct itimerval timer;
+ timer.it_interval.tv_sec = 0;
+ timer.it_interval.tv_usec = 1;
+ timer.it_value = timer.it_interval;
+ ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
+ struct sigaction signal_action;
+ memset(&signal_action, 0, sizeof(signal_action));
+ sigemptyset(&signal_action.sa_mask);
+ signal_action.sa_sigaction = SigprofAction;
+ signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
+ ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
+}
+
+// Disables ITIMER_PROF timer and ignores SIGPROF signal.
+void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
+ struct itimerval timer;
+ timer.it_interval.tv_sec = 0;
+ timer.it_interval.tv_usec = 0;
+ timer.it_value = timer.it_interval;
+ ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
+ struct sigaction signal_action;
+ memset(&signal_action, 0, sizeof(signal_action));
+ sigemptyset(&signal_action.sa_mask);
+ signal_action.sa_handler = SIG_IGN;
+ ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
+}
+
+// Tests that death tests work when SIGPROF handler and timer are set.
+TEST_F(TestForDeathTest, FastSigprofActionSet) {
+ testing::GTEST_FLAG(death_test_style) = "fast";
+ SetSigprofActionAndTimer();
+ EXPECT_DEATH(_exit(1), "");
+ struct sigaction old_signal_action;
+ DisableSigprofActionAndTimer(&old_signal_action);
+ EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
+}
+
+TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
+ testing::GTEST_FLAG(death_test_style) = "threadsafe";
+ SetSigprofActionAndTimer();
+ EXPECT_DEATH(_exit(1), "");
+ struct sigaction old_signal_action;
+ DisableSigprofActionAndTimer(&old_signal_action);
+ EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
+}
+# endif // GTEST_OS_LINUX
+
// Repeats a representative sample of death tests in the "threadsafe" style:
TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
@@ -409,6 +464,8 @@ TEST_F(TestForDeathTest, MixedStyles) {
EXPECT_DEATH(_exit(1), "");
}
+# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
+
namespace {
bool pthread_flag;
@@ -419,8 +476,6 @@ void SetPthreadFlag() {
} // namespace
-# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
-
TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
if (!testing::GTEST_FLAG(death_test_use_fork)) {
testing::GTEST_FLAG(death_test_style) = "threadsafe";
@@ -561,8 +616,8 @@ TEST_F(TestForDeathTest, ReturnIsFailure) {
"illegal return in test statement.");
}
-// Tests that EXPECT_DEBUG_DEATH works as expected,
-// that is, in debug mode, it:
+// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a
+// message to it, and in debug mode it:
// 1. Asserts on death.
// 2. Has no side effect.
//
@@ -571,8 +626,8 @@ TEST_F(TestForDeathTest, ReturnIsFailure) {
TEST_F(TestForDeathTest, TestExpectDebugDeath) {
int sideeffect = 0;
- EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect),
- "death.*DieInDebugElse12");
+ EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
+ << "Must accept a streamed message";
# ifdef NDEBUG
@@ -587,22 +642,18 @@ TEST_F(TestForDeathTest, TestExpectDebugDeath) {
# endif
}
-// Tests that ASSERT_DEBUG_DEATH works as expected
-// In debug mode:
-// 1. Asserts on debug death.
+// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
+// message to it, and in debug mode it:
+// 1. Asserts on death.
// 2. Has no side effect.
//
-// In opt mode:
-// 1. Has side effects and returns the expected value (12).
+// And in opt mode, it:
+// 1. Has side effects but does not assert.
TEST_F(TestForDeathTest, TestAssertDebugDeath) {
int sideeffect = 0;
- ASSERT_DEBUG_DEATH({ // NOLINT
- // Tests that the return value is 12 in opt mode.
- EXPECT_EQ(12, DieInDebugElse12(&sideeffect));
- // Tests that the side effect occurred in opt mode.
- EXPECT_EQ(12, sideeffect);
- }, "death.*DieInDebugElse12");
+ ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
+ << "Must accept a streamed message";
# ifdef NDEBUG
@@ -673,7 +724,7 @@ static void TestExitMacros() {
// Of all signals effects on the process exit code, only those of SIGABRT
// are documented on Windows.
// See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
- EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "");
+ EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
# else
@@ -682,14 +733,14 @@ static void TestExitMacros() {
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
- << "This failure is expected, too.";
+ << "This failure is expected, too.";
}, "This failure is expected, too.");
# endif // GTEST_OS_WINDOWS
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
- << "This failure is expected.";
+ << "This failure is expected.";
}, "This failure is expected.");
}
@@ -839,6 +890,7 @@ class MockDeathTest : public DeathTest {
virtual void Abort(AbortReason reason) {
parent_->abort_args_.push_back(reason);
}
+
private:
MockDeathTestFactory* const parent_;
const TestRole role_;
@@ -1070,41 +1122,40 @@ TEST(AutoHandleTest, AutoHandleWorks) {
# if GTEST_OS_WINDOWS
typedef unsigned __int64 BiggestParsable;
typedef signed __int64 BiggestSignedParsable;
-const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
-const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
# else
typedef unsigned long long BiggestParsable;
typedef signed long long BiggestSignedParsable;
-const BiggestParsable kBiggestParsableMax =
- ::std::numeric_limits<BiggestParsable>::max();
-const BiggestSignedParsable kBiggestSignedParsableMax =
- ::std::numeric_limits<BiggestSignedParsable>::max();
# endif // GTEST_OS_WINDOWS
+// We cannot use std::numeric_limits<T>::max() as it clashes with the
+// max() macro defined by <windows.h>.
+const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
+const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
+
TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
BiggestParsable result = 0;
// Rejects non-numbers.
- EXPECT_FALSE(ParseNaturalNumber(String("non-number string"), &result));
+ EXPECT_FALSE(ParseNaturalNumber("non-number string", &result));
// Rejects numbers with whitespace prefix.
- EXPECT_FALSE(ParseNaturalNumber(String(" 123"), &result));
+ EXPECT_FALSE(ParseNaturalNumber(" 123", &result));
// Rejects negative numbers.
- EXPECT_FALSE(ParseNaturalNumber(String("-123"), &result));
+ EXPECT_FALSE(ParseNaturalNumber("-123", &result));
// Rejects numbers starting with a plus sign.
- EXPECT_FALSE(ParseNaturalNumber(String("+123"), &result));
+ EXPECT_FALSE(ParseNaturalNumber("+123", &result));
errno = 0;
}
TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
BiggestParsable result = 0;
- EXPECT_FALSE(ParseNaturalNumber(String("99999999999999999999999"), &result));
+ EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result));
signed char char_result = 0;
- EXPECT_FALSE(ParseNaturalNumber(String("200"), &char_result));
+ EXPECT_FALSE(ParseNaturalNumber("200", &char_result));
errno = 0;
}
@@ -1112,16 +1163,16 @@ TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
BiggestParsable result = 0;
result = 0;
- ASSERT_TRUE(ParseNaturalNumber(String("123"), &result));
+ ASSERT_TRUE(ParseNaturalNumber("123", &result));
EXPECT_EQ(123U, result);
// Check 0 as an edge case.
result = 1;
- ASSERT_TRUE(ParseNaturalNumber(String("0"), &result));
+ ASSERT_TRUE(ParseNaturalNumber("0", &result));
EXPECT_EQ(0U, result);
result = 1;
- ASSERT_TRUE(ParseNaturalNumber(String("00000"), &result));
+ ASSERT_TRUE(ParseNaturalNumber("00000", &result));
EXPECT_EQ(0U, result);
}
@@ -1157,11 +1208,11 @@ TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
short short_result = 0;
- ASSERT_TRUE(ParseNaturalNumber(String("123"), &short_result));
+ ASSERT_TRUE(ParseNaturalNumber("123", &short_result));
EXPECT_EQ(123, short_result);
signed char char_result = 0;
- ASSERT_TRUE(ParseNaturalNumber(String("123"), &char_result));
+ ASSERT_TRUE(ParseNaturalNumber("123", &char_result));
EXPECT_EQ(123, char_result);
}
@@ -1191,7 +1242,6 @@ TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
using testing::internal::CaptureStderr;
using testing::internal::GetCapturedStderr;
-using testing::internal::String;
// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
// defined but do not trigger failures when death tests are not available on
@@ -1201,7 +1251,7 @@ TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
// when death tests are not supported.
CaptureStderr();
EXPECT_DEATH_IF_SUPPORTED(;, "");
- String output = GetCapturedStderr();
+ std::string output = GetCapturedStderr();
ASSERT_TRUE(NULL != strstr(output.c_str(),
"Death tests are not supported on this platform"));
ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
@@ -1237,6 +1287,27 @@ TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
FuncWithAssert(&n);
EXPECT_EQ(1, n);
}
+
+TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
+ testing::GTEST_FLAG(death_test_style) = "fast";
+ EXPECT_FALSE(InDeathTestChild());
+ EXPECT_DEATH({
+ fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+ fflush(stderr);
+ _exit(1);
+ }, "Inside");
+}
+
+TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
+ testing::GTEST_FLAG(death_test_style) = "threadsafe";
+ EXPECT_FALSE(InDeathTestChild());
+ EXPECT_DEATH({
+ fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
+ fflush(stderr);
+ _exit(1);
+ }, "Inside");
+}
+
#endif // GTEST_HAS_DEATH_TEST
// Tests that the death test macros expand to code which may or may not
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-23 19:53:57 +0000