test/gtest_output_test_.cc

   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
  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, &notifications_, 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 }