41 #if GTEST_HAS_DEATH_TEST
47 # include <sys/wait.h>
48 # endif // GTEST_OS_WINDOWS
55 # include <sys/time.h>
56 # endif // GTEST_OS_LINUX
65 # define GTEST_IMPLEMENTATION_ 1
67 # undef GTEST_IMPLEMENTATION_
69 namespace posix = ::testing::internal::posix;
72 using testing::internal::DeathTest;
73 using testing::internal::DeathTestFactory;
75 using testing::internal::GetLastErrnoDescription;
77 using testing::internal::InDeathTestChild;
78 using testing::internal::ParseNaturalNumber;
85 class ReplaceDeathTestFactory {
87 explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
89 old_factory_ = unit_test_impl_->death_test_factory_.release();
90 unit_test_impl_->death_test_factory_.reset(new_factory);
93 ~ReplaceDeathTestFactory() {
94 unit_test_impl_->death_test_factory_.release();
95 unit_test_impl_->death_test_factory_.reset(old_factory_);
99 ReplaceDeathTestFactory(
const ReplaceDeathTestFactory&);
100 void operator=(
const ReplaceDeathTestFactory&);
102 UnitTestImpl* unit_test_impl_;
103 DeathTestFactory* old_factory_;
110 fprintf(stderr,
"%s", message.c_str());
126 DieWithMessage(
"death inside " +
function +
"().");
133 TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
135 virtual ~TestForDeathTest() {
140 static void StaticMemberFunction() { DieInside(
"StaticMemberFunction"); }
143 void MemberFunction() {
145 DieInside(
"MemberFunction");
150 const FilePath original_dir_;
156 explicit MayDie(
bool should_die) : should_die_(should_die) {}
159 void MemberFunction()
const {
161 DieInside(
"MayDie::MemberFunction");
170 void GlobalFunction() { DieInside(
"GlobalFunction"); }
173 int NonVoidFunction() {
174 DieInside(
"NonVoidFunction");
179 void DieIf(
bool should_die) {
185 bool DieIfLessThan(
int x,
int y) {
187 DieInside(
"DieIfLessThan");
193 void DeathTestSubroutine() {
194 EXPECT_DEATH(GlobalFunction(),
"death.*GlobalFunction");
195 ASSERT_DEATH(GlobalFunction(),
"death.*GlobalFunction");
199 int DieInDebugElse12(
int* sideeffect) {
200 if (sideeffect) *sideeffect = 12;
204 DieInside(
"DieInDebugElse12");
211 # if GTEST_OS_WINDOWS
214 TEST(ExitStatusPredicateTest, ExitedWithCode) {
229 static int NormalExitStatus(
int exit_code) {
230 pid_t child_pid = fork();
231 if (child_pid == 0) {
235 waitpid(child_pid, &status, 0);
244 static int KilledExitStatus(
int signum) {
245 pid_t child_pid = fork();
246 if (child_pid == 0) {
251 waitpid(child_pid, &status, 0);
256 TEST(ExitStatusPredicateTest, ExitedWithCode) {
257 const int status0 = NormalExitStatus(0);
258 const int status1 = NormalExitStatus(1);
259 const int status42 = NormalExitStatus(42);
260 const testing::ExitedWithCode pred0(0);
261 const testing::ExitedWithCode pred1(1);
262 const testing::ExitedWithCode pred42(42);
272 TEST(ExitStatusPredicateTest, KilledBySignal) {
273 const int status_segv = KilledExitStatus(SIGSEGV);
274 const int status_kill = KilledExitStatus(SIGKILL);
275 const testing::KilledBySignal pred_segv(SIGSEGV);
276 const testing::KilledBySignal pred_kill(SIGKILL);
283 # endif // GTEST_OS_WINDOWS
288 TEST_F(TestForDeathTest, SingleStatement) {
291 ASSERT_DEATH(
return,
"");
294 EXPECT_DEATH(_exit(1),
"");
301 ASSERT_DEATH(
return,
"") <<
"did not die";
306 EXPECT_DEATH(_exit(1),
"") << 1 << 2 << 3;
309 void DieWithEmbeddedNul() {
310 fprintf(stderr,
"Hello%cmy null world.\n",
'\0');
318 TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
321 EXPECT_DEATH(DieWithEmbeddedNul(),
"my null world");
322 ASSERT_DEATH(DieWithEmbeddedNul(),
"my null world");
324 # endif // GTEST_USES_PCRE
328 TEST_F(TestForDeathTest, SwitchStatement) {
339 EXPECT_DEATH(_exit(1), "") << "exit
in switch case";
346 TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
348 ASSERT_DEATH(StaticMemberFunction(),
"death.*StaticMember");
353 TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
356 EXPECT_DEATH(MemberFunction(),
"inside.*MemberFunction");
363 TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
367 EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1),
"");
370 ASSERT_DEATH(_exit(1),
"");
374 void SigprofAction(
int, siginfo_t*,
void*) { }
377 void SetSigprofActionAndTimer() {
378 struct itimerval timer;
379 timer.it_interval.tv_sec = 0;
380 timer.it_interval.tv_usec = 1;
381 timer.it_value = timer.it_interval;
382 ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
383 struct sigaction signal_action;
384 memset(&signal_action, 0,
sizeof(signal_action));
385 sigemptyset(&signal_action.sa_mask);
386 signal_action.sa_sigaction = SigprofAction;
387 signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
388 ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
392 void DisableSigprofActionAndTimer(
struct sigaction* old_signal_action) {
393 struct itimerval timer;
394 timer.it_interval.tv_sec = 0;
395 timer.it_interval.tv_usec = 0;
396 timer.it_value = timer.it_interval;
397 ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
398 struct sigaction signal_action;
399 memset(&signal_action, 0,
sizeof(signal_action));
400 sigemptyset(&signal_action.sa_mask);
401 signal_action.sa_handler = SIG_IGN;
402 ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
406 TEST_F(TestForDeathTest, FastSigprofActionSet) {
408 SetSigprofActionAndTimer();
409 EXPECT_DEATH(_exit(1),
"");
410 struct sigaction old_signal_action;
411 DisableSigprofActionAndTimer(&old_signal_action);
412 EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
415 TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
417 SetSigprofActionAndTimer();
418 EXPECT_DEATH(_exit(1),
"");
419 struct sigaction old_signal_action;
420 DisableSigprofActionAndTimer(&old_signal_action);
421 EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
423 # endif // GTEST_OS_LINUX
427 TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
429 ASSERT_DEATH(StaticMemberFunction(),
"death.*StaticMember");
432 TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
435 EXPECT_DEATH(MemberFunction(),
"inside.*MemberFunction");
438 TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
441 for (
int i = 0;
i < 3; ++
i)
442 EXPECT_EXIT(_exit(
i), testing::ExitedWithCode(
i),
"") <<
": i = " <<
i;
445 TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
449 EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1),
"");
452 ASSERT_DEATH(_exit(1),
"");
455 TEST_F(TestForDeathTest, MixedStyles) {
457 EXPECT_DEATH(_exit(1),
"");
459 EXPECT_DEATH(_exit(1),
"");
462 # if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
468 void SetPthreadFlag() {
474 TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
477 pthread_flag =
false;
478 ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
479 ASSERT_DEATH(_exit(1),
"");
484 # endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
487 TEST_F(TestForDeathTest, MethodOfAnotherClass) {
488 const MayDie
x(
true);
489 ASSERT_DEATH(x.MemberFunction(),
"MayDie\\:\\:MemberFunction");
493 TEST_F(TestForDeathTest, GlobalFunction) {
494 EXPECT_DEATH(GlobalFunction(),
"GlobalFunction");
499 TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
500 static const char regex_c_str[] =
"GlobalFunction";
501 EXPECT_DEATH(GlobalFunction(), regex_c_str);
504 EXPECT_DEATH(GlobalFunction(), regex);
506 # if GTEST_HAS_GLOBAL_STRING
508 const string regex_str(regex_c_str);
509 EXPECT_DEATH(GlobalFunction(), regex_str);
511 # endif // GTEST_HAS_GLOBAL_STRING
513 # if !GTEST_USES_PCRE
516 EXPECT_DEATH(GlobalFunction(), regex_std_str);
518 # endif // !GTEST_USES_PCRE
522 TEST_F(TestForDeathTest, NonVoidFunction) {
523 ASSERT_DEATH(NonVoidFunction(),
"NonVoidFunction");
527 TEST_F(TestForDeathTest, FunctionWithParameter) {
528 EXPECT_DEATH(DieIf(
true),
"DieIf\\(\\)");
529 EXPECT_DEATH(DieIfLessThan(2, 3),
"DieIfLessThan");
533 TEST_F(TestForDeathTest, OutsideFixture) {
534 DeathTestSubroutine();
538 TEST_F(TestForDeathTest, InsideLoop) {
539 for (
int i = 0;
i < 5;
i++) {
540 EXPECT_DEATH(DieIfLessThan(-1,
i),
"DieIfLessThan") <<
"where i == " <<
i;
545 TEST_F(TestForDeathTest, CompoundStatement) {
555 TEST_F(TestForDeathTest, DoesNotDie) {
561 TEST_F(TestForDeathTest, ErrorMessageMismatch) {
563 EXPECT_DEATH(DieIf(
true),
"DieIfLessThan") <<
"End of death test message.";
564 },
"died but not with expected error");
569 void ExpectDeathTestHelper(
bool* aborted) {
571 EXPECT_DEATH(DieIf(
false),
"DieIf");
576 TEST_F(TestForDeathTest, EXPECT_DEATH) {
584 TEST_F(TestForDeathTest, ASSERT_DEATH) {
588 ASSERT_DEATH(DieIf(
false),
"DieIf");
595 TEST_F(TestForDeathTest, SingleEvaluation) {
597 EXPECT_DEATH(DieIf((++x) == 4),
"DieIf");
599 const char* regex =
"DieIf";
600 const char* regex_save = regex;
601 EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
606 TEST_F(TestForDeathTest, RunawayIsFailure) {
613 TEST_F(TestForDeathTest, ReturnIsFailure) {
615 "illegal return in test statement.");
625 TEST_F(TestForDeathTest, TestExpectDebugDeath) {
628 EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect),
"death.*DieInDebugElse12")
629 <<
"Must accept a streamed message";
651 TEST_F(TestForDeathTest, TestAssertDebugDeath) {
654 ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect),
"death.*DieInDebugElse12")
655 <<
"Must accept a streamed message";
672 void ExpectDebugDeathHelper(
bool* aborted) {
674 EXPECT_DEBUG_DEATH(
return,
"") <<
"This is expected to fail.";
678 # if GTEST_OS_WINDOWS
679 TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
680 printf(
"This test should be considered failing if it shows "
681 "any pop-up dialogs.\n");
689 # endif // GTEST_OS_WINDOWS
693 TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
699 void AssertDebugDeathHelper(
bool* aborted) {
702 ASSERT_DEBUG_DEATH(
GTEST_LOG_(
INFO) <<
"In ASSERT_DEBUG_DEATH";
return,
"")
703 <<
"This is expected to fail.";
710 TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
717 TEST_F(TestForDeathTest, AssertDebugDeathAborts2) {
724 TEST_F(TestForDeathTest, AssertDebugDeathAborts3) {
731 TEST_F(TestForDeathTest, AssertDebugDeathAborts4) {
738 TEST_F(TestForDeathTest, AssertDebugDeathAborts5) {
745 TEST_F(TestForDeathTest, AssertDebugDeathAborts6) {
752 TEST_F(TestForDeathTest, AssertDebugDeathAborts7) {
759 TEST_F(TestForDeathTest, AssertDebugDeathAborts8) {
766 TEST_F(TestForDeathTest, AssertDebugDeathAborts9) {
773 TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
783 static void TestExitMacros() {
784 EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1),
"");
785 ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42),
"");
787 # if GTEST_OS_WINDOWS
792 EXPECT_EXIT(
raise(SIGABRT), testing::ExitedWithCode(3),
"") <<
"b_ar";
796 EXPECT_EXIT(
raise(SIGKILL), testing::KilledBySignal(SIGKILL),
"") <<
"foo";
797 ASSERT_EXIT(
raise(SIGUSR2), testing::KilledBySignal(SIGUSR2),
"") <<
"bar";
800 ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV),
"")
801 <<
"This failure is expected, too.";
802 },
"This failure is expected, too.");
804 # endif // GTEST_OS_WINDOWS
807 EXPECT_EXIT(
raise(SIGSEGV), testing::ExitedWithCode(0),
"")
808 <<
"This failure is expected.";
809 },
"This failure is expected.");
812 TEST_F(TestForDeathTest, ExitMacros) {
816 TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
821 TEST_F(TestForDeathTest, InvalidStyle) {
824 EXPECT_DEATH(_exit(0),
"") <<
"This failure is expected.";
825 },
"This failure is expected.");
828 TEST_F(TestForDeathTest, DeathTestFailedOutput) {
831 EXPECT_DEATH(DieWithMessage(
"death\n"),
834 "[ DEATH ] death\n");
837 TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
841 fprintf(stderr,
"returning\n");
845 " Result: illegal return in test statement.\n"
847 "[ DEATH ] returning\n");
850 TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
853 EXPECT_EXIT(DieWithMessage(
"exiting with rc 1\n"),
854 testing::ExitedWithCode(3),
856 " Result: died but not with expected exit code:\n"
857 " Exited with exit status 1\n"
859 "[ DEATH ] exiting with rc 1\n");
862 TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
865 EXPECT_DEATH(DieWithMessage(
"line 1\nline 2\nline 3\n"),
866 "line 1\nxyz\nline 3\n"),
870 "[ DEATH ] line 3\n");
873 TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
875 EXPECT_DEATH(DieWithMessage(
"line 1\nline 2\nline 3\n"),
876 "line 1\nline 2\nline 3\n");
880 class MockDeathTestFactory :
public DeathTestFactory {
882 MockDeathTestFactory();
883 virtual bool Create(
const char* statement,
884 const ::testing::internal::RE* regex,
888 void SetParameters(
bool create, DeathTest::TestRole role,
892 int AssumeRoleCalls()
const {
return assume_role_calls_; }
893 int WaitCalls()
const {
return wait_calls_; }
894 size_t PassedCalls()
const {
return passed_args_.size(); }
895 bool PassedArgument(
int n)
const {
return passed_args_[
n]; }
896 size_t AbortCalls()
const {
return abort_args_.size(); }
897 DeathTest::AbortReason AbortArgument(
int n)
const {
898 return abort_args_[
n];
900 bool TestDeleted()
const {
return test_deleted_; }
903 friend class MockDeathTest;
908 DeathTest::TestRole role_;
915 int assume_role_calls_;
920 std::vector<bool> passed_args_;
923 std::vector<DeathTest::AbortReason> abort_args_;
934 class MockDeathTest :
public DeathTest {
936 MockDeathTest(MockDeathTestFactory *parent,
937 TestRole role,
int status,
bool passed) :
938 parent_(parent), role_(role), status_(status), passed_(passed) {
940 virtual ~MockDeathTest() {
941 parent_->test_deleted_ =
true;
943 virtual TestRole AssumeRole() {
944 ++parent_->assume_role_calls_;
948 ++parent_->wait_calls_;
951 virtual bool Passed(
bool exit_status_ok) {
952 parent_->passed_args_.push_back(exit_status_ok);
955 virtual void Abort(AbortReason reason) {
956 parent_->abort_args_.push_back(reason);
960 MockDeathTestFactory*
const parent_;
961 const TestRole role_;
968 MockDeathTestFactory::MockDeathTestFactory()
970 role_(DeathTest::OVERSEE_TEST),
973 assume_role_calls_(0),
981 void MockDeathTestFactory::SetParameters(
bool create,
982 DeathTest::TestRole role,
983 int status,
bool passed) {
989 assume_role_calls_ = 0;
991 passed_args_.clear();
999 bool MockDeathTestFactory::Create(
const char* ,
1000 const ::testing::internal::RE* ,
1004 test_deleted_ =
false;
1006 *test =
new MockDeathTest(
this, role_, status_, passed_);
1018 static testing::internal::ReplaceDeathTestFactory* replacer_;
1019 static MockDeathTestFactory* factory_;
1022 factory_ =
new MockDeathTestFactory;
1023 replacer_ =
new testing::internal::ReplaceDeathTestFactory(factory_);
1036 static void RunReturningDeathTest(
bool* flag) {
1044 testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
1046 MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
1050 TEST_F(MacroLogicDeathTest, NothingHappens) {
1052 factory_->SetParameters(
false, DeathTest::OVERSEE_TEST, 0,
true);
1053 EXPECT_DEATH(flag =
true,
"");
1055 EXPECT_EQ(0, factory_->AssumeRoleCalls());
1065 TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
1067 factory_->SetParameters(
true, DeathTest::OVERSEE_TEST, 0,
true);
1068 EXPECT_DEATH(flag =
true,
"");
1070 EXPECT_EQ(1, factory_->AssumeRoleCalls());
1080 TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
1082 factory_->SetParameters(
true, DeathTest::OVERSEE_TEST, 1,
true);
1083 EXPECT_DEATH(flag =
true,
"");
1085 EXPECT_EQ(1, factory_->AssumeRoleCalls());
1096 TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
1098 factory_->SetParameters(
true, DeathTest::EXECUTE_TEST, 0,
true);
1099 RunReturningDeathTest(&flag);
1101 EXPECT_EQ(1, factory_->AssumeRoleCalls());
1105 EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
1106 factory_->AbortArgument(0));
1112 TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
1114 factory_->SetParameters(
true, DeathTest::EXECUTE_TEST, 0,
true);
1115 EXPECT_DEATH(flag =
true,
"");
1117 EXPECT_EQ(1, factory_->AssumeRoleCalls());
1127 factory_->AbortArgument(0));
1128 EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
1129 factory_->AbortArgument(1));
1135 TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
1136 EXPECT_DEATH(_exit(1),
"");
1140 TEST(StreamingAssertionsDeathTest, DeathTest) {
1141 EXPECT_DEATH(_exit(1),
"") <<
"unexpected failure";
1142 ASSERT_DEATH(_exit(1),
"") <<
"unexpected failure";
1144 EXPECT_DEATH(_exit(0),
"") <<
"expected failure";
1145 },
"expected failure");
1147 ASSERT_DEATH(_exit(0),
"") <<
"expected failure";
1148 },
"expected failure");
1153 TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
1160 # if GTEST_OS_WINDOWS
1161 TEST(AutoHandleTest, AutoHandleWorks) {
1162 HANDLE handle = ::CreateEvent(NULL,
FALSE,
FALSE, NULL);
1163 ASSERT_NE(INVALID_HANDLE_VALUE, handle);
1166 testing::internal::AutoHandle auto_handle(handle);
1171 auto_handle.Reset();
1172 EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
1176 handle = ::CreateEvent(NULL,
FALSE,
FALSE, NULL);
1177 ASSERT_NE(INVALID_HANDLE_VALUE, handle);
1178 auto_handle.Reset(handle);
1182 testing::internal::AutoHandle auto_handle2;
1183 EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
1185 # endif // GTEST_OS_WINDOWS
1187 # if GTEST_OS_WINDOWS
1188 typedef unsigned __int64 BiggestParsable;
1189 typedef signed __int64 BiggestSignedParsable;
1191 typedef unsigned long long BiggestParsable;
1192 typedef signed long long BiggestSignedParsable;
1193 # endif // GTEST_OS_WINDOWS
1197 const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
1198 const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
1200 TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
1201 BiggestParsable result = 0;
1204 EXPECT_FALSE(ParseNaturalNumber(
"non-number string", &result));
1217 TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
1218 BiggestParsable result = 0;
1220 EXPECT_FALSE(ParseNaturalNumber(
"99999999999999999999999", &result));
1222 signed char char_result = 0;
1227 TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
1228 BiggestParsable result = 0;
1240 ASSERT_TRUE(ParseNaturalNumber(
"00000", &result));
1244 TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
1246 msg << kBiggestParsableMax;
1248 BiggestParsable result = 0;
1249 EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
1253 msg2 << kBiggestSignedParsableMax;
1255 BiggestSignedParsable signed_result = 0;
1256 EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
1257 EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
1263 EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
1269 unsigned int uint_result = 0;
1270 EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
1274 TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
1275 short short_result = 0;
1276 ASSERT_TRUE(ParseNaturalNumber(
"123", &short_result));
1279 signed char char_result = 0;
1280 ASSERT_TRUE(ParseNaturalNumber(
"123", &char_result));
1284 # if GTEST_OS_WINDOWS
1285 TEST(EnvironmentTest, HandleFitsIntoSizeT) {
1291 # endif // GTEST_OS_WINDOWS
1295 TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
1297 "death inside CondDeathTestExpectMacro");
1299 "death inside CondDeathTestAssertMacro");
1306 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
1310 fprintf(stderr, InDeathTestChild() ?
"Inside" :
"Outside");
1316 TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
1320 fprintf(stderr, InDeathTestChild() ?
"Inside" :
"Outside");
1326 #else // !GTEST_HAS_DEATH_TEST follows
1334 TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
1341 "Death tests are not supported on this platform"));
1348 ASSERT_TRUE(NULL == strstr(output.c_str(),
"streamed message"));
1354 "Death tests are not supported on this platform"));
1360 ASSERT_TRUE(NULL == strstr(output.c_str(),
"streamed message"));
1370 TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
1376 #endif // !GTEST_HAS_DEATH_TEST
1383 TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
1406 TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
1414 <<
"exit in default switch handler";