Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gtest_output_test_.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file 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
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.
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 
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,
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 
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.
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 
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.
351  protected:
353  printf("(expecting 5 failures)\n");
354  ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor.";
355  }
356 
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 
371  ADD_FAILURE() << "Expected failure #3, in the test body.";
372 }
373 
374 // Tests fatal failures in the fixture constructor.
376  protected:
378  printf("(expecting 2 failures)\n");
379  Init();
380  }
381 
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 
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().
412  protected:
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 
432  FAIL() << "Expected failure #2, in the test function.";
433 }
434 
435 // Tests fatal failures in SetUp().
437  protected:
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_;
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 
536 };
537 
538 TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {}
539 TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {}
540 
542 };
543 
545  TheSecondTestWithThisNameShouldFail) {}
546 
547 } // namespace foo
548 
549 namespace bar {
550 
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 
560 };
561 
562 // Expected to fail. We rely on the golden file to check that Google Test
563 // generates the right error message.
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 
575 };
576 
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 
584 };
585 
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().
595 
596 // Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
597 TEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) {
598  global_integer = 0;
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;
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) {
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");
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");
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");
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");
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 {
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;
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;
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) {
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");
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");
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");
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");
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 {
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}.
878  public: // Must be public and not protected due to a bug in g++ 3.4.2.
879  enum FailureMode {
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 
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 
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.
1060 
1061  return RunAllTests();
1062 }