1 // Copyright 2005, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 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 13 // distribution. 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. 17 // 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. 29 // 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 34 // FAIL. 35 // 36 // Author: wan (at) google.com (Zhanyong Wan) 37 38 #include "gtest/gtest-spi.h" 39 #include "gtest/gtest.h" 40 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 45 // his code. 46 #define GTEST_IMPLEMENTATION_ 1 47 #include "src/gtest-internal-inl.h" 48 #undef GTEST_IMPLEMENTATION_ 49 50 #include <stdlib.h> 51 52 #if GTEST_IS_THREADSAFE 53 using testing::ScopedFakeTestPartResultReporter; 54 using testing::TestPartResultArray; 55 56 using testing::internal::Notification; 57 using testing::internal::ThreadWithParam; 58 #endif 59 60 namespace posix = ::testing::internal::posix; 61 62 // Tests catching fatal failures. 63 64 // A subroutine used by the following test. 65 void TestEq1(int x) { 66 ASSERT_EQ(1, x); 67 } 68 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. 73 TestEq1(2); 74 75 // Catches the fatal failure and aborts the test. 76 // 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; 80 81 // If we get here, something is wrong. 82 FAIL() << "This should never be reached."; 83 } 84 85 TEST(PassingTest, PassingTest1) { 86 } 87 88 TEST(PassingTest, PassingTest2) { 89 } 90 91 // Tests that parameters of failing parameterized tests are printed in the 92 // failing test summary. 93 class FailingParamTest : public testing::TestWithParam<int> {}; 94 95 TEST_P(FailingParamTest, Fails) { 96 EXPECT_EQ(1, GetParam()); 97 } 98 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, 102 FailingParamTest, 103 testing::Values(2)); 104 105 static const char kGoldenString[] = "\"Line\0 1\"\nLine 2"; 106 107 TEST(NonfatalFailureTest, EscapesStringOperands) { 108 std::string actual = "actual \"string\""; 109 EXPECT_EQ(kGoldenString, actual); 110 111 const char* golden = kGoldenString; 112 EXPECT_EQ(golden, actual); 113 } 114 115 TEST(NonfatalFailureTest, DiffForLongStrings) { 116 std::string golden_str(kGoldenString, sizeof(kGoldenString) - 1); 117 EXPECT_EQ(golden_str, "Line 2"); 118 } 119 120 // Tests catching a fatal failure in a subroutine. 121 TEST(FatalFailureTest, FatalFailureInSubroutine) { 122 printf("(expecting a failure that x should be 1)\n"); 123 124 TryTestSubroutine(); 125 } 126 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"); 130 131 // Calls a subrountine that yields a fatal failure. 132 TryTestSubroutine(); 133 134 // Catches the fatal failure and aborts the test. 135 // 136 // When calling HasFatalFailure() inside a TEST, TEST_F, or test 137 // fixture, the testing::Test:: prefix is not needed. 138 if (HasFatalFailure()) return; 139 140 // If we get here, something is wrong. 141 FAIL() << "This should never be reached."; 142 } 143 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. 149 } 150 151 // Tests interleaving user logging and Google Test assertions. 152 TEST(LoggingTest, InterleavingLoggingAndAssertions) { 153 static const int a[4] = { 154 3, 9, 2, 6 155 }; 156 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); 160 EXPECT_GE(3, a[i]); 161 } 162 } 163 164 // Tests the SCOPED_TRACE macro. 165 166 // A helper function for testing SCOPED_TRACE. 167 void SubWithoutTrace(int n) { 168 EXPECT_EQ(1, n); 169 ASSERT_EQ(2, n); 170 } 171 172 // Another helper function for testing SCOPED_TRACE. 173 void SubWithTrace(int n) { 174 SCOPED_TRACE(testing::Message() << "n = " << n); 175 176 SubWithoutTrace(n); 177 } 178 179 // Tests that SCOPED_TRACE() obeys lexical scopes. 180 TEST(SCOPED_TRACETest, ObeysScopes) { 181 printf("(expected to fail)\n"); 182 183 // There should be no trace before SCOPED_TRACE() is invoked. 184 ADD_FAILURE() << "This failure is expected, and shouldn't have a trace."; 185 186 { 187 SCOPED_TRACE("Expected trace"); 188 // After SCOPED_TRACE(), a failure in the current scope should contain 189 // the trace. 190 ADD_FAILURE() << "This failure is expected, and should have a trace."; 191 } 192 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."; 196 } 197 198 // Tests that SCOPED_TRACE works inside a loop. 199 TEST(SCOPED_TRACETest, WorksInLoop) { 200 printf("(expected to fail)\n"); 201 202 for (int i = 1; i <= 2; i++) { 203 SCOPED_TRACE(testing::Message() << "i = " << i); 204 205 SubWithoutTrace(i); 206 } 207 } 208 209 // Tests that SCOPED_TRACE works in a subroutine. 210 TEST(SCOPED_TRACETest, WorksInSubroutine) { 211 printf("(expected to fail)\n"); 212 213 SubWithTrace(1); 214 SubWithTrace(2); 215 } 216 217 // Tests that SCOPED_TRACE can be nested. 218 TEST(SCOPED_TRACETest, CanBeNested) { 219 printf("(expected to fail)\n"); 220 221 SCOPED_TRACE(""); // A trace without a message. 222 223 SubWithTrace(2); 224 } 225 226 // Tests that multiple SCOPED_TRACEs can be used in the same scope. 227 TEST(SCOPED_TRACETest, CanBeRepeated) { 228 printf("(expected to fail)\n"); 229 230 SCOPED_TRACE("A"); 231 ADD_FAILURE() 232 << "This failure is expected, and should contain trace point A."; 233 234 SCOPED_TRACE("B"); 235 ADD_FAILURE() 236 << "This failure is expected, and should contain trace point A and B."; 237 238 { 239 SCOPED_TRACE("C"); 240 ADD_FAILURE() << "This failure is expected, and should " 241 << "contain trace point A, B, and C."; 242 } 243 244 SCOPED_TRACE("D"); 245 ADD_FAILURE() << "This failure is expected, and should " 246 << "contain trace point A, B, and D."; 247 } 248 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. 253 254 // Here's the sequence of actions that happen in the test: 255 // 256 // Thread A (main) | Thread B (spawned) 257 // ===============================|================================ 258 // spawns thread B | 259 // -------------------------------+-------------------------------- 260 // waits for n1 | SCOPED_TRACE("Trace B"); 261 // | generates failure #1 262 // | notifies n1 263 // -------------------------------+-------------------------------- 264 // SCOPED_TRACE("Trace A"); | waits for n2 265 // generates failure #2 | 266 // notifies n2 | 267 // -------------------------------|-------------------------------- 268 // waits for n3 | generates failure #3 269 // | trace B dies 270 // | generates failure #4 271 // | notifies n3 272 // -------------------------------|-------------------------------- 273 // generates failure #5 | finishes 274 // trace A dies | 275 // generates failure #6 | 276 // -------------------------------|-------------------------------- 277 // waits for thread B to finish | 278 279 struct CheckPoints { 280 Notification n1; 281 Notification n2; 282 Notification n3; 283 }; 284 285 static void ThreadWithScopedTrace(CheckPoints* check_points) { 286 { 287 SCOPED_TRACE("Trace B"); 288 ADD_FAILURE() 289 << "Expected failure #1 (in thread B, only trace B alive)."; 290 check_points->n1.Notify(); 291 check_points->n2.WaitForNotification(); 292 293 ADD_FAILURE() 294 << "Expected failure #3 (in thread B, trace A & B both alive)."; 295 } // Trace B dies here. 296 ADD_FAILURE() 297 << "Expected failure #4 (in thread B, only trace A alive)."; 298 check_points->n3.Notify(); 299 } 300 301 TEST(SCOPED_TRACETest, WorksConcurrently) { 302 printf("(expecting 6 failures)\n"); 303 304 CheckPoints check_points; 305 ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, 306 &check_points, 307 NULL); 308 check_points.n1.WaitForNotification(); 309 310 { 311 SCOPED_TRACE("Trace A"); 312 ADD_FAILURE() 313 << "Expected failure #2 (in thread A, trace A & B both alive)."; 314 check_points.n2.Notify(); 315 check_points.n3.WaitForNotification(); 316 317 ADD_FAILURE() 318 << "Expected failure #5 (in thread A, only trace A alive)."; 319 } // Trace A dies here. 320 ADD_FAILURE() 321 << "Expected failure #6 (in thread A, no trace alive)."; 322 thread.Join(); 323 } 324 #endif // GTEST_IS_THREADSAFE 325 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 331 // the test output. 332 } 333 334 // Tests using assertions outside of TEST and TEST_F. 335 // 336 // This function creates two failures intentionally. 337 void AdHocTest() { 338 printf("The non-test part of the code is expected to have 2 failures.\n\n"); 339 EXPECT_TRUE(false); 340 EXPECT_EQ(2, 3); 341 } 342 343 // Runs all TESTs, all TEST_Fs, and the ad hoc test. 344 int RunAllTests() { 345 AdHocTest(); 346 return RUN_ALL_TESTS(); 347 } 348 349 // Tests non-fatal failures in the fixture constructor. 350 class NonFatalFailureInFixtureConstructorTest : public testing::Test { 351 protected: 352 NonFatalFailureInFixtureConstructorTest() { 353 printf("(expecting 5 failures)\n"); 354 ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor."; 355 } 356 357 ~NonFatalFailureInFixtureConstructorTest() { 358 ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor."; 359 } 360 361 virtual void SetUp() { 362 ADD_FAILURE() << "Expected failure #2, in SetUp()."; 363 } 364 365 virtual void TearDown() { 366 ADD_FAILURE() << "Expected failure #4, in TearDown."; 367 } 368 }; 369 370 TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) { 371 ADD_FAILURE() << "Expected failure #3, in the test body."; 372 } 373 374 // Tests fatal failures in the fixture constructor. 375 class FatalFailureInFixtureConstructorTest : public testing::Test { 376 protected: 377 FatalFailureInFixtureConstructorTest() { 378 printf("(expecting 2 failures)\n"); 379 Init(); 380 } 381 382 ~FatalFailureInFixtureConstructorTest() { 383 ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor."; 384 } 385 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."; 390 } 391 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."; 396 } 397 398 private: 399 void Init() { 400 FAIL() << "Expected failure #1, in the test fixture c'tor."; 401 } 402 }; 403 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."; 408 } 409 410 // Tests non-fatal failures in SetUp(). 411 class NonFatalFailureInSetUpTest : public testing::Test { 412 protected: 413 virtual ~NonFatalFailureInSetUpTest() { 414 Deinit(); 415 } 416 417 virtual void SetUp() { 418 printf("(expecting 4 failures)\n"); 419 ADD_FAILURE() << "Expected failure #1, in SetUp()."; 420 } 421 422 virtual void TearDown() { 423 FAIL() << "Expected failure #3, in TearDown()."; 424 } 425 private: 426 void Deinit() { 427 FAIL() << "Expected failure #4, in the test fixture d'tor."; 428 } 429 }; 430 431 TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) { 432 FAIL() << "Expected failure #2, in the test function."; 433 } 434 435 // Tests fatal failures in SetUp(). 436 class FatalFailureInSetUpTest : public testing::Test { 437 protected: 438 virtual ~FatalFailureInSetUpTest() { 439 Deinit(); 440 } 441 442 virtual void SetUp() { 443 printf("(expecting 3 failures)\n"); 444 FAIL() << "Expected failure #1, in SetUp()."; 445 } 446 447 virtual void TearDown() { 448 FAIL() << "Expected failure #2, in TearDown()."; 449 } 450 private: 451 void Deinit() { 452 FAIL() << "Expected failure #3, in the test fixture d'tor."; 453 } 454 }; 455 456 TEST_F(FatalFailureInSetUpTest, FailureInSetUp) { 457 FAIL() << "UNEXPECTED failure in the test function. " 458 << "We should never get here, as SetUp() failed."; 459 } 460 461 TEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) { 462 ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc"; 463 } 464 465 #if GTEST_IS_THREADSAFE 466 467 // A unary function that may die. 468 void DieIf(bool should_die) { 469 GTEST_CHECK_(!should_die) << " - death inside DieIf()."; 470 } 471 472 // Tests running death tests in a multi-threaded context. 473 474 // Used for coordination between the main and the spawn thread. 475 struct SpawnThreadNotifications { 476 SpawnThreadNotifications() {} 477 478 Notification spawn_thread_started; 479 Notification spawn_thread_ok_to_terminate; 480 481 private: 482 GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications); 483 }; 484 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(); 490 491 // Waits for permission to finish from the main thread. 492 notifications->spawn_thread_ok_to_terminate.WaitForNotification(); 493 } 494 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 { 499 protected: 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(); 505 } 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(); 513 } 514 515 private: 516 SpawnThreadNotifications notifications_; 517 testing::internal::scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> > 518 thread_; 519 }; 520 521 #endif // GTEST_IS_THREADSAFE 522 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. 527 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 531 // fail. 532 533 namespace foo { 534 535 class MixedUpTestCaseTest : public testing::Test { 536 }; 537 538 TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {} 539 TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {} 540 541 class MixedUpTestCaseWithSameTestNameTest : public testing::Test { 542 }; 543 544 TEST_F(MixedUpTestCaseWithSameTestNameTest, 545 TheSecondTestWithThisNameShouldFail) {} 546 547 } // namespace foo 548 549 namespace bar { 550 551 class MixedUpTestCaseTest : public testing::Test { 552 }; 553 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) {} 558 559 class MixedUpTestCaseWithSameTestNameTest : public testing::Test { 560 }; 561 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) {} 566 567 } // namespace bar 568 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. 573 574 class TEST_F_before_TEST_in_same_test_case : public testing::Test { 575 }; 576 577 TEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {} 578 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) {} 582 583 class TEST_before_TEST_F_in_same_test_case : public testing::Test { 584 }; 585 586 TEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {} 587 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) { 591 } 592 593 // Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE(). 594 int global_integer = 0; 595 596 // Tests that EXPECT_NONFATAL_FAILURE() can reference global variables. 597 TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) { 598 global_integer = 0; 599 EXPECT_NONFATAL_FAILURE({ 600 EXPECT_EQ(1, global_integer) << "Expected non-fatal failure."; 601 }, "Expected non-fatal failure."); 602 } 603 604 // Tests that EXPECT_NONFATAL_FAILURE() can reference local variables 605 // (static or not). 606 TEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) { 607 int m = 0; 608 static int n; 609 n = 1; 610 EXPECT_NONFATAL_FAILURE({ 611 EXPECT_EQ(m, n) << "Expected non-fatal failure."; 612 }, "Expected non-fatal failure."); 613 } 614 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."); 621 } 622 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({ 628 }, ""); 629 } 630 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."; 638 }, ""); 639 } 640 641 // Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal 642 // failure. 643 TEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) { 644 printf("(expecting a failure)\n"); 645 EXPECT_NONFATAL_FAILURE({ 646 FAIL() << "Expected fatal failure."; 647 }, ""); 648 } 649 650 // Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being 651 // tested returns. 652 TEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) { 653 printf("(expecting a failure)\n"); 654 EXPECT_NONFATAL_FAILURE({ 655 return; 656 }, ""); 657 } 658 659 #if GTEST_HAS_EXCEPTIONS 660 661 // Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being 662 // tested throws. 663 TEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) { 664 printf("(expecting a failure)\n"); 665 try { 666 EXPECT_NONFATAL_FAILURE({ 667 throw 0; 668 }, ""); 669 } catch(int) { // NOLINT 670 } 671 } 672 673 #endif // GTEST_HAS_EXCEPTIONS 674 675 // Tests that EXPECT_FATAL_FAILURE() can reference global variables. 676 TEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) { 677 global_integer = 0; 678 EXPECT_FATAL_FAILURE({ 679 ASSERT_EQ(1, global_integer) << "Expected fatal failure."; 680 }, "Expected fatal failure."); 681 } 682 683 // Tests that EXPECT_FATAL_FAILURE() can reference local static 684 // variables. 685 TEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) { 686 static int n; 687 n = 1; 688 EXPECT_FATAL_FAILURE({ 689 ASSERT_EQ(0, n) << "Expected fatal failure."; 690 }, "Expected fatal failure."); 691 } 692 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."); 699 } 700 701 // Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal 702 // failure. 703 TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) { 704 printf("(expecting a failure)\n"); 705 EXPECT_FATAL_FAILURE({ 706 }, ""); 707 } 708 709 // A helper for generating a fatal failure. 710 void FatalFailure() { 711 FAIL() << "Expected fatal failure."; 712 } 713 714 // Tests that EXPECT_FATAL_FAILURE() fails when there are two 715 // fatal failures. 716 TEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) { 717 printf("(expecting a failure)\n"); 718 EXPECT_FATAL_FAILURE({ 719 FatalFailure(); 720 FatalFailure(); 721 }, ""); 722 } 723 724 // Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal 725 // failure. 726 TEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) { 727 printf("(expecting a failure)\n"); 728 EXPECT_FATAL_FAILURE({ 729 ADD_FAILURE() << "Expected non-fatal failure."; 730 }, ""); 731 } 732 733 // Tests that EXPECT_FATAL_FAILURE() fails when the statement being 734 // tested returns. 735 TEST(ExpectFatalFailureTest, FailsWhenStatementReturns) { 736 printf("(expecting a failure)\n"); 737 EXPECT_FATAL_FAILURE({ 738 return; 739 }, ""); 740 } 741 742 #if GTEST_HAS_EXCEPTIONS 743 744 // Tests that EXPECT_FATAL_FAILURE() fails when the statement being 745 // tested throws. 746 TEST(ExpectFatalFailureTest, FailsWhenStatementThrows) { 747 printf("(expecting a failure)\n"); 748 try { 749 EXPECT_FATAL_FAILURE({ 750 throw 0; 751 }, ""); 752 } catch(int) { // NOLINT 753 } 754 } 755 756 #endif // GTEST_HAS_EXCEPTIONS 757 758 // This #ifdef block tests the output of value-parameterized tests. 759 760 #if GTEST_HAS_PARAM_TEST 761 762 std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) { 763 return info.param; 764 } 765 766 class ParamTest : public testing::TestWithParam<std::string> { 767 }; 768 769 TEST_P(ParamTest, Success) { 770 EXPECT_EQ("a", GetParam()); 771 } 772 773 TEST_P(ParamTest, Failure) { 774 EXPECT_EQ("b", GetParam()) << "Expected failure"; 775 } 776 777 INSTANTIATE_TEST_CASE_P(PrintingStrings, 778 ParamTest, 779 testing::Values(std::string("a")), 780 ParamNameFunc); 781 782 #endif // GTEST_HAS_PARAM_TEST 783 784 // This #ifdef block tests the output of typed tests. 785 #if GTEST_HAS_TYPED_TEST 786 787 template <typename T> 788 class TypedTest : public testing::Test { 789 }; 790 791 TYPED_TEST_CASE(TypedTest, testing::Types<int>); 792 793 TYPED_TEST(TypedTest, Success) { 794 EXPECT_EQ(0, TypeParam()); 795 } 796 797 TYPED_TEST(TypedTest, Failure) { 798 EXPECT_EQ(1, TypeParam()) << "Expected failure"; 799 } 800 801 #endif // GTEST_HAS_TYPED_TEST 802 803 // This #ifdef block tests the output of type-parameterized tests. 804 #if GTEST_HAS_TYPED_TEST_P 805 806 template <typename T> 807 class TypedTestP : public testing::Test { 808 }; 809 810 TYPED_TEST_CASE_P(TypedTestP); 811 812 TYPED_TEST_P(TypedTestP, Success) { 813 EXPECT_EQ(0U, TypeParam()); 814 } 815 816 TYPED_TEST_P(TypedTestP, Failure) { 817 EXPECT_EQ(1U, TypeParam()) << "Expected failure"; 818 } 819 820 REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure); 821 822 typedef testing::Types<unsigned char, unsigned int> UnsignedTypes; 823 INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes); 824 825 #endif // GTEST_HAS_TYPED_TEST_P 826 827 #if GTEST_HAS_DEATH_TEST 828 829 // We rely on the golden file to verify that tests whose test case 830 // name ends with DeathTest are run first. 831 832 TEST(ADeathTest, ShouldRunFirst) { 833 } 834 835 # if GTEST_HAS_TYPED_TEST 836 837 // We rely on the golden file to verify that typed tests whose test 838 // case name ends with DeathTest are run first. 839 840 template <typename T> 841 class ATypedDeathTest : public testing::Test { 842 }; 843 844 typedef testing::Types<int, double> NumericTypes; 845 TYPED_TEST_CASE(ATypedDeathTest, NumericTypes); 846 847 TYPED_TEST(ATypedDeathTest, ShouldRunFirst) { 848 } 849 850 # endif // GTEST_HAS_TYPED_TEST 851 852 # if GTEST_HAS_TYPED_TEST_P 853 854 855 // We rely on the golden file to verify that type-parameterized tests 856 // whose test case name ends with DeathTest are run first. 857 858 template <typename T> 859 class ATypeParamDeathTest : public testing::Test { 860 }; 861 862 TYPED_TEST_CASE_P(ATypeParamDeathTest); 863 864 TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) { 865 } 866 867 REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst); 868 869 INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes); 870 871 # endif // GTEST_HAS_TYPED_TEST_P 872 873 #endif // GTEST_HAS_DEATH_TEST 874 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. 879 enum FailureMode { 880 FATAL_FAILURE, 881 NONFATAL_FAILURE 882 }; 883 static void AddFailure(FailureMode failure) { 884 if (failure == FATAL_FAILURE) { 885 FAIL() << "Expected fatal failure."; 886 } else { 887 ADD_FAILURE() << "Expected non-fatal failure."; 888 } 889 } 890 }; 891 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 " 899 "failure."); 900 // Wrong message. 901 printf("(expecting 1 failure)\n"); 902 EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure " 903 "expected."); 904 } 905 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."); 913 // Wrong message. 914 printf("(expecting 1 failure)\n"); 915 EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal " 916 "failure."); 917 } 918 919 #if GTEST_IS_THREADSAFE 920 921 class ExpectFailureWithThreadsTest : public ExpectFailureTest { 922 protected: 923 static void AddFailureInOtherThread(FailureMode failure) { 924 ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 925 thread.Join(); 926 } 927 }; 928 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."); 934 } 935 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."); 941 } 942 943 typedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest; 944 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; 950 { 951 ScopedFakeTestPartResultReporter reporter( 952 ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 953 &results); 954 AddFailureInOtherThread(FATAL_FAILURE); 955 AddFailureInOtherThread(NONFATAL_FAILURE); 956 } 957 // The two failures should not have been intercepted. 958 EXPECT_EQ(0, results.size()) << "This shouldn't fail."; 959 } 960 961 #endif // GTEST_IS_THREADSAFE 962 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."); 971 // Wrong message. 972 printf("(expecting 1 failure)\n"); 973 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE), 974 "Some other fatal failure expected."); 975 } 976 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 " 981 "failure."); 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."); 986 // Wrong message. 987 printf("(expecting 1 failure)\n"); 988 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE), 989 "Some other non-fatal failure."); 990 } 991 992 993 // Two test environments for testing testing::AddGlobalTestEnvironment(). 994 995 class FooEnvironment : public testing::Environment { 996 public: 997 virtual void SetUp() { 998 printf("%s", "FooEnvironment::SetUp() called.\n"); 999 } 1000 1001 virtual void TearDown() { 1002 printf("%s", "FooEnvironment::TearDown() called.\n"); 1003 FAIL() << "Expected fatal failure."; 1004 } 1005 }; 1006 1007 class BarEnvironment : public testing::Environment { 1008 public: 1009 virtual void SetUp() { 1010 printf("%s", "BarEnvironment::SetUp() called.\n"); 1011 } 1012 1013 virtual void TearDown() { 1014 printf("%s", "BarEnvironment::TearDown() called.\n"); 1015 ADD_FAILURE() << "Expected non-fatal failure."; 1016 } 1017 }; 1018 1019 // The main function. 1020 // 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; 1026 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. 1030 1031 // It's hard to test InitGoogleTest() directly, as it has many 1032 // global side effects. The following line serves as a sanity test 1033 // for it. 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; 1038 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); 1045 # else 1046 posix::FReopen("/dev/null", "w", stdout); 1047 # endif // GTEST_OS_WINDOWS 1048 return RUN_ALL_TESTS(); 1049 } 1050 #endif // GTEST_HAS_DEATH_TEST 1051 1052 if (internal_skip_environment_and_ad_hoc_tests) 1053 return RUN_ALL_TESTS(); 1054 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); 1060 1061 return RunAllTests(); 1062 } 1063