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@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 53using testing::ScopedFakeTestPartResultReporter; 54using testing::TestPartResultArray; 55 56using testing::internal::Notification; 57using testing::internal::ThreadWithParam; 58#endif 59 60namespace posix = ::testing::internal::posix; 61 62// Tests catching fatal failures. 63 64// A subroutine used by the following test. 65void 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. 71void 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 85TEST(PassingTest, PassingTest1) { 86} 87 88TEST(PassingTest, PassingTest2) { 89} 90 91// Tests that parameters of failing parameterized tests are printed in the 92// failing test summary. 93class FailingParamTest : public testing::TestWithParam<int> {}; 94 95TEST_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. 101INSTANTIATE_TEST_CASE_P(PrintingFailingParams, 102 FailingParamTest, 103 testing::Values(2)); 104 105static const char kGoldenString[] = "\"Line\0 1\"\nLine 2"; 106 107TEST(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 115TEST(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. 121TEST(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. 128TEST(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. 145TEST(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. 152TEST(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. 167void SubWithoutTrace(int n) { 168 EXPECT_EQ(1, n); 169 ASSERT_EQ(2, n); 170} 171 172// Another helper function for testing SCOPED_TRACE. 173void SubWithTrace(int n) { 174 SCOPED_TRACE(testing::Message() << "n = " << n); 175 176 SubWithoutTrace(n); 177} 178 179// Tests that SCOPED_TRACE() obeys lexical scopes. 180TEST(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. 199TEST(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. 210TEST(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. 218TEST(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. 227TEST(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 279struct CheckPoints { 280 Notification n1; 281 Notification n2; 282 Notification n3; 283}; 284 285static 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 301TEST(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 326TEST(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. 337void 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. 344int RunAllTests() { 345 AdHocTest(); 346 return RUN_ALL_TESTS(); 347} 348 349// Tests non-fatal failures in the fixture constructor. 350class 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 370TEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) { 371 ADD_FAILURE() << "Expected failure #3, in the test body."; 372} 373 374// Tests fatal failures in the fixture constructor. 375class 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 404TEST_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(). 411class 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 431TEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) { 432 FAIL() << "Expected failure #2, in the test function."; 433} 434 435// Tests fatal failures in SetUp(). 436class 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 456TEST_F(FatalFailureInSetUpTest, FailureInSetUp) { 457 FAIL() << "UNEXPECTED failure in the test function. " 458 << "We should never get here, as SetUp() failed."; 459} 460 461TEST(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. 468void 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. 475struct 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). 487static 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. 498class 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 533namespace foo { 534 535class MixedUpTestCaseTest : public testing::Test { 536}; 537 538TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {} 539TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {} 540 541class MixedUpTestCaseWithSameTestNameTest : public testing::Test { 542}; 543 544TEST_F(MixedUpTestCaseWithSameTestNameTest, 545 TheSecondTestWithThisNameShouldFail) {} 546 547} // namespace foo 548 549namespace bar { 550 551class 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. 556TEST_F(MixedUpTestCaseTest, ThisShouldFail) {} 557TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {} 558 559class 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. 564TEST_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 574class TEST_F_before_TEST_in_same_test_case : public testing::Test { 575}; 576 577TEST_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. 581TEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {} 582 583class TEST_before_TEST_F_in_same_test_case : public testing::Test { 584}; 585 586TEST(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. 590TEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) { 591} 592 593// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE(). 594int global_integer = 0; 595 596// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables. 597TEST(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). 606TEST(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. 617TEST(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. 625TEST(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. 633TEST(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. 643TEST(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. 652TEST(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. 663TEST(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. 676TEST(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. 685TEST(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. 695TEST(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. 703TEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) { 704 printf("(expecting a failure)\n"); 705 EXPECT_FATAL_FAILURE({ 706 }, ""); 707} 708 709// A helper for generating a fatal failure. 710void FatalFailure() { 711 FAIL() << "Expected fatal failure."; 712} 713 714// Tests that EXPECT_FATAL_FAILURE() fails when there are two 715// fatal failures. 716TEST(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. 726TEST(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. 735TEST(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. 746TEST(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 762std::string ParamNameFunc(const testing::TestParamInfo<std::string>& info) { 763 return info.param; 764} 765 766class ParamTest : public testing::TestWithParam<std::string> { 767}; 768 769TEST_P(ParamTest, Success) { 770 EXPECT_EQ("a", GetParam()); 771} 772 773TEST_P(ParamTest, Failure) { 774 EXPECT_EQ("b", GetParam()) << "Expected failure"; 775} 776 777INSTANTIATE_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 787template <typename T> 788class TypedTest : public testing::Test { 789}; 790 791TYPED_TEST_CASE(TypedTest, testing::Types<int>); 792 793TYPED_TEST(TypedTest, Success) { 794 EXPECT_EQ(0, TypeParam()); 795} 796 797TYPED_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 806template <typename T> 807class TypedTestP : public testing::Test { 808}; 809 810TYPED_TEST_CASE_P(TypedTestP); 811 812TYPED_TEST_P(TypedTestP, Success) { 813 EXPECT_EQ(0U, TypeParam()); 814} 815 816TYPED_TEST_P(TypedTestP, Failure) { 817 EXPECT_EQ(1U, TypeParam()) << "Expected failure"; 818} 819 820REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure); 821 822typedef testing::Types<unsigned char, unsigned int> UnsignedTypes; 823INSTANTIATE_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 832TEST(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 840template <typename T> 841class ATypedDeathTest : public testing::Test { 842}; 843 844typedef testing::Types<int, double> NumericTypes; 845TYPED_TEST_CASE(ATypedDeathTest, NumericTypes); 846 847TYPED_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 858template <typename T> 859class ATypeParamDeathTest : public testing::Test { 860}; 861 862TYPED_TEST_CASE_P(ATypeParamDeathTest); 863 864TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) { 865} 866 867REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst); 868 869INSTANTIATE_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}. 877class 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 892TEST_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 906TEST_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 921class ExpectFailureWithThreadsTest : public ExpectFailureTest { 922 protected: 923 static void AddFailureInOtherThread(FailureMode failure) { 924 ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 925 thread.Join(); 926 } 927}; 928 929TEST_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 936TEST_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 943typedef 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. 947TEST_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 963TEST_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 977TEST_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 995class 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 1007class 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. 1024int 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