1 // Copyright 2005, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 // The purpose of this file is to generate Google Test output under
31 // various conditions. The output will then be verified by
32 // gtest_output_test.py to ensure that Google Test generates the
33 // desired messages. Therefore, most tests in this file are MEANT TO
36 // Author: wan@google.com (Zhanyong Wan)
38 #include "gtest/gtest-spi.h"
39 #include "gtest/gtest.h"
41 // Indicates that this translation unit is part of Google Test's
42 // implementation. It must come before gtest-internal-inl.h is
43 // included, or there will be a compiler error. This trick is to
44 // prevent a user from accidentally including gtest-internal-inl.h in
46 #define GTEST_IMPLEMENTATION_ 1
47 #include "src/gtest-internal-inl.h"
48 #undef GTEST_IMPLEMENTATION_
52 #if GTEST_IS_THREADSAFE
53 using testing::ScopedFakeTestPartResultReporter
;
54 using testing::TestPartResultArray
;
56 using testing::internal::Notification
;
57 using testing::internal::ThreadWithParam
;
60 namespace posix
= ::testing::internal::posix
;
62 // Tests catching fatal failures.
64 // A subroutine used by the following test.
69 // This function calls a test subroutine, catches the fatal failure it
70 // generates, and then returns early.
71 void TryTestSubroutine() {
72 // Calls a subrountine that yields a fatal failure.
75 // Catches the fatal failure and aborts the test.
77 // The testing::Test:: prefix is necessary when calling
78 // HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
79 if (testing::Test::HasFatalFailure()) return;
81 // If we get here, something is wrong.
82 FAIL() << "This should never be reached.";
85 TEST(PassingTest
, PassingTest1
) {
88 TEST(PassingTest
, PassingTest2
) {
91 // Tests that parameters of failing parameterized tests are printed in the
92 // failing test summary.
93 class FailingParamTest
: public testing::TestWithParam
<int> {};
95 TEST_P(FailingParamTest
, Fails
) {
96 EXPECT_EQ(1, GetParam());
99 // This generates a test which will fail. Google Test is expected to print
100 // its parameter when it outputs the list of all failed tests.
101 INSTANTIATE_TEST_CASE_P(PrintingFailingParams
,
105 static const char kGoldenString
[] = "\"Line\0 1\"\nLine 2";
107 TEST(NonfatalFailureTest
, EscapesStringOperands
) {
108 std::string actual
= "actual \"string\"";
109 EXPECT_EQ(kGoldenString
, actual
);
111 const char* golden
= kGoldenString
;
112 EXPECT_EQ(golden
, actual
);
115 TEST(NonfatalFailureTest
, DiffForLongStrings
) {
116 std::string
golden_str(kGoldenString
, sizeof(kGoldenString
) - 1);
117 EXPECT_EQ(golden_str
, "Line 2");
120 // Tests catching a fatal failure in a subroutine.
121 TEST(FatalFailureTest
, FatalFailureInSubroutine
) {
122 printf("(expecting a failure that x should be 1)\n");
127 // Tests catching a fatal failure in a nested subroutine.
128 TEST(FatalFailureTest
, FatalFailureInNestedSubroutine
) {
129 printf("(expecting a failure that x should be 1)\n");
131 // Calls a subrountine that yields a fatal failure.
134 // Catches the fatal failure and aborts the test.
136 // When calling HasFatalFailure() inside a TEST, TEST_F, or test
137 // fixture, the testing::Test:: prefix is not needed.
138 if (HasFatalFailure()) return;
140 // If we get here, something is wrong.
141 FAIL() << "This should never be reached.";
144 // Tests HasFatalFailure() after a failed EXPECT check.
145 TEST(FatalFailureTest
, NonfatalFailureInSubroutine
) {
146 printf("(expecting a failure on false)\n");
147 EXPECT_TRUE(false); // Generates a nonfatal failure
148 ASSERT_FALSE(HasFatalFailure()); // This should succeed.
151 // Tests interleaving user logging and Google Test assertions.
152 TEST(LoggingTest
, InterleavingLoggingAndAssertions
) {
153 static const int a
[4] = {
157 printf("(expecting 2 failures on (3) >= (a[i]))\n");
158 for (int i
= 0; i
< static_cast<int>(sizeof(a
)/sizeof(*a
)); i
++) {
159 printf("i == %d\n", i
);
164 // Tests the SCOPED_TRACE macro.
166 // A helper function for testing SCOPED_TRACE.
167 void SubWithoutTrace(int n
) {
172 // Another helper function for testing SCOPED_TRACE.
173 void SubWithTrace(int n
) {
174 SCOPED_TRACE(testing::Message() << "n = " << n
);
179 // Tests that SCOPED_TRACE() obeys lexical scopes.
180 TEST(SCOPED_TRACETest
, ObeysScopes
) {
181 printf("(expected to fail)\n");
183 // There should be no trace before SCOPED_TRACE() is invoked.
184 ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
187 SCOPED_TRACE("Expected trace");
188 // After SCOPED_TRACE(), a failure in the current scope should contain
190 ADD_FAILURE() << "This failure is expected, and should have a trace.";
193 // Once the control leaves the scope of the SCOPED_TRACE(), there
194 // should be no trace again.
195 ADD_FAILURE() << "This failure is expected, and shouldn't have a trace.";
198 // Tests that SCOPED_TRACE works inside a loop.
199 TEST(SCOPED_TRACETest
, WorksInLoop
) {
200 printf("(expected to fail)\n");
202 for (int i
= 1; i
<= 2; i
++) {
203 SCOPED_TRACE(testing::Message() << "i = " << i
);
209 // Tests that SCOPED_TRACE works in a subroutine.
210 TEST(SCOPED_TRACETest
, WorksInSubroutine
) {
211 printf("(expected to fail)\n");
217 // Tests that SCOPED_TRACE can be nested.
218 TEST(SCOPED_TRACETest
, CanBeNested
) {
219 printf("(expected to fail)\n");
221 SCOPED_TRACE(""); // A trace without a message.
226 // Tests that multiple SCOPED_TRACEs can be used in the same scope.
227 TEST(SCOPED_TRACETest
, CanBeRepeated
) {
228 printf("(expected to fail)\n");
232 << "This failure is expected, and should contain trace point A.";
236 << "This failure is expected, and should contain trace point A and B.";
240 ADD_FAILURE() << "This failure is expected, and should "
241 << "contain trace point A, B, and C.";
245 ADD_FAILURE() << "This failure is expected, and should "
246 << "contain trace point A, B, and D.";
249 #if GTEST_IS_THREADSAFE
250 // Tests that SCOPED_TRACE()s can be used concurrently from multiple
251 // threads. Namely, an assertion should be affected by
252 // SCOPED_TRACE()s in its own thread only.
254 // Here's the sequence of actions that happen in the test:
256 // Thread A (main) | Thread B (spawned)
257 // ===============================|================================
259 // -------------------------------+--------------------------------
260 // waits for n1 | SCOPED_TRACE("Trace B");
261 // | generates failure #1
263 // -------------------------------+--------------------------------
264 // SCOPED_TRACE("Trace A"); | waits for n2
265 // generates failure #2 |
267 // -------------------------------|--------------------------------
268 // waits for n3 | generates failure #3
270 // | generates failure #4
272 // -------------------------------|--------------------------------
273 // generates failure #5 | finishes
275 // generates failure #6 |
276 // -------------------------------|--------------------------------
277 // waits for thread B to finish |
285 static void ThreadWithScopedTrace(CheckPoints
* check_points
) {
287 SCOPED_TRACE("Trace B");
289 << "Expected failure #1 (in thread B, only trace B alive).";
290 check_points
->n1
.Notify();
291 check_points
->n2
.WaitForNotification();
294 << "Expected failure #3 (in thread B, trace A & B both alive).";
295 } // Trace B dies here.
297 << "Expected failure #4 (in thread B, only trace A alive).";
298 check_points
->n3
.Notify();
301 TEST(SCOPED_TRACETest
, WorksConcurrently
) {
302 printf("(expecting 6 failures)\n");
304 CheckPoints check_points
;
305 ThreadWithParam
<CheckPoints
*> thread(&ThreadWithScopedTrace
,
308 check_points
.n1
.WaitForNotification();
311 SCOPED_TRACE("Trace A");
313 << "Expected failure #2 (in thread A, trace A & B both alive).";
314 check_points
.n2
.Notify();
315 check_points
.n3
.WaitForNotification();
318 << "Expected failure #5 (in thread A, only trace A alive).";
319 } // Trace A dies here.
321 << "Expected failure #6 (in thread A, no trace alive).";
324 #endif // GTEST_IS_THREADSAFE
326 TEST(DisabledTestsWarningTest
,
327 DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
) {
328 // This test body is intentionally empty. Its sole purpose is for
329 // verifying that the --gtest_also_run_disabled_tests flag
330 // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
334 // Tests using assertions outside of TEST and TEST_F.
336 // This function creates two failures intentionally.
338 printf("The non-test part of the code is expected to have 2 failures.\n\n");
343 // Runs all TESTs, all TEST_Fs, and the ad hoc test.
346 return RUN_ALL_TESTS();
349 // Tests non-fatal failures in the fixture constructor.
350 class NonFatalFailureInFixtureConstructorTest
: public testing::Test
{
352 NonFatalFailureInFixtureConstructorTest() {
353 printf("(expecting 5 failures)\n");
354 ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
357 ~NonFatalFailureInFixtureConstructorTest() {
358 ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor.";
361 virtual void SetUp() {
362 ADD_FAILURE() << "Expected failure #2, in SetUp().";
365 virtual void TearDown() {
366 ADD_FAILURE() << "Expected failure #4, in TearDown.";
370 TEST_F(NonFatalFailureInFixtureConstructorTest
, FailureInConstructor
) {
371 ADD_FAILURE() << "Expected failure #3, in the test body.";
374 // Tests fatal failures in the fixture constructor.
375 class FatalFailureInFixtureConstructorTest
: public testing::Test
{
377 FatalFailureInFixtureConstructorTest() {
378 printf("(expecting 2 failures)\n");
382 ~FatalFailureInFixtureConstructorTest() {
383 ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor.";
386 virtual void SetUp() {
387 ADD_FAILURE() << "UNEXPECTED failure in SetUp(). "
388 << "We should never get here, as the test fixture c'tor "
389 << "had a fatal failure.";
392 virtual void TearDown() {
393 ADD_FAILURE() << "UNEXPECTED failure in TearDown(). "
394 << "We should never get here, as the test fixture c'tor "
395 << "had a fatal failure.";
400 FAIL() << "Expected failure #1, in the test fixture c'tor.";
404 TEST_F(FatalFailureInFixtureConstructorTest
, FailureInConstructor
) {
405 ADD_FAILURE() << "UNEXPECTED failure in the test body. "
406 << "We should never get here, as the test fixture c'tor "
407 << "had a fatal failure.";
410 // Tests non-fatal failures in SetUp().
411 class NonFatalFailureInSetUpTest
: public testing::Test
{
413 virtual ~NonFatalFailureInSetUpTest() {
417 virtual void SetUp() {
418 printf("(expecting 4 failures)\n");
419 ADD_FAILURE() << "Expected failure #1, in SetUp().";
422 virtual void TearDown() {
423 FAIL() << "Expected failure #3, in TearDown().";
427 FAIL() << "Expected failure #4, in the test fixture d'tor.";
431 TEST_F(NonFatalFailureInSetUpTest
, FailureInSetUp
) {
432 FAIL() << "Expected failure #2, in the test function.";
435 // Tests fatal failures in SetUp().
436 class FatalFailureInSetUpTest
: public testing::Test
{
438 virtual ~FatalFailureInSetUpTest() {
442 virtual void SetUp() {
443 printf("(expecting 3 failures)\n");
444 FAIL() << "Expected failure #1, in SetUp().";
447 virtual void TearDown() {
448 FAIL() << "Expected failure #2, in TearDown().";
452 FAIL() << "Expected failure #3, in the test fixture d'tor.";
456 TEST_F(FatalFailureInSetUpTest
, FailureInSetUp
) {
457 FAIL() << "UNEXPECTED failure in the test function. "
458 << "We should never get here, as SetUp() failed.";
461 TEST(AddFailureAtTest
, MessageContainsSpecifiedFileAndLineNumber
) {
462 ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc";
465 #if GTEST_IS_THREADSAFE
467 // A unary function that may die.
468 void DieIf(bool should_die
) {
469 GTEST_CHECK_(!should_die
) << " - death inside DieIf().";
472 // Tests running death tests in a multi-threaded context.
474 // Used for coordination between the main and the spawn thread.
475 struct SpawnThreadNotifications
{
476 SpawnThreadNotifications() {}
478 Notification spawn_thread_started
;
479 Notification spawn_thread_ok_to_terminate
;
482 GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications
);
485 // The function to be executed in the thread spawn by the
486 // MultipleThreads test (below).
487 static void ThreadRoutine(SpawnThreadNotifications
* notifications
) {
488 // Signals the main thread that this thread has started.
489 notifications
->spawn_thread_started
.Notify();
491 // Waits for permission to finish from the main thread.
492 notifications
->spawn_thread_ok_to_terminate
.WaitForNotification();
495 // This is a death-test test, but it's not named with a DeathTest
496 // suffix. It starts threads which might interfere with later
497 // death tests, so it must run after all other death tests.
498 class DeathTestAndMultiThreadsTest
: public testing::Test
{
500 // Starts a thread and waits for it to begin.
501 virtual void SetUp() {
502 thread_
.reset(new ThreadWithParam
<SpawnThreadNotifications
*>(
503 &ThreadRoutine
, ¬ifications_
, NULL
));
504 notifications_
.spawn_thread_started
.WaitForNotification();
506 // Tells the thread to finish, and reaps it.
507 // Depending on the version of the thread library in use,
508 // a manager thread might still be left running that will interfere
509 // with later death tests. This is unfortunate, but this class
510 // cleans up after itself as best it can.
511 virtual void TearDown() {
512 notifications_
.spawn_thread_ok_to_terminate
.Notify();
516 SpawnThreadNotifications notifications_
;
517 testing::internal::scoped_ptr
<ThreadWithParam
<SpawnThreadNotifications
*> >
521 #endif // GTEST_IS_THREADSAFE
523 // The MixedUpTestCaseTest test case verifies that Google Test will fail a
524 // test if it uses a different fixture class than what other tests in
525 // the same test case use. It deliberately contains two fixture
526 // classes with the same name but defined in different namespaces.
528 // The MixedUpTestCaseWithSameTestNameTest test case verifies that
529 // when the user defines two tests with the same test case name AND
530 // same test name (but in different namespaces), the second test will
535 class MixedUpTestCaseTest
: public testing::Test
{
538 TEST_F(MixedUpTestCaseTest
, FirstTestFromNamespaceFoo
) {}
539 TEST_F(MixedUpTestCaseTest
, SecondTestFromNamespaceFoo
) {}
541 class MixedUpTestCaseWithSameTestNameTest
: public testing::Test
{
544 TEST_F(MixedUpTestCaseWithSameTestNameTest
,
545 TheSecondTestWithThisNameShouldFail
) {}
551 class MixedUpTestCaseTest
: public testing::Test
{
554 // The following two tests are expected to fail. We rely on the
555 // golden file to check that Google Test generates the right error message.
556 TEST_F(MixedUpTestCaseTest
, ThisShouldFail
) {}
557 TEST_F(MixedUpTestCaseTest
, ThisShouldFailToo
) {}
559 class MixedUpTestCaseWithSameTestNameTest
: public testing::Test
{
562 // Expected to fail. We rely on the golden file to check that Google Test
563 // generates the right error message.
564 TEST_F(MixedUpTestCaseWithSameTestNameTest
,
565 TheSecondTestWithThisNameShouldFail
) {}
569 // The following two test cases verify that Google Test catches the user
570 // error of mixing TEST and TEST_F in the same test case. The first
571 // test case checks the scenario where TEST_F appears before TEST, and
572 // the second one checks where TEST appears before TEST_F.
574 class TEST_F_before_TEST_in_same_test_case
: public testing::Test
{
577 TEST_F(TEST_F_before_TEST_in_same_test_case
, DefinedUsingTEST_F
) {}
579 // Expected to fail. We rely on the golden file to check that Google Test
580 // generates the right error message.
581 TEST(TEST_F_before_TEST_in_same_test_case
, DefinedUsingTESTAndShouldFail
) {}
583 class TEST_before_TEST_F_in_same_test_case
: public testing::Test
{
586 TEST(TEST_before_TEST_F_in_same_test_case
, DefinedUsingTEST
) {}
588 // Expected to fail. We rely on the golden file to check that Google Test
589 // generates the right error message.
590 TEST_F(TEST_before_TEST_F_in_same_test_case
, DefinedUsingTEST_FAndShouldFail
) {
593 // Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
594 int global_integer
= 0;
596 // Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
597 TEST(ExpectNonfatalFailureTest
, CanReferenceGlobalVariables
) {
599 EXPECT_NONFATAL_FAILURE({
600 EXPECT_EQ(1, global_integer
) << "Expected non-fatal failure.";
601 }, "Expected non-fatal failure.");
604 // Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
606 TEST(ExpectNonfatalFailureTest
, CanReferenceLocalVariables
) {
610 EXPECT_NONFATAL_FAILURE({
611 EXPECT_EQ(m
, n
) << "Expected non-fatal failure.";
612 }, "Expected non-fatal failure.");
615 // Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
616 // one non-fatal failure and no fatal failure.
617 TEST(ExpectNonfatalFailureTest
, SucceedsWhenThereIsOneNonfatalFailure
) {
618 EXPECT_NONFATAL_FAILURE({
619 ADD_FAILURE() << "Expected non-fatal failure.";
620 }, "Expected non-fatal failure.");
623 // Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
624 // non-fatal failure.
625 TEST(ExpectNonfatalFailureTest
, FailsWhenThereIsNoNonfatalFailure
) {
626 printf("(expecting a failure)\n");
627 EXPECT_NONFATAL_FAILURE({
631 // Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
632 // non-fatal failures.
633 TEST(ExpectNonfatalFailureTest
, FailsWhenThereAreTwoNonfatalFailures
) {
634 printf("(expecting a failure)\n");
635 EXPECT_NONFATAL_FAILURE({
636 ADD_FAILURE() << "Expected non-fatal failure 1.";
637 ADD_FAILURE() << "Expected non-fatal failure 2.";
641 // Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
643 TEST(ExpectNonfatalFailureTest
, FailsWhenThereIsOneFatalFailure
) {
644 printf("(expecting a failure)\n");
645 EXPECT_NONFATAL_FAILURE({
646 FAIL() << "Expected fatal failure.";
650 // Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
652 TEST(ExpectNonfatalFailureTest
, FailsWhenStatementReturns
) {
653 printf("(expecting a failure)\n");
654 EXPECT_NONFATAL_FAILURE({
659 #if GTEST_HAS_EXCEPTIONS
661 // Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
663 TEST(ExpectNonfatalFailureTest
, FailsWhenStatementThrows
) {
664 printf("(expecting a failure)\n");
666 EXPECT_NONFATAL_FAILURE({
669 } catch(int) { // NOLINT
673 #endif // GTEST_HAS_EXCEPTIONS
675 // Tests that EXPECT_FATAL_FAILURE() can reference global variables.
676 TEST(ExpectFatalFailureTest
, CanReferenceGlobalVariables
) {
678 EXPECT_FATAL_FAILURE({
679 ASSERT_EQ(1, global_integer
) << "Expected fatal failure.";
680 }, "Expected fatal failure.");
683 // Tests that EXPECT_FATAL_FAILURE() can reference local static
685 TEST(ExpectFatalFailureTest
, CanReferenceLocalStaticVariables
) {
688 EXPECT_FATAL_FAILURE({
689 ASSERT_EQ(0, n
) << "Expected fatal failure.";
690 }, "Expected fatal failure.");
693 // Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
694 // one fatal failure and no non-fatal failure.
695 TEST(ExpectFatalFailureTest
, SucceedsWhenThereIsOneFatalFailure
) {
696 EXPECT_FATAL_FAILURE({
697 FAIL() << "Expected fatal failure.";
698 }, "Expected fatal failure.");
701 // Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
703 TEST(ExpectFatalFailureTest
, FailsWhenThereIsNoFatalFailure
) {
704 printf("(expecting a failure)\n");
705 EXPECT_FATAL_FAILURE({
709 // A helper for generating a fatal failure.
710 void FatalFailure() {
711 FAIL() << "Expected fatal failure.";
714 // Tests that EXPECT_FATAL_FAILURE() fails when there are two
716 TEST(ExpectFatalFailureTest
, FailsWhenThereAreTwoFatalFailures
) {
717 printf("(expecting a failure)\n");
718 EXPECT_FATAL_FAILURE({
724 // Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
726 TEST(ExpectFatalFailureTest
, FailsWhenThereIsOneNonfatalFailure
) {
727 printf("(expecting a failure)\n");
728 EXPECT_FATAL_FAILURE({
729 ADD_FAILURE() << "Expected non-fatal failure.";
733 // Tests that EXPECT_FATAL_FAILURE() fails when the statement being
735 TEST(ExpectFatalFailureTest
, FailsWhenStatementReturns
) {
736 printf("(expecting a failure)\n");
737 EXPECT_FATAL_FAILURE({
742 #if GTEST_HAS_EXCEPTIONS
744 // Tests that EXPECT_FATAL_FAILURE() fails when the statement being
746 TEST(ExpectFatalFailureTest
, FailsWhenStatementThrows
) {
747 printf("(expecting a failure)\n");
749 EXPECT_FATAL_FAILURE({
752 } catch(int) { // NOLINT
756 #endif // GTEST_HAS_EXCEPTIONS
758 // This #ifdef block tests the output of value-parameterized tests.
760 #if GTEST_HAS_PARAM_TEST
762 std::string
ParamNameFunc(const testing::TestParamInfo
<std::string
>& info
) {
766 class ParamTest
: public testing::TestWithParam
<std::string
> {
769 TEST_P(ParamTest
, Success
) {
770 EXPECT_EQ("a", GetParam());
773 TEST_P(ParamTest
, Failure
) {
774 EXPECT_EQ("b", GetParam()) << "Expected failure";
777 INSTANTIATE_TEST_CASE_P(PrintingStrings
,
779 testing::Values(std::string("a")),
782 #endif // GTEST_HAS_PARAM_TEST
784 // This #ifdef block tests the output of typed tests.
785 #if GTEST_HAS_TYPED_TEST
787 template <typename T
>
788 class TypedTest
: public testing::Test
{
791 TYPED_TEST_CASE(TypedTest
, testing::Types
<int>);
793 TYPED_TEST(TypedTest
, Success
) {
794 EXPECT_EQ(0, TypeParam());
797 TYPED_TEST(TypedTest
, Failure
) {
798 EXPECT_EQ(1, TypeParam()) << "Expected failure";
801 #endif // GTEST_HAS_TYPED_TEST
803 // This #ifdef block tests the output of type-parameterized tests.
804 #if GTEST_HAS_TYPED_TEST_P
806 template <typename T
>
807 class TypedTestP
: public testing::Test
{
810 TYPED_TEST_CASE_P(TypedTestP
);
812 TYPED_TEST_P(TypedTestP
, Success
) {
813 EXPECT_EQ(0U, TypeParam());
816 TYPED_TEST_P(TypedTestP
, Failure
) {
817 EXPECT_EQ(1U, TypeParam()) << "Expected failure";
820 REGISTER_TYPED_TEST_CASE_P(TypedTestP
, Success
, Failure
);
822 typedef testing::Types
<unsigned char, unsigned int> UnsignedTypes
;
823 INSTANTIATE_TYPED_TEST_CASE_P(Unsigned
, TypedTestP
, UnsignedTypes
);
825 #endif // GTEST_HAS_TYPED_TEST_P
827 #if GTEST_HAS_DEATH_TEST
829 // We rely on the golden file to verify that tests whose test case
830 // name ends with DeathTest are run first.
832 TEST(ADeathTest
, ShouldRunFirst
) {
835 # if GTEST_HAS_TYPED_TEST
837 // We rely on the golden file to verify that typed tests whose test
838 // case name ends with DeathTest are run first.
840 template <typename T
>
841 class ATypedDeathTest
: public testing::Test
{
844 typedef testing::Types
<int, double> NumericTypes
;
845 TYPED_TEST_CASE(ATypedDeathTest
, NumericTypes
);
847 TYPED_TEST(ATypedDeathTest
, ShouldRunFirst
) {
850 # endif // GTEST_HAS_TYPED_TEST
852 # if GTEST_HAS_TYPED_TEST_P
855 // We rely on the golden file to verify that type-parameterized tests
856 // whose test case name ends with DeathTest are run first.
858 template <typename T
>
859 class ATypeParamDeathTest
: public testing::Test
{
862 TYPED_TEST_CASE_P(ATypeParamDeathTest
);
864 TYPED_TEST_P(ATypeParamDeathTest
, ShouldRunFirst
) {
867 REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest
, ShouldRunFirst
);
869 INSTANTIATE_TYPED_TEST_CASE_P(My
, ATypeParamDeathTest
, NumericTypes
);
871 # endif // GTEST_HAS_TYPED_TEST_P
873 #endif // GTEST_HAS_DEATH_TEST
875 // Tests various failure conditions of
876 // EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
877 class ExpectFailureTest
: public testing::Test
{
878 public: // Must be public and not protected due to a bug in g++ 3.4.2.
883 static void AddFailure(FailureMode failure
) {
884 if (failure
== FATAL_FAILURE
) {
885 FAIL() << "Expected fatal failure.";
887 ADD_FAILURE() << "Expected non-fatal failure.";
892 TEST_F(ExpectFailureTest
, ExpectFatalFailure
) {
893 // Expected fatal failure, but succeeds.
894 printf("(expecting 1 failure)\n");
895 EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure.");
896 // Expected fatal failure, but got a non-fatal failure.
897 printf("(expecting 1 failure)\n");
898 EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE
), "Expected non-fatal "
901 printf("(expecting 1 failure)\n");
902 EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE
), "Some other fatal failure "
906 TEST_F(ExpectFailureTest
, ExpectNonFatalFailure
) {
907 // Expected non-fatal failure, but succeeds.
908 printf("(expecting 1 failure)\n");
909 EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure.");
910 // Expected non-fatal failure, but got a fatal failure.
911 printf("(expecting 1 failure)\n");
912 EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE
), "Expected fatal failure.");
914 printf("(expecting 1 failure)\n");
915 EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE
), "Some other non-fatal "
919 #if GTEST_IS_THREADSAFE
921 class ExpectFailureWithThreadsTest
: public ExpectFailureTest
{
923 static void AddFailureInOtherThread(FailureMode failure
) {
924 ThreadWithParam
<FailureMode
> thread(&AddFailure
, failure
, NULL
);
929 TEST_F(ExpectFailureWithThreadsTest
, ExpectFatalFailure
) {
930 // We only intercept the current thread.
931 printf("(expecting 2 failures)\n");
932 EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE
),
933 "Expected fatal failure.");
936 TEST_F(ExpectFailureWithThreadsTest
, ExpectNonFatalFailure
) {
937 // We only intercept the current thread.
938 printf("(expecting 2 failures)\n");
939 EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE
),
940 "Expected non-fatal failure.");
943 typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest
;
945 // Tests that the ScopedFakeTestPartResultReporter only catches failures from
946 // the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.
947 TEST_F(ScopedFakeTestPartResultReporterTest
, InterceptOnlyCurrentThread
) {
948 printf("(expecting 2 failures)\n");
949 TestPartResultArray results
;
951 ScopedFakeTestPartResultReporter
reporter(
952 ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD
,
954 AddFailureInOtherThread(FATAL_FAILURE
);
955 AddFailureInOtherThread(NONFATAL_FAILURE
);
957 // The two failures should not have been intercepted.
958 EXPECT_EQ(0, results
.size()) << "This shouldn't fail.";
961 #endif // GTEST_IS_THREADSAFE
963 TEST_F(ExpectFailureTest
, ExpectFatalFailureOnAllThreads
) {
964 // Expected fatal failure, but succeeds.
965 printf("(expecting 1 failure)\n");
966 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure.");
967 // Expected fatal failure, but got a non-fatal failure.
968 printf("(expecting 1 failure)\n");
969 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE
),
970 "Expected non-fatal failure.");
972 printf("(expecting 1 failure)\n");
973 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE
),
974 "Some other fatal failure expected.");
977 TEST_F(ExpectFailureTest
, ExpectNonFatalFailureOnAllThreads
) {
978 // Expected non-fatal failure, but succeeds.
979 printf("(expecting 1 failure)\n");
980 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal "
982 // Expected non-fatal failure, but got a fatal failure.
983 printf("(expecting 1 failure)\n");
984 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE
),
985 "Expected fatal failure.");
987 printf("(expecting 1 failure)\n");
988 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE
),
989 "Some other non-fatal failure.");
993 // Two test environments for testing testing::AddGlobalTestEnvironment().
995 class FooEnvironment
: public testing::Environment
{
997 virtual void SetUp() {
998 printf("%s", "FooEnvironment::SetUp() called.\n");
1001 virtual void TearDown() {
1002 printf("%s", "FooEnvironment::TearDown() called.\n");
1003 FAIL() << "Expected fatal failure.";
1007 class BarEnvironment
: public testing::Environment
{
1009 virtual void SetUp() {
1010 printf("%s", "BarEnvironment::SetUp() called.\n");
1013 virtual void TearDown() {
1014 printf("%s", "BarEnvironment::TearDown() called.\n");
1015 ADD_FAILURE() << "Expected non-fatal failure.";
1019 // The main function.
1021 // The idea is to use Google Test to run all the tests we have defined (some
1022 // of them are intended to fail), and then compare the test results
1023 // with the "golden" file.
1024 int main(int argc
, char **argv
) {
1025 testing::GTEST_FLAG(print_time
) = false;
1027 // We just run the tests, knowing some of them are intended to fail.
1028 // We will use a separate Python script to compare the output of
1029 // this program with the golden file.
1031 // It's hard to test InitGoogleTest() directly, as it has many
1032 // global side effects. The following line serves as a sanity test
1034 testing::InitGoogleTest(&argc
, argv
);
1035 bool internal_skip_environment_and_ad_hoc_tests
=
1036 std::count(argv
, argv
+ argc
,
1037 std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
1039 #if GTEST_HAS_DEATH_TEST
1040 if (testing::internal::GTEST_FLAG(internal_run_death_test
) != "") {
1041 // Skip the usual output capturing if we're running as the child
1042 // process of an threadsafe-style death test.
1043 # if GTEST_OS_WINDOWS
1044 posix::FReopen("nul:", "w", stdout
);
1046 posix::FReopen("/dev/null", "w", stdout
);
1047 # endif // GTEST_OS_WINDOWS
1048 return RUN_ALL_TESTS();
1050 #endif // GTEST_HAS_DEATH_TEST
1052 if (internal_skip_environment_and_ad_hoc_tests
)
1053 return RUN_ALL_TESTS();
1055 // Registers two global test environments.
1056 // The golden file verifies that they are set up in the order they
1057 // are registered, and torn down in the reverse order.
1058 testing::AddGlobalTestEnvironment(new FooEnvironment
);
1059 testing::AddGlobalTestEnvironment(new BarEnvironment
);
1061 return RunAllTests();