[ceph.git] / ceph / src / jaegertracing / opentelemetry-cpp / third_party / googletest / googletest / test / googletest-output-test-golden-lin.txt

The non-test part of the code is expected to have 2 failures.

googletest-output-test_.cc:#: Failure
Value of: false
  Actual: false
Expected: true
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Expected equality of these values:
  2
  3
Stack trace: (omitted)

\e[0;32m[==========] \e[mRunning 88 tests from 41 test suites.
\e[0;32m[----------] \e[mGlobal test environment set-up.
FooEnvironment::SetUp() called.
BarEnvironment::SetUp() called.
\e[0;32m[----------] \e[m1 test from ADeathTest
\e[0;32m[ RUN      ] \e[mADeathTest.ShouldRunFirst
\e[0;32m[       OK ] \e[mADeathTest.ShouldRunFirst
\e[0;32m[----------] \e[m1 test from ATypedDeathTest/0, where TypeParam = int
\e[0;32m[ RUN      ] \e[mATypedDeathTest/0.ShouldRunFirst
\e[0;32m[       OK ] \e[mATypedDeathTest/0.ShouldRunFirst
\e[0;32m[----------] \e[m1 test from ATypedDeathTest/1, where TypeParam = double
\e[0;32m[ RUN      ] \e[mATypedDeathTest/1.ShouldRunFirst
\e[0;32m[       OK ] \e[mATypedDeathTest/1.ShouldRunFirst
\e[0;32m[----------] \e[m1 test from My/ATypeParamDeathTest/0, where TypeParam = int
\e[0;32m[ RUN      ] \e[mMy/ATypeParamDeathTest/0.ShouldRunFirst
\e[0;32m[       OK ] \e[mMy/ATypeParamDeathTest/0.ShouldRunFirst
\e[0;32m[----------] \e[m1 test from My/ATypeParamDeathTest/1, where TypeParam = double
\e[0;32m[ RUN      ] \e[mMy/ATypeParamDeathTest/1.ShouldRunFirst
\e[0;32m[       OK ] \e[mMy/ATypeParamDeathTest/1.ShouldRunFirst
\e[0;32m[----------] \e[m2 tests from PassingTest
\e[0;32m[ RUN      ] \e[mPassingTest.PassingTest1
\e[0;32m[       OK ] \e[mPassingTest.PassingTest1
\e[0;32m[ RUN      ] \e[mPassingTest.PassingTest2
\e[0;32m[       OK ] \e[mPassingTest.PassingTest2
\e[0;32m[----------] \e[m2 tests from NonfatalFailureTest
\e[0;32m[ RUN      ] \e[mNonfatalFailureTest.EscapesStringOperands
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  kGoldenString
    Which is: "\"Line"
  actual
    Which is: "actual \"string\""
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Expected equality of these values:
  golden
    Which is: "\"Line"
  actual
    Which is: "actual \"string\""
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mNonfatalFailureTest.EscapesStringOperands
\e[0;32m[ RUN      ] \e[mNonfatalFailureTest.DiffForLongStrings
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  golden_str
    Which is: "\"Line\0 1\"\nLine 2"
  "Line 2"
With diff:
@@ -1,2 @@
-\"Line\0 1\"
 Line 2

Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mNonfatalFailureTest.DiffForLongStrings
\e[0;32m[----------] \e[m3 tests from FatalFailureTest
\e[0;32m[ RUN      ] \e[mFatalFailureTest.FatalFailureInSubroutine
(expecting a failure that x should be 1)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  x
    Which is: 2
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mFatalFailureTest.FatalFailureInSubroutine
\e[0;32m[ RUN      ] \e[mFatalFailureTest.FatalFailureInNestedSubroutine
(expecting a failure that x should be 1)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  x
    Which is: 2
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mFatalFailureTest.FatalFailureInNestedSubroutine
\e[0;32m[ RUN      ] \e[mFatalFailureTest.NonfatalFailureInSubroutine
(expecting a failure on false)
googletest-output-test_.cc:#: Failure
Value of: false
  Actual: false
Expected: true
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mFatalFailureTest.NonfatalFailureInSubroutine
\e[0;32m[----------] \e[m1 test from LoggingTest
\e[0;32m[ RUN      ] \e[mLoggingTest.InterleavingLoggingAndAssertions
(expecting 2 failures on (3) >= (a[i]))
i == 0
i == 1
googletest-output-test_.cc:#: Failure
Expected: (3) >= (a[i]), actual: 3 vs 9
Stack trace: (omitted)

i == 2
i == 3
googletest-output-test_.cc:#: Failure
Expected: (3) >= (a[i]), actual: 3 vs 6
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mLoggingTest.InterleavingLoggingAndAssertions
\e[0;32m[----------] \e[m7 tests from SCOPED_TRACETest
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.AcceptedValues
googletest-output-test_.cc:#: Failure
Failed
Just checking that all these values work fine.
Google Test trace:
googletest-output-test_.cc:#: (null)
googletest-output-test_.cc:#: 1337
googletest-output-test_.cc:#: std::string
googletest-output-test_.cc:#: literal string
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.AcceptedValues
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.ObeysScopes
(expected to fail)
googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and shouldn't have a trace.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and should have a trace.
Google Test trace:
googletest-output-test_.cc:#: Expected trace
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and shouldn't have a trace.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.ObeysScopes
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.WorksInLoop
(expected to fail)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  2
  n
    Which is: 1
Google Test trace:
googletest-output-test_.cc:#: i = 1
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  n
    Which is: 2
Google Test trace:
googletest-output-test_.cc:#: i = 2
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksInLoop
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.WorksInSubroutine
(expected to fail)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  2
  n
    Which is: 1
Google Test trace:
googletest-output-test_.cc:#: n = 1
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  n
    Which is: 2
Google Test trace:
googletest-output-test_.cc:#: n = 2
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksInSubroutine
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.CanBeNested
(expected to fail)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  n
    Which is: 2
Google Test trace:
googletest-output-test_.cc:#: n = 2
googletest-output-test_.cc:#: 
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.CanBeNested
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.CanBeRepeated
(expected to fail)
googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and should contain trace point A.
Google Test trace:
googletest-output-test_.cc:#: A
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and should contain trace point A and B.
Google Test trace:
googletest-output-test_.cc:#: B
googletest-output-test_.cc:#: A
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and should contain trace point A, B, and C.
Google Test trace:
googletest-output-test_.cc:#: C
googletest-output-test_.cc:#: B
googletest-output-test_.cc:#: A
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
This failure is expected, and should contain trace point A, B, and D.
Google Test trace:
googletest-output-test_.cc:#: D
googletest-output-test_.cc:#: B
googletest-output-test_.cc:#: A
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.CanBeRepeated
\e[0;32m[ RUN      ] \e[mSCOPED_TRACETest.WorksConcurrently
(expecting 6 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected failure #1 (in thread B, only trace B alive).
Google Test trace:
googletest-output-test_.cc:#: Trace B
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #2 (in thread A, trace A & B both alive).
Google Test trace:
googletest-output-test_.cc:#: Trace A
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #3 (in thread B, trace A & B both alive).
Google Test trace:
googletest-output-test_.cc:#: Trace B
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #4 (in thread B, only trace A alive).
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #5 (in thread A, only trace A alive).
Google Test trace:
googletest-output-test_.cc:#: Trace A
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #6 (in thread A, no trace alive).
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksConcurrently
\e[0;32m[----------] \e[m1 test from ScopedTraceTest
\e[0;32m[ RUN      ] \e[mScopedTraceTest.WithExplicitFileAndLine
googletest-output-test_.cc:#: Failure
Failed
Check that the trace is attached to a particular location.
Google Test trace:
explicit_file.cc:123: expected trace message
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mScopedTraceTest.WithExplicitFileAndLine
\e[0;32m[----------] \e[m1 test from NonFatalFailureInFixtureConstructorTest
\e[0;32m[ RUN      ] \e[mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
(expecting 5 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected failure #1, in the test fixture c'tor.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #2, in SetUp().
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #3, in the test body.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #4, in TearDown.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #5, in the test fixture d'tor.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
\e[0;32m[----------] \e[m1 test from FatalFailureInFixtureConstructorTest
\e[0;32m[ RUN      ] \e[mFatalFailureInFixtureConstructorTest.FailureInConstructor
(expecting 2 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected failure #1, in the test fixture c'tor.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #2, in the test fixture d'tor.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mFatalFailureInFixtureConstructorTest.FailureInConstructor
\e[0;32m[----------] \e[m1 test from NonFatalFailureInSetUpTest
\e[0;32m[ RUN      ] \e[mNonFatalFailureInSetUpTest.FailureInSetUp
(expecting 4 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected failure #1, in SetUp().
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #2, in the test function.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #3, in TearDown().
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #4, in the test fixture d'tor.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mNonFatalFailureInSetUpTest.FailureInSetUp
\e[0;32m[----------] \e[m1 test from FatalFailureInSetUpTest
\e[0;32m[ RUN      ] \e[mFatalFailureInSetUpTest.FailureInSetUp
(expecting 3 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected failure #1, in SetUp().
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #2, in TearDown().
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected failure #3, in the test fixture d'tor.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mFatalFailureInSetUpTest.FailureInSetUp
\e[0;32m[----------] \e[m1 test from AddFailureAtTest
\e[0;32m[ RUN      ] \e[mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
foo.cc:42: Failure
Failed
Expected nonfatal failure in foo.cc
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
\e[0;32m[----------] \e[m1 test from GtestFailAtTest
\e[0;32m[ RUN      ] \e[mGtestFailAtTest.MessageContainsSpecifiedFileAndLineNumber
foo.cc:42: Failure
Failed
Expected fatal failure in foo.cc
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mGtestFailAtTest.MessageContainsSpecifiedFileAndLineNumber
\e[0;32m[----------] \e[m4 tests from MixedUpTestSuiteTest
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteTest.FirstTestFromNamespaceFoo
\e[0;32m[       OK ] \e[mMixedUpTestSuiteTest.FirstTestFromNamespaceFoo
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteTest.SecondTestFromNamespaceFoo
\e[0;32m[       OK ] \e[mMixedUpTestSuiteTest.SecondTestFromNamespaceFoo
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteTest.ThisShouldFail
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class.  However, in test suite MixedUpTestSuiteTest,
you defined test FirstTestFromNamespaceFoo and test ThisShouldFail
using two different test fixture classes.  This can happen if
the two classes are from different namespaces or translation
units and have the same name.  You should probably rename one
of the classes to put the tests into different test suites.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteTest.ThisShouldFail
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteTest.ThisShouldFailToo
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class.  However, in test suite MixedUpTestSuiteTest,
you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo
using two different test fixture classes.  This can happen if
the two classes are from different namespaces or translation
units and have the same name.  You should probably rename one
of the classes to put the tests into different test suites.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteTest.ThisShouldFailToo
\e[0;32m[----------] \e[m2 tests from MixedUpTestSuiteWithSameTestNameTest
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
\e[0;32m[       OK ] \e[mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
\e[0;32m[ RUN      ] \e[mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class.  However, in test suite MixedUpTestSuiteWithSameTestNameTest,
you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail
using two different test fixture classes.  This can happen if
the two classes are from different namespaces or translation
units and have the same name.  You should probably rename one
of the classes to put the tests into different test suites.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
\e[0;32m[----------] \e[m2 tests from TEST_F_before_TEST_in_same_test_case
\e[0;32m[ RUN      ] \e[mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
\e[0;32m[       OK ] \e[mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F
\e[0;32m[ RUN      ] \e[mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class, so mixing TEST_F and TEST in the same test suite is
illegal.  In test suite TEST_F_before_TEST_in_same_test_case,
test DefinedUsingTEST_F is defined using TEST_F but
test DefinedUsingTESTAndShouldFail is defined using TEST.  You probably
want to change the TEST to TEST_F or move it to another test
case.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
\e[0;32m[----------] \e[m2 tests from TEST_before_TEST_F_in_same_test_case
\e[0;32m[ RUN      ] \e[mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
\e[0;32m[       OK ] \e[mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST
\e[0;32m[ RUN      ] \e[mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class, so mixing TEST_F and TEST in the same test suite is
illegal.  In test suite TEST_before_TEST_F_in_same_test_case,
test DefinedUsingTEST_FAndShouldFail is defined using TEST_F but
test DefinedUsingTEST is defined using TEST.  You probably
want to change the TEST to TEST_F or move it to another test
case.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
\e[0;32m[----------] \e[m8 tests from ExpectNonfatalFailureTest
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.CanReferenceGlobalVariables
\e[0;32m[       OK ] \e[mExpectNonfatalFailureTest.CanReferenceGlobalVariables
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.CanReferenceLocalVariables
\e[0;32m[       OK ] \e[mExpectNonfatalFailureTest.CanReferenceLocalVariables
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
\e[0;32m[       OK ] \e[mExpectNonfatalFailureTest.SucceedsWhenThereIsOneNonfatalFailure
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual: 2 failures
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure 1.
Stack trace: (omitted)


googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure 2.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual:
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.FailsWhenStatementReturns
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenStatementReturns
\e[0;32m[ RUN      ] \e[mExpectNonfatalFailureTest.FailsWhenStatementThrows
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenStatementThrows
\e[0;32m[----------] \e[m8 tests from ExpectFatalFailureTest
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.CanReferenceGlobalVariables
\e[0;32m[       OK ] \e[mExpectFatalFailureTest.CanReferenceGlobalVariables
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.CanReferenceLocalStaticVariables
\e[0;32m[       OK ] \e[mExpectFatalFailureTest.CanReferenceLocalStaticVariables
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
\e[0;32m[       OK ] \e[mExpectFatalFailureTest.SucceedsWhenThereIsOneFatalFailure
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual: 2 failures
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual:
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.FailsWhenStatementReturns
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenStatementReturns
\e[0;32m[ RUN      ] \e[mExpectFatalFailureTest.FailsWhenStatementThrows
(expecting a failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenStatementThrows
\e[0;32m[----------] \e[m2 tests from TypedTest/0, where TypeParam = int
\e[0;32m[ RUN      ] \e[mTypedTest/0.Success
\e[0;32m[       OK ] \e[mTypedTest/0.Success
\e[0;32m[ RUN      ] \e[mTypedTest/0.Failure
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  TypeParam()
    Which is: 0
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mTypedTest/0.Failure, where TypeParam = int
\e[0;32m[----------] \e[m2 tests from TypedTestWithNames/char0, where TypeParam = char
\e[0;32m[ RUN      ] \e[mTypedTestWithNames/char0.Success
\e[0;32m[       OK ] \e[mTypedTestWithNames/char0.Success
\e[0;32m[ RUN      ] \e[mTypedTestWithNames/char0.Failure
googletest-output-test_.cc:#: Failure
Failed
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mTypedTestWithNames/char0.Failure, where TypeParam = char
\e[0;32m[----------] \e[m2 tests from TypedTestWithNames/int1, where TypeParam = int
\e[0;32m[ RUN      ] \e[mTypedTestWithNames/int1.Success
\e[0;32m[       OK ] \e[mTypedTestWithNames/int1.Success
\e[0;32m[ RUN      ] \e[mTypedTestWithNames/int1.Failure
googletest-output-test_.cc:#: Failure
Failed
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mTypedTestWithNames/int1.Failure, where TypeParam = int
\e[0;32m[----------] \e[m2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
\e[0;32m[ RUN      ] \e[mUnsigned/TypedTestP/0.Success
\e[0;32m[       OK ] \e[mUnsigned/TypedTestP/0.Success
\e[0;32m[ RUN      ] \e[mUnsigned/TypedTestP/0.Failure
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1U
    Which is: 1
  TypeParam()
    Which is: '\0'
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
\e[0;32m[----------] \e[m2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
\e[0;32m[ RUN      ] \e[mUnsigned/TypedTestP/1.Success
\e[0;32m[       OK ] \e[mUnsigned/TypedTestP/1.Success
\e[0;32m[ RUN      ] \e[mUnsigned/TypedTestP/1.Failure
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1U
    Which is: 1
  TypeParam()
    Which is: 0
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
\e[0;32m[----------] \e[m2 tests from UnsignedCustomName/TypedTestP/unsignedChar0, where TypeParam = unsigned char
\e[0;32m[ RUN      ] \e[mUnsignedCustomName/TypedTestP/unsignedChar0.Success
\e[0;32m[       OK ] \e[mUnsignedCustomName/TypedTestP/unsignedChar0.Success
\e[0;32m[ RUN      ] \e[mUnsignedCustomName/TypedTestP/unsignedChar0.Failure
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1U
    Which is: 1
  TypeParam()
    Which is: '\0'
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mUnsignedCustomName/TypedTestP/unsignedChar0.Failure, where TypeParam = unsigned char
\e[0;32m[----------] \e[m2 tests from UnsignedCustomName/TypedTestP/unsignedInt1, where TypeParam = unsigned int
\e[0;32m[ RUN      ] \e[mUnsignedCustomName/TypedTestP/unsignedInt1.Success
\e[0;32m[       OK ] \e[mUnsignedCustomName/TypedTestP/unsignedInt1.Success
\e[0;32m[ RUN      ] \e[mUnsignedCustomName/TypedTestP/unsignedInt1.Failure
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1U
    Which is: 1
  TypeParam()
    Which is: 0
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mUnsignedCustomName/TypedTestP/unsignedInt1.Failure, where TypeParam = unsigned int
\e[0;32m[----------] \e[m4 tests from ExpectFailureTest
\e[0;32m[ RUN      ] \e[mExpectFailureTest.ExpectFatalFailure
(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual:
googletest-output-test_.cc:#: Success:
Succeeded
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual:
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure containing "Some other fatal failure expected."
  Actual:
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectFatalFailure
\e[0;32m[ RUN      ] \e[mExpectFailureTest.ExpectNonFatalFailure
(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual:
googletest-output-test_.cc:#: Success:
Succeeded
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual:
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure containing "Some other non-fatal failure."
  Actual:
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectNonFatalFailure
\e[0;32m[ RUN      ] \e[mExpectFailureTest.ExpectFatalFailureOnAllThreads
(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual:
googletest-output-test_.cc:#: Success:
Succeeded
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual:
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 fatal failure containing "Some other fatal failure expected."
  Actual:
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectFatalFailureOnAllThreads
\e[0;32m[ RUN      ] \e[mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual:
googletest-output-test_.cc:#: Success:
Succeeded
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual:
googletest-output-test_.cc:#: Fatal failure:
Failed
Expected fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

(expecting 1 failure)
gtest.cc:#: Failure
Expected: 1 non-fatal failure containing "Some other non-fatal failure."
  Actual:
googletest-output-test_.cc:#: Non-fatal failure:
Failed
Expected non-fatal failure.
Stack trace: (omitted)


Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
\e[0;32m[----------] \e[m2 tests from ExpectFailureWithThreadsTest
\e[0;32m[ RUN      ] \e[mExpectFailureWithThreadsTest.ExpectFatalFailure
(expecting 2 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected fatal failure.
Stack trace: (omitted)

gtest.cc:#: Failure
Expected: 1 fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureWithThreadsTest.ExpectFatalFailure
\e[0;32m[ RUN      ] \e[mExpectFailureWithThreadsTest.ExpectNonFatalFailure
(expecting 2 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected non-fatal failure.
Stack trace: (omitted)

gtest.cc:#: Failure
Expected: 1 non-fatal failure
  Actual: 0 failures
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mExpectFailureWithThreadsTest.ExpectNonFatalFailure
\e[0;32m[----------] \e[m1 test from ScopedFakeTestPartResultReporterTest
\e[0;32m[ RUN      ] \e[mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
(expecting 2 failures)
googletest-output-test_.cc:#: Failure
Failed
Expected fatal failure.
Stack trace: (omitted)

googletest-output-test_.cc:#: Failure
Failed
Expected non-fatal failure.
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
\e[0;32m[----------] \e[m2 tests from DynamicFixture
DynamicFixture::SetUpTestSuite
\e[0;32m[ RUN      ] \e[mDynamicFixture.DynamicTestPass
DynamicFixture()
DynamicFixture::SetUp
DynamicFixture::TearDown
~DynamicFixture()
\e[0;32m[       OK ] \e[mDynamicFixture.DynamicTestPass
\e[0;32m[ RUN      ] \e[mDynamicFixture.DynamicTestFail
DynamicFixture()
DynamicFixture::SetUp
googletest-output-test_.cc:#: Failure
Value of: Pass
  Actual: false
Expected: true
Stack trace: (omitted)

DynamicFixture::TearDown
~DynamicFixture()
\e[0;31m[  FAILED  ] \e[mDynamicFixture.DynamicTestFail
DynamicFixture::TearDownTestSuite
\e[0;32m[----------] \e[m1 test from DynamicFixtureAnotherName
DynamicFixture::SetUpTestSuite
\e[0;32m[ RUN      ] \e[mDynamicFixtureAnotherName.DynamicTestPass
DynamicFixture()
DynamicFixture::SetUp
DynamicFixture::TearDown
~DynamicFixture()
\e[0;32m[       OK ] \e[mDynamicFixtureAnotherName.DynamicTestPass
DynamicFixture::TearDownTestSuite
\e[0;32m[----------] \e[m2 tests from BadDynamicFixture1
DynamicFixture::SetUpTestSuite
\e[0;32m[ RUN      ] \e[mBadDynamicFixture1.FixtureBase
DynamicFixture()
DynamicFixture::SetUp
DynamicFixture::TearDown
~DynamicFixture()
\e[0;32m[       OK ] \e[mBadDynamicFixture1.FixtureBase
\e[0;32m[ RUN      ] \e[mBadDynamicFixture1.TestBase
DynamicFixture()
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class, so mixing TEST_F and TEST in the same test suite is
illegal.  In test suite BadDynamicFixture1,
test FixtureBase is defined using TEST_F but
test TestBase is defined using TEST.  You probably
want to change the TEST to TEST_F or move it to another test
case.
Stack trace: (omitted)

~DynamicFixture()
\e[0;31m[  FAILED  ] \e[mBadDynamicFixture1.TestBase
DynamicFixture::TearDownTestSuite
\e[0;32m[----------] \e[m2 tests from BadDynamicFixture2
DynamicFixture::SetUpTestSuite
\e[0;32m[ RUN      ] \e[mBadDynamicFixture2.FixtureBase
DynamicFixture()
DynamicFixture::SetUp
DynamicFixture::TearDown
~DynamicFixture()
\e[0;32m[       OK ] \e[mBadDynamicFixture2.FixtureBase
\e[0;32m[ RUN      ] \e[mBadDynamicFixture2.Derived
DynamicFixture()
gtest.cc:#: Failure
Failed
All tests in the same test suite must use the same test fixture
class.  However, in test suite BadDynamicFixture2,
you defined test FixtureBase and test Derived
using two different test fixture classes.  This can happen if
the two classes are from different namespaces or translation
units and have the same name.  You should probably rename one
of the classes to put the tests into different test suites.
Stack trace: (omitted)

~DynamicFixture()
\e[0;31m[  FAILED  ] \e[mBadDynamicFixture2.Derived
DynamicFixture::TearDownTestSuite
\e[0;32m[----------] \e[m1 test from PrintingFailingParams/FailingParamTest
\e[0;32m[ RUN      ] \e[mPrintingFailingParams/FailingParamTest.Fails/0
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  GetParam()
    Which is: 2
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
\e[0;32m[----------] \e[m1 test from EmptyBasenameParamInst
\e[0;32m[ RUN      ] \e[mEmptyBasenameParamInst.Passes/0
\e[0;32m[       OK ] \e[mEmptyBasenameParamInst.Passes/0
\e[0;32m[----------] \e[m2 tests from PrintingStrings/ParamTest
\e[0;32m[ RUN      ] \e[mPrintingStrings/ParamTest.Success/a
\e[0;32m[       OK ] \e[mPrintingStrings/ParamTest.Success/a
\e[0;32m[ RUN      ] \e[mPrintingStrings/ParamTest.Failure/a
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  "b"
  GetParam()
    Which is: "a"
Expected failure
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mPrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
\e[0;32m[----------] \e[m3 tests from GoogleTestVerification
\e[0;32m[ RUN      ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<NoTests>
googletest-output-test_.cc:#: Failure
Parameterized test suite NoTests is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are defined via TEST_P . No test cases will run.

Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from code that always depend on code that provides TEST_P. Failing to do so is often an indication of dead code, e.g. the last TEST_P was removed but the rest got left behind.

To suppress this error for this test suite, insert the following line (in a non-header) in the namespace it is defined in:

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NoTests);
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<NoTests>
\e[0;32m[ RUN      ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<DetectNotInstantiatedTest>
googletest-output-test_.cc:#: Failure
Parameterized test suite DetectNotInstantiatedTest is defined via TEST_P, but never instantiated. None of the test cases will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only ones provided expand to nothing.

Ideally, TEST_P definitions should only ever be included as part of binaries that intend to use them. (As opposed to, for example, being placed in a library that may be linked in to get other utilities.)

To suppress this error for this test suite, insert the following line (in a non-header) in the namespace it is defined in:

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DetectNotInstantiatedTest);
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<DetectNotInstantiatedTest>
\e[0;32m[ RUN      ] \e[mGoogleTestVerification.UninstantiatedTypeParameterizedTestSuite<DetectNotInstantiatedTypesTest>
googletest-output-test_.cc:#: Failure
Type parameterized test suite DetectNotInstantiatedTypesTest is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run.

Ideally, TYPED_TEST_P definitions should only ever be included as part of binaries that intend to use them. (As opposed to, for example, being placed in a library that may be linked in to get other utilities.)

To suppress this error for this test suite, insert the following line (in a non-header) in the namespace it is defined in:

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DetectNotInstantiatedTypesTest);
Stack trace: (omitted)

\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedTypeParameterizedTestSuite<DetectNotInstantiatedTypesTest>
\e[0;32m[----------] \e[mGlobal test environment tear-down
BarEnvironment::TearDown() called.
googletest-output-test_.cc:#: Failure
Failed
Expected non-fatal failure.
Stack trace: (omitted)

FooEnvironment::TearDown() called.
googletest-output-test_.cc:#: Failure
Failed
Expected fatal failure.
Stack trace: (omitted)

\e[0;32m[==========] \e[m88 tests from 41 test suites ran.
\e[0;32m[  PASSED  ] \e[m31 tests.
\e[0;31m[  FAILED  ] \e[m57 tests, listed below:
\e[0;31m[  FAILED  ] \e[mNonfatalFailureTest.EscapesStringOperands
\e[0;31m[  FAILED  ] \e[mNonfatalFailureTest.DiffForLongStrings
\e[0;31m[  FAILED  ] \e[mFatalFailureTest.FatalFailureInSubroutine
\e[0;31m[  FAILED  ] \e[mFatalFailureTest.FatalFailureInNestedSubroutine
\e[0;31m[  FAILED  ] \e[mFatalFailureTest.NonfatalFailureInSubroutine
\e[0;31m[  FAILED  ] \e[mLoggingTest.InterleavingLoggingAndAssertions
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.AcceptedValues
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.ObeysScopes
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksInLoop
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksInSubroutine
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.CanBeNested
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.CanBeRepeated
\e[0;31m[  FAILED  ] \e[mSCOPED_TRACETest.WorksConcurrently
\e[0;31m[  FAILED  ] \e[mScopedTraceTest.WithExplicitFileAndLine
\e[0;31m[  FAILED  ] \e[mNonFatalFailureInFixtureConstructorTest.FailureInConstructor
\e[0;31m[  FAILED  ] \e[mFatalFailureInFixtureConstructorTest.FailureInConstructor
\e[0;31m[  FAILED  ] \e[mNonFatalFailureInSetUpTest.FailureInSetUp
\e[0;31m[  FAILED  ] \e[mFatalFailureInSetUpTest.FailureInSetUp
\e[0;31m[  FAILED  ] \e[mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber
\e[0;31m[  FAILED  ] \e[mGtestFailAtTest.MessageContainsSpecifiedFileAndLineNumber
\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteTest.ThisShouldFail
\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteTest.ThisShouldFailToo
\e[0;31m[  FAILED  ] \e[mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail
\e[0;31m[  FAILED  ] \e[mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail
\e[0;31m[  FAILED  ] \e[mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail
\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure
\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereAreTwoNonfatalFailures
\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenThereIsOneFatalFailure
\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenStatementReturns
\e[0;31m[  FAILED  ] \e[mExpectNonfatalFailureTest.FailsWhenStatementThrows
\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereIsNoFatalFailure
\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereAreTwoFatalFailures
\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenThereIsOneNonfatalFailure
\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenStatementReturns
\e[0;31m[  FAILED  ] \e[mExpectFatalFailureTest.FailsWhenStatementThrows
\e[0;31m[  FAILED  ] \e[mTypedTest/0.Failure, where TypeParam = int
\e[0;31m[  FAILED  ] \e[mTypedTestWithNames/char0.Failure, where TypeParam = char
\e[0;31m[  FAILED  ] \e[mTypedTestWithNames/int1.Failure, where TypeParam = int
\e[0;31m[  FAILED  ] \e[mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
\e[0;31m[  FAILED  ] \e[mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
\e[0;31m[  FAILED  ] \e[mUnsignedCustomName/TypedTestP/unsignedChar0.Failure, where TypeParam = unsigned char
\e[0;31m[  FAILED  ] \e[mUnsignedCustomName/TypedTestP/unsignedInt1.Failure, where TypeParam = unsigned int
\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectFatalFailure
\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectNonFatalFailure
\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectFatalFailureOnAllThreads
\e[0;31m[  FAILED  ] \e[mExpectFailureTest.ExpectNonFatalFailureOnAllThreads
\e[0;31m[  FAILED  ] \e[mExpectFailureWithThreadsTest.ExpectFatalFailure
\e[0;31m[  FAILED  ] \e[mExpectFailureWithThreadsTest.ExpectNonFatalFailure
\e[0;31m[  FAILED  ] \e[mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread
\e[0;31m[  FAILED  ] \e[mDynamicFixture.DynamicTestFail
\e[0;31m[  FAILED  ] \e[mBadDynamicFixture1.TestBase
\e[0;31m[  FAILED  ] \e[mBadDynamicFixture2.Derived
\e[0;31m[  FAILED  ] \e[mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
\e[0;31m[  FAILED  ] \e[mPrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<NoTests>
\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedParameterizedTestSuite<DetectNotInstantiatedTest>
\e[0;31m[  FAILED  ] \e[mGoogleTestVerification.UninstantiatedTypeParameterizedTestSuite<DetectNotInstantiatedTypesTest>

57 FAILED TESTS
\e[0;33m  YOU HAVE 1 DISABLED TEST

\e[mNote: Google Test filter = FatalFailureTest.*:LoggingTest.*
[==========] Running 4 tests from 2 test suites.
[----------] Global test environment set-up.
[----------] 3 tests from FatalFailureTest
[ RUN      ] FatalFailureTest.FatalFailureInSubroutine
(expecting a failure that x should be 1)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  x
    Which is: 2
Stack trace: (omitted)

[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine (? ms)
[ RUN      ] FatalFailureTest.FatalFailureInNestedSubroutine
(expecting a failure that x should be 1)
googletest-output-test_.cc:#: Failure
Expected equality of these values:
  1
  x
    Which is: 2
Stack trace: (omitted)

[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
[ RUN      ] FatalFailureTest.NonfatalFailureInSubroutine
(expecting a failure on false)
googletest-output-test_.cc:#: Failure
Value of: false
  Actual: false
Expected: true
Stack trace: (omitted)

[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine (? ms)
[----------] 3 tests from FatalFailureTest (? ms total)

[----------] 1 test from LoggingTest
[ RUN      ] LoggingTest.InterleavingLoggingAndAssertions
(expecting 2 failures on (3) >= (a[i]))
i == 0
i == 1
googletest-output-test_.cc:#: Failure
Expected: (3) >= (a[i]), actual: 3 vs 9
Stack trace: (omitted)

i == 2
i == 3
googletest-output-test_.cc:#: Failure
Expected: (3) >= (a[i]), actual: 3 vs 6
Stack trace: (omitted)

[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions (? ms)
[----------] 1 test from LoggingTest (? ms total)

[----------] Global test environment tear-down
[==========] 4 tests from 2 test suites ran. (? ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 4 tests, listed below:
[  FAILED  ] FatalFailureTest.FatalFailureInSubroutine
[  FAILED  ] FatalFailureTest.FatalFailureInNestedSubroutine
[  FAILED  ] FatalFailureTest.NonfatalFailureInSubroutine
[  FAILED  ] LoggingTest.InterleavingLoggingAndAssertions

 4 FAILED TESTS
Note: Google Test filter = *DISABLED_*
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from DisabledTestsWarningTest
[ RUN      ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
[       OK ] DisabledTestsWarningTest.DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran.
[  PASSED  ] 1 test.
Note: Google Test filter = PassingTest.*
Note: This is test shard 2 of 2.
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from PassingTest
[ RUN      ] PassingTest.PassingTest2
[       OK ] PassingTest.PassingTest2
[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran.
[  PASSED  ] 1 test.