Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F67158047
googletest-output-test_.cc
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Thu, Jun 20, 09:19
Size
32 KB
Mime Type
text/x-c
Expires
Sat, Jun 22, 09:19 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
18344727
Attached To
R9484 sp4e-homework-lars-bertil
googletest-output-test_.cc
View Options
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The purpose of this file is to generate Google Test output under
// various conditions. The output will then be verified by
// googletest-output-test.py to ensure that Google Test generates the
// desired messages. Therefore, most tests in this file are MEANT TO
// FAIL.
//
// Author: wan@google.com (Zhanyong Wan)
#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"
#include "src/gtest-internal-inl.h"
#include <stdlib.h>
#if GTEST_IS_THREADSAFE
using
testing
::
ScopedFakeTestPartResultReporter
;
using
testing
::
TestPartResultArray
;
using
testing
::
internal
::
Notification
;
using
testing
::
internal
::
ThreadWithParam
;
#endif
namespace
posix
=
::
testing
::
internal
::
posix
;
// Tests catching fatal failures.
// A subroutine used by the following test.
void
TestEq1
(
int
x
)
{
ASSERT_EQ
(
1
,
x
);
}
// This function calls a test subroutine, catches the fatal failure it
// generates, and then returns early.
void
TryTestSubroutine
()
{
// Calls a subrountine that yields a fatal failure.
TestEq1
(
2
);
// Catches the fatal failure and aborts the test.
//
// The testing::Test:: prefix is necessary when calling
// HasFatalFailure() outside of a TEST, TEST_F, or test fixture.
if
(
testing
::
Test
::
HasFatalFailure
())
return
;
// If we get here, something is wrong.
FAIL
()
<<
"This should never be reached."
;
}
TEST
(
PassingTest
,
PassingTest1
)
{
}
TEST
(
PassingTest
,
PassingTest2
)
{
}
// Tests that parameters of failing parameterized tests are printed in the
// failing test summary.
class
FailingParamTest
:
public
testing
::
TestWithParam
<
int
>
{};
TEST_P
(
FailingParamTest
,
Fails
)
{
EXPECT_EQ
(
1
,
GetParam
());
}
// This generates a test which will fail. Google Test is expected to print
// its parameter when it outputs the list of all failed tests.
INSTANTIATE_TEST_CASE_P
(
PrintingFailingParams
,
FailingParamTest
,
testing
::
Values
(
2
));
static
const
char
kGoldenString
[]
=
"
\"
Line
\0
1
\"\n
Line 2"
;
TEST
(
NonfatalFailureTest
,
EscapesStringOperands
)
{
std
::
string
actual
=
"actual
\"
string
\"
"
;
EXPECT_EQ
(
kGoldenString
,
actual
);
const
char
*
golden
=
kGoldenString
;
EXPECT_EQ
(
golden
,
actual
);
}
TEST
(
NonfatalFailureTest
,
DiffForLongStrings
)
{
std
::
string
golden_str
(
kGoldenString
,
sizeof
(
kGoldenString
)
-
1
);
EXPECT_EQ
(
golden_str
,
"Line 2"
);
}
// Tests catching a fatal failure in a subroutine.
TEST
(
FatalFailureTest
,
FatalFailureInSubroutine
)
{
printf
(
"(expecting a failure that x should be 1)
\n
"
);
TryTestSubroutine
();
}
// Tests catching a fatal failure in a nested subroutine.
TEST
(
FatalFailureTest
,
FatalFailureInNestedSubroutine
)
{
printf
(
"(expecting a failure that x should be 1)
\n
"
);
// Calls a subrountine that yields a fatal failure.
TryTestSubroutine
();
// Catches the fatal failure and aborts the test.
//
// When calling HasFatalFailure() inside a TEST, TEST_F, or test
// fixture, the testing::Test:: prefix is not needed.
if
(
HasFatalFailure
())
return
;
// If we get here, something is wrong.
FAIL
()
<<
"This should never be reached."
;
}
// Tests HasFatalFailure() after a failed EXPECT check.
TEST
(
FatalFailureTest
,
NonfatalFailureInSubroutine
)
{
printf
(
"(expecting a failure on false)
\n
"
);
EXPECT_TRUE
(
false
);
// Generates a nonfatal failure
ASSERT_FALSE
(
HasFatalFailure
());
// This should succeed.
}
// Tests interleaving user logging and Google Test assertions.
TEST
(
LoggingTest
,
InterleavingLoggingAndAssertions
)
{
static
const
int
a
[
4
]
=
{
3
,
9
,
2
,
6
};
printf
(
"(expecting 2 failures on (3) >= (a[i]))
\n
"
);
for
(
int
i
=
0
;
i
<
static_cast
<
int
>
(
sizeof
(
a
)
/
sizeof
(
*
a
));
i
++
)
{
printf
(
"i == %d
\n
"
,
i
);
EXPECT_GE
(
3
,
a
[
i
]);
}
}
// Tests the SCOPED_TRACE macro.
// A helper function for testing SCOPED_TRACE.
void
SubWithoutTrace
(
int
n
)
{
EXPECT_EQ
(
1
,
n
);
ASSERT_EQ
(
2
,
n
);
}
// Another helper function for testing SCOPED_TRACE.
void
SubWithTrace
(
int
n
)
{
SCOPED_TRACE
(
testing
::
Message
()
<<
"n = "
<<
n
);
SubWithoutTrace
(
n
);
}
TEST
(
SCOPED_TRACETest
,
AcceptedValues
)
{
SCOPED_TRACE
(
"literal string"
);
SCOPED_TRACE
(
std
::
string
(
"std::string"
));
SCOPED_TRACE
(
1337
);
// streamable type
const
char
*
null_value
=
NULL
;
SCOPED_TRACE
(
null_value
);
ADD_FAILURE
()
<<
"Just checking that all these values work fine."
;
}
// Tests that SCOPED_TRACE() obeys lexical scopes.
TEST
(
SCOPED_TRACETest
,
ObeysScopes
)
{
printf
(
"(expected to fail)
\n
"
);
// There should be no trace before SCOPED_TRACE() is invoked.
ADD_FAILURE
()
<<
"This failure is expected, and shouldn't have a trace."
;
{
SCOPED_TRACE
(
"Expected trace"
);
// After SCOPED_TRACE(), a failure in the current scope should contain
// the trace.
ADD_FAILURE
()
<<
"This failure is expected, and should have a trace."
;
}
// Once the control leaves the scope of the SCOPED_TRACE(), there
// should be no trace again.
ADD_FAILURE
()
<<
"This failure is expected, and shouldn't have a trace."
;
}
// Tests that SCOPED_TRACE works inside a loop.
TEST
(
SCOPED_TRACETest
,
WorksInLoop
)
{
printf
(
"(expected to fail)
\n
"
);
for
(
int
i
=
1
;
i
<=
2
;
i
++
)
{
SCOPED_TRACE
(
testing
::
Message
()
<<
"i = "
<<
i
);
SubWithoutTrace
(
i
);
}
}
// Tests that SCOPED_TRACE works in a subroutine.
TEST
(
SCOPED_TRACETest
,
WorksInSubroutine
)
{
printf
(
"(expected to fail)
\n
"
);
SubWithTrace
(
1
);
SubWithTrace
(
2
);
}
// Tests that SCOPED_TRACE can be nested.
TEST
(
SCOPED_TRACETest
,
CanBeNested
)
{
printf
(
"(expected to fail)
\n
"
);
SCOPED_TRACE
(
""
);
// A trace without a message.
SubWithTrace
(
2
);
}
// Tests that multiple SCOPED_TRACEs can be used in the same scope.
TEST
(
SCOPED_TRACETest
,
CanBeRepeated
)
{
printf
(
"(expected to fail)
\n
"
);
SCOPED_TRACE
(
"A"
);
ADD_FAILURE
()
<<
"This failure is expected, and should contain trace point A."
;
SCOPED_TRACE
(
"B"
);
ADD_FAILURE
()
<<
"This failure is expected, and should contain trace point A and B."
;
{
SCOPED_TRACE
(
"C"
);
ADD_FAILURE
()
<<
"This failure is expected, and should "
<<
"contain trace point A, B, and C."
;
}
SCOPED_TRACE
(
"D"
);
ADD_FAILURE
()
<<
"This failure is expected, and should "
<<
"contain trace point A, B, and D."
;
}
#if GTEST_IS_THREADSAFE
// Tests that SCOPED_TRACE()s can be used concurrently from multiple
// threads. Namely, an assertion should be affected by
// SCOPED_TRACE()s in its own thread only.
// Here's the sequence of actions that happen in the test:
//
// Thread A (main) | Thread B (spawned)
// ===============================|================================
// spawns thread B |
// -------------------------------+--------------------------------
// waits for n1 | SCOPED_TRACE("Trace B");
// | generates failure #1
// | notifies n1
// -------------------------------+--------------------------------
// SCOPED_TRACE("Trace A"); | waits for n2
// generates failure #2 |
// notifies n2 |
// -------------------------------|--------------------------------
// waits for n3 | generates failure #3
// | trace B dies
// | generates failure #4
// | notifies n3
// -------------------------------|--------------------------------
// generates failure #5 | finishes
// trace A dies |
// generates failure #6 |
// -------------------------------|--------------------------------
// waits for thread B to finish |
struct
CheckPoints
{
Notification
n1
;
Notification
n2
;
Notification
n3
;
};
static
void
ThreadWithScopedTrace
(
CheckPoints
*
check_points
)
{
{
SCOPED_TRACE
(
"Trace B"
);
ADD_FAILURE
()
<<
"Expected failure #1 (in thread B, only trace B alive)."
;
check_points
->
n1
.
Notify
();
check_points
->
n2
.
WaitForNotification
();
ADD_FAILURE
()
<<
"Expected failure #3 (in thread B, trace A & B both alive)."
;
}
// Trace B dies here.
ADD_FAILURE
()
<<
"Expected failure #4 (in thread B, only trace A alive)."
;
check_points
->
n3
.
Notify
();
}
TEST
(
SCOPED_TRACETest
,
WorksConcurrently
)
{
printf
(
"(expecting 6 failures)
\n
"
);
CheckPoints
check_points
;
ThreadWithParam
<
CheckPoints
*>
thread
(
&
ThreadWithScopedTrace
,
&
check_points
,
NULL
);
check_points
.
n1
.
WaitForNotification
();
{
SCOPED_TRACE
(
"Trace A"
);
ADD_FAILURE
()
<<
"Expected failure #2 (in thread A, trace A & B both alive)."
;
check_points
.
n2
.
Notify
();
check_points
.
n3
.
WaitForNotification
();
ADD_FAILURE
()
<<
"Expected failure #5 (in thread A, only trace A alive)."
;
}
// Trace A dies here.
ADD_FAILURE
()
<<
"Expected failure #6 (in thread A, no trace alive)."
;
thread
.
Join
();
}
#endif
// GTEST_IS_THREADSAFE
// Tests basic functionality of the ScopedTrace utility (most of its features
// are already tested in SCOPED_TRACETest).
TEST
(
ScopedTraceTest
,
WithExplicitFileAndLine
)
{
testing
::
ScopedTrace
trace
(
"explicit_file.cc"
,
123
,
"expected trace message"
);
ADD_FAILURE
()
<<
"Check that the trace is attached to a particular location."
;
}
TEST
(
DisabledTestsWarningTest
,
DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning
)
{
// This test body is intentionally empty. Its sole purpose is for
// verifying that the --gtest_also_run_disabled_tests flag
// suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of
// the test output.
}
// Tests using assertions outside of TEST and TEST_F.
//
// This function creates two failures intentionally.
void
AdHocTest
()
{
printf
(
"The non-test part of the code is expected to have 2 failures.
\n\n
"
);
EXPECT_TRUE
(
false
);
EXPECT_EQ
(
2
,
3
);
}
// Runs all TESTs, all TEST_Fs, and the ad hoc test.
int
RunAllTests
()
{
AdHocTest
();
return
RUN_ALL_TESTS
();
}
// Tests non-fatal failures in the fixture constructor.
class
NonFatalFailureInFixtureConstructorTest
:
public
testing
::
Test
{
protected
:
NonFatalFailureInFixtureConstructorTest
()
{
printf
(
"(expecting 5 failures)
\n
"
);
ADD_FAILURE
()
<<
"Expected failure #1, in the test fixture c'tor."
;
}
~
NonFatalFailureInFixtureConstructorTest
()
{
ADD_FAILURE
()
<<
"Expected failure #5, in the test fixture d'tor."
;
}
virtual
void
SetUp
()
{
ADD_FAILURE
()
<<
"Expected failure #2, in SetUp()."
;
}
virtual
void
TearDown
()
{
ADD_FAILURE
()
<<
"Expected failure #4, in TearDown."
;
}
};
TEST_F
(
NonFatalFailureInFixtureConstructorTest
,
FailureInConstructor
)
{
ADD_FAILURE
()
<<
"Expected failure #3, in the test body."
;
}
// Tests fatal failures in the fixture constructor.
class
FatalFailureInFixtureConstructorTest
:
public
testing
::
Test
{
protected
:
FatalFailureInFixtureConstructorTest
()
{
printf
(
"(expecting 2 failures)
\n
"
);
Init
();
}
~
FatalFailureInFixtureConstructorTest
()
{
ADD_FAILURE
()
<<
"Expected failure #2, in the test fixture d'tor."
;
}
virtual
void
SetUp
()
{
ADD_FAILURE
()
<<
"UNEXPECTED failure in SetUp(). "
<<
"We should never get here, as the test fixture c'tor "
<<
"had a fatal failure."
;
}
virtual
void
TearDown
()
{
ADD_FAILURE
()
<<
"UNEXPECTED failure in TearDown(). "
<<
"We should never get here, as the test fixture c'tor "
<<
"had a fatal failure."
;
}
private
:
void
Init
()
{
FAIL
()
<<
"Expected failure #1, in the test fixture c'tor."
;
}
};
TEST_F
(
FatalFailureInFixtureConstructorTest
,
FailureInConstructor
)
{
ADD_FAILURE
()
<<
"UNEXPECTED failure in the test body. "
<<
"We should never get here, as the test fixture c'tor "
<<
"had a fatal failure."
;
}
// Tests non-fatal failures in SetUp().
class
NonFatalFailureInSetUpTest
:
public
testing
::
Test
{
protected
:
virtual
~
NonFatalFailureInSetUpTest
()
{
Deinit
();
}
virtual
void
SetUp
()
{
printf
(
"(expecting 4 failures)
\n
"
);
ADD_FAILURE
()
<<
"Expected failure #1, in SetUp()."
;
}
virtual
void
TearDown
()
{
FAIL
()
<<
"Expected failure #3, in TearDown()."
;
}
private
:
void
Deinit
()
{
FAIL
()
<<
"Expected failure #4, in the test fixture d'tor."
;
}
};
TEST_F
(
NonFatalFailureInSetUpTest
,
FailureInSetUp
)
{
FAIL
()
<<
"Expected failure #2, in the test function."
;
}
// Tests fatal failures in SetUp().
class
FatalFailureInSetUpTest
:
public
testing
::
Test
{
protected
:
virtual
~
FatalFailureInSetUpTest
()
{
Deinit
();
}
virtual
void
SetUp
()
{
printf
(
"(expecting 3 failures)
\n
"
);
FAIL
()
<<
"Expected failure #1, in SetUp()."
;
}
virtual
void
TearDown
()
{
FAIL
()
<<
"Expected failure #2, in TearDown()."
;
}
private
:
void
Deinit
()
{
FAIL
()
<<
"Expected failure #3, in the test fixture d'tor."
;
}
};
TEST_F
(
FatalFailureInSetUpTest
,
FailureInSetUp
)
{
FAIL
()
<<
"UNEXPECTED failure in the test function. "
<<
"We should never get here, as SetUp() failed."
;
}
TEST
(
AddFailureAtTest
,
MessageContainsSpecifiedFileAndLineNumber
)
{
ADD_FAILURE_AT
(
"foo.cc"
,
42
)
<<
"Expected failure in foo.cc"
;
}
#if GTEST_IS_THREADSAFE
// A unary function that may die.
void
DieIf
(
bool
should_die
)
{
GTEST_CHECK_
(
!
should_die
)
<<
" - death inside DieIf()."
;
}
// Tests running death tests in a multi-threaded context.
// Used for coordination between the main and the spawn thread.
struct
SpawnThreadNotifications
{
SpawnThreadNotifications
()
{}
Notification
spawn_thread_started
;
Notification
spawn_thread_ok_to_terminate
;
private
:
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
SpawnThreadNotifications
);
};
// The function to be executed in the thread spawn by the
// MultipleThreads test (below).
static
void
ThreadRoutine
(
SpawnThreadNotifications
*
notifications
)
{
// Signals the main thread that this thread has started.
notifications
->
spawn_thread_started
.
Notify
();
// Waits for permission to finish from the main thread.
notifications
->
spawn_thread_ok_to_terminate
.
WaitForNotification
();
}
// This is a death-test test, but it's not named with a DeathTest
// suffix. It starts threads which might interfere with later
// death tests, so it must run after all other death tests.
class
DeathTestAndMultiThreadsTest
:
public
testing
::
Test
{
protected
:
// Starts a thread and waits for it to begin.
virtual
void
SetUp
()
{
thread_
.
reset
(
new
ThreadWithParam
<
SpawnThreadNotifications
*>
(
&
ThreadRoutine
,
&
notifications_
,
NULL
));
notifications_
.
spawn_thread_started
.
WaitForNotification
();
}
// Tells the thread to finish, and reaps it.
// Depending on the version of the thread library in use,
// a manager thread might still be left running that will interfere
// with later death tests. This is unfortunate, but this class
// cleans up after itself as best it can.
virtual
void
TearDown
()
{
notifications_
.
spawn_thread_ok_to_terminate
.
Notify
();
}
private
:
SpawnThreadNotifications
notifications_
;
testing
::
internal
::
scoped_ptr
<
ThreadWithParam
<
SpawnThreadNotifications
*>
>
thread_
;
};
#endif
// GTEST_IS_THREADSAFE
// The MixedUpTestCaseTest test case verifies that Google Test will fail a
// test if it uses a different fixture class than what other tests in
// the same test case use. It deliberately contains two fixture
// classes with the same name but defined in different namespaces.
// The MixedUpTestCaseWithSameTestNameTest test case verifies that
// when the user defines two tests with the same test case name AND
// same test name (but in different namespaces), the second test will
// fail.
namespace
foo
{
class
MixedUpTestCaseTest
:
public
testing
::
Test
{
};
TEST_F
(
MixedUpTestCaseTest
,
FirstTestFromNamespaceFoo
)
{}
TEST_F
(
MixedUpTestCaseTest
,
SecondTestFromNamespaceFoo
)
{}
class
MixedUpTestCaseWithSameTestNameTest
:
public
testing
::
Test
{
};
TEST_F
(
MixedUpTestCaseWithSameTestNameTest
,
TheSecondTestWithThisNameShouldFail
)
{}
}
// namespace foo
namespace
bar
{
class
MixedUpTestCaseTest
:
public
testing
::
Test
{
};
// The following two tests are expected to fail. We rely on the
// golden file to check that Google Test generates the right error message.
TEST_F
(
MixedUpTestCaseTest
,
ThisShouldFail
)
{}
TEST_F
(
MixedUpTestCaseTest
,
ThisShouldFailToo
)
{}
class
MixedUpTestCaseWithSameTestNameTest
:
public
testing
::
Test
{
};
// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.
TEST_F
(
MixedUpTestCaseWithSameTestNameTest
,
TheSecondTestWithThisNameShouldFail
)
{}
}
// namespace bar
// The following two test cases verify that Google Test catches the user
// error of mixing TEST and TEST_F in the same test case. The first
// test case checks the scenario where TEST_F appears before TEST, and
// the second one checks where TEST appears before TEST_F.
class
TEST_F_before_TEST_in_same_test_case
:
public
testing
::
Test
{
};
TEST_F
(
TEST_F_before_TEST_in_same_test_case
,
DefinedUsingTEST_F
)
{}
// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.
TEST
(
TEST_F_before_TEST_in_same_test_case
,
DefinedUsingTESTAndShouldFail
)
{}
class
TEST_before_TEST_F_in_same_test_case
:
public
testing
::
Test
{
};
TEST
(
TEST_before_TEST_F_in_same_test_case
,
DefinedUsingTEST
)
{}
// Expected to fail. We rely on the golden file to check that Google Test
// generates the right error message.
TEST_F
(
TEST_before_TEST_F_in_same_test_case
,
DefinedUsingTEST_FAndShouldFail
)
{
}
// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE().
int
global_integer
=
0
;
// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables.
TEST
(
ExpectNonfatalFailureTest
,
CanReferenceGlobalVariables
)
{
global_integer
=
0
;
EXPECT_NONFATAL_FAILURE
({
EXPECT_EQ
(
1
,
global_integer
)
<<
"Expected non-fatal failure."
;
},
"Expected non-fatal failure."
);
}
// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables
// (static or not).
TEST
(
ExpectNonfatalFailureTest
,
CanReferenceLocalVariables
)
{
int
m
=
0
;
static
int
n
;
n
=
1
;
EXPECT_NONFATAL_FAILURE
({
EXPECT_EQ
(
m
,
n
)
<<
"Expected non-fatal failure."
;
},
"Expected non-fatal failure."
);
}
// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly
// one non-fatal failure and no fatal failure.
TEST
(
ExpectNonfatalFailureTest
,
SucceedsWhenThereIsOneNonfatalFailure
)
{
EXPECT_NONFATAL_FAILURE
({
ADD_FAILURE
()
<<
"Expected non-fatal failure."
;
},
"Expected non-fatal failure."
);
}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no
// non-fatal failure.
TEST
(
ExpectNonfatalFailureTest
,
FailsWhenThereIsNoNonfatalFailure
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
({
},
""
);
}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two
// non-fatal failures.
TEST
(
ExpectNonfatalFailureTest
,
FailsWhenThereAreTwoNonfatalFailures
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
({
ADD_FAILURE
()
<<
"Expected non-fatal failure 1."
;
ADD_FAILURE
()
<<
"Expected non-fatal failure 2."
;
},
""
);
}
// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal
// failure.
TEST
(
ExpectNonfatalFailureTest
,
FailsWhenThereIsOneFatalFailure
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
({
FAIL
()
<<
"Expected fatal failure."
;
},
""
);
}
// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
// tested returns.
TEST
(
ExpectNonfatalFailureTest
,
FailsWhenStatementReturns
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
({
return
;
},
""
);
}
#if GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being
// tested throws.
TEST
(
ExpectNonfatalFailureTest
,
FailsWhenStatementThrows
)
{
printf
(
"(expecting a failure)
\n
"
);
try
{
EXPECT_NONFATAL_FAILURE
({
throw
0
;
},
""
);
}
catch
(
int
)
{
// NOLINT
}
}
#endif
// GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_FATAL_FAILURE() can reference global variables.
TEST
(
ExpectFatalFailureTest
,
CanReferenceGlobalVariables
)
{
global_integer
=
0
;
EXPECT_FATAL_FAILURE
({
ASSERT_EQ
(
1
,
global_integer
)
<<
"Expected fatal failure."
;
},
"Expected fatal failure."
);
}
// Tests that EXPECT_FATAL_FAILURE() can reference local static
// variables.
TEST
(
ExpectFatalFailureTest
,
CanReferenceLocalStaticVariables
)
{
static
int
n
;
n
=
1
;
EXPECT_FATAL_FAILURE
({
ASSERT_EQ
(
0
,
n
)
<<
"Expected fatal failure."
;
},
"Expected fatal failure."
);
}
// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly
// one fatal failure and no non-fatal failure.
TEST
(
ExpectFatalFailureTest
,
SucceedsWhenThereIsOneFatalFailure
)
{
EXPECT_FATAL_FAILURE
({
FAIL
()
<<
"Expected fatal failure."
;
},
"Expected fatal failure."
);
}
// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal
// failure.
TEST
(
ExpectFatalFailureTest
,
FailsWhenThereIsNoFatalFailure
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_FATAL_FAILURE
({
},
""
);
}
// A helper for generating a fatal failure.
void
FatalFailure
()
{
FAIL
()
<<
"Expected fatal failure."
;
}
// Tests that EXPECT_FATAL_FAILURE() fails when there are two
// fatal failures.
TEST
(
ExpectFatalFailureTest
,
FailsWhenThereAreTwoFatalFailures
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_FATAL_FAILURE
({
FatalFailure
();
FatalFailure
();
},
""
);
}
// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal
// failure.
TEST
(
ExpectFatalFailureTest
,
FailsWhenThereIsOneNonfatalFailure
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_FATAL_FAILURE
({
ADD_FAILURE
()
<<
"Expected non-fatal failure."
;
},
""
);
}
// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
// tested returns.
TEST
(
ExpectFatalFailureTest
,
FailsWhenStatementReturns
)
{
printf
(
"(expecting a failure)
\n
"
);
EXPECT_FATAL_FAILURE
({
return
;
},
""
);
}
#if GTEST_HAS_EXCEPTIONS
// Tests that EXPECT_FATAL_FAILURE() fails when the statement being
// tested throws.
TEST
(
ExpectFatalFailureTest
,
FailsWhenStatementThrows
)
{
printf
(
"(expecting a failure)
\n
"
);
try
{
EXPECT_FATAL_FAILURE
({
throw
0
;
},
""
);
}
catch
(
int
)
{
// NOLINT
}
}
#endif
// GTEST_HAS_EXCEPTIONS
// This #ifdef block tests the output of value-parameterized tests.
std
::
string
ParamNameFunc
(
const
testing
::
TestParamInfo
<
std
::
string
>&
info
)
{
return
info
.
param
;
}
class
ParamTest
:
public
testing
::
TestWithParam
<
std
::
string
>
{
};
TEST_P
(
ParamTest
,
Success
)
{
EXPECT_EQ
(
"a"
,
GetParam
());
}
TEST_P
(
ParamTest
,
Failure
)
{
EXPECT_EQ
(
"b"
,
GetParam
())
<<
"Expected failure"
;
}
INSTANTIATE_TEST_CASE_P
(
PrintingStrings
,
ParamTest
,
testing
::
Values
(
std
::
string
(
"a"
)),
ParamNameFunc
);
// This #ifdef block tests the output of typed tests.
#if GTEST_HAS_TYPED_TEST
template
<
typename
T
>
class
TypedTest
:
public
testing
::
Test
{
};
TYPED_TEST_CASE
(
TypedTest
,
testing
::
Types
<
int
>
);
TYPED_TEST
(
TypedTest
,
Success
)
{
EXPECT_EQ
(
0
,
TypeParam
());
}
TYPED_TEST
(
TypedTest
,
Failure
)
{
EXPECT_EQ
(
1
,
TypeParam
())
<<
"Expected failure"
;
}
#endif
// GTEST_HAS_TYPED_TEST
// This #ifdef block tests the output of type-parameterized tests.
#if GTEST_HAS_TYPED_TEST_P
template
<
typename
T
>
class
TypedTestP
:
public
testing
::
Test
{
};
TYPED_TEST_CASE_P
(
TypedTestP
);
TYPED_TEST_P
(
TypedTestP
,
Success
)
{
EXPECT_EQ
(
0U
,
TypeParam
());
}
TYPED_TEST_P
(
TypedTestP
,
Failure
)
{
EXPECT_EQ
(
1U
,
TypeParam
())
<<
"Expected failure"
;
}
REGISTER_TYPED_TEST_CASE_P
(
TypedTestP
,
Success
,
Failure
);
typedef
testing
::
Types
<
unsigned
char
,
unsigned
int
>
UnsignedTypes
;
INSTANTIATE_TYPED_TEST_CASE_P
(
Unsigned
,
TypedTestP
,
UnsignedTypes
);
#endif
// GTEST_HAS_TYPED_TEST_P
#if GTEST_HAS_DEATH_TEST
// We rely on the golden file to verify that tests whose test case
// name ends with DeathTest are run first.
TEST
(
ADeathTest
,
ShouldRunFirst
)
{
}
# if GTEST_HAS_TYPED_TEST
// We rely on the golden file to verify that typed tests whose test
// case name ends with DeathTest are run first.
template
<
typename
T
>
class
ATypedDeathTest
:
public
testing
::
Test
{
};
typedef
testing
::
Types
<
int
,
double
>
NumericTypes
;
TYPED_TEST_CASE
(
ATypedDeathTest
,
NumericTypes
);
TYPED_TEST
(
ATypedDeathTest
,
ShouldRunFirst
)
{
}
# endif
// GTEST_HAS_TYPED_TEST
# if GTEST_HAS_TYPED_TEST_P
// We rely on the golden file to verify that type-parameterized tests
// whose test case name ends with DeathTest are run first.
template
<
typename
T
>
class
ATypeParamDeathTest
:
public
testing
::
Test
{
};
TYPED_TEST_CASE_P
(
ATypeParamDeathTest
);
TYPED_TEST_P
(
ATypeParamDeathTest
,
ShouldRunFirst
)
{
}
REGISTER_TYPED_TEST_CASE_P
(
ATypeParamDeathTest
,
ShouldRunFirst
);
INSTANTIATE_TYPED_TEST_CASE_P
(
My
,
ATypeParamDeathTest
,
NumericTypes
);
# endif
// GTEST_HAS_TYPED_TEST_P
#endif
// GTEST_HAS_DEATH_TEST
// Tests various failure conditions of
// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}.
class
ExpectFailureTest
:
public
testing
::
Test
{
public
:
// Must be public and not protected due to a bug in g++ 3.4.2.
enum
FailureMode
{
FATAL_FAILURE
,
NONFATAL_FAILURE
};
static
void
AddFailure
(
FailureMode
failure
)
{
if
(
failure
==
FATAL_FAILURE
)
{
FAIL
()
<<
"Expected fatal failure."
;
}
else
{
ADD_FAILURE
()
<<
"Expected non-fatal failure."
;
}
}
};
TEST_F
(
ExpectFailureTest
,
ExpectFatalFailure
)
{
// Expected fatal failure, but succeeds.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE
(
SUCCEED
(),
"Expected fatal failure."
);
// Expected fatal failure, but got a non-fatal failure.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE
(
AddFailure
(
NONFATAL_FAILURE
),
"Expected non-fatal "
"failure."
);
// Wrong message.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE
(
AddFailure
(
FATAL_FAILURE
),
"Some other fatal failure "
"expected."
);
}
TEST_F
(
ExpectFailureTest
,
ExpectNonFatalFailure
)
{
// Expected non-fatal failure, but succeeds.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
(
SUCCEED
(),
"Expected non-fatal failure."
);
// Expected non-fatal failure, but got a fatal failure.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
(
AddFailure
(
FATAL_FAILURE
),
"Expected fatal failure."
);
// Wrong message.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE
(
AddFailure
(
NONFATAL_FAILURE
),
"Some other non-fatal "
"failure."
);
}
#if GTEST_IS_THREADSAFE
class
ExpectFailureWithThreadsTest
:
public
ExpectFailureTest
{
protected
:
static
void
AddFailureInOtherThread
(
FailureMode
failure
)
{
ThreadWithParam
<
FailureMode
>
thread
(
&
AddFailure
,
failure
,
NULL
);
thread
.
Join
();
}
};
TEST_F
(
ExpectFailureWithThreadsTest
,
ExpectFatalFailure
)
{
// We only intercept the current thread.
printf
(
"(expecting 2 failures)
\n
"
);
EXPECT_FATAL_FAILURE
(
AddFailureInOtherThread
(
FATAL_FAILURE
),
"Expected fatal failure."
);
}
TEST_F
(
ExpectFailureWithThreadsTest
,
ExpectNonFatalFailure
)
{
// We only intercept the current thread.
printf
(
"(expecting 2 failures)
\n
"
);
EXPECT_NONFATAL_FAILURE
(
AddFailureInOtherThread
(
NONFATAL_FAILURE
),
"Expected non-fatal failure."
);
}
typedef
ExpectFailureWithThreadsTest
ScopedFakeTestPartResultReporterTest
;
// Tests that the ScopedFakeTestPartResultReporter only catches failures from
// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD.
TEST_F
(
ScopedFakeTestPartResultReporterTest
,
InterceptOnlyCurrentThread
)
{
printf
(
"(expecting 2 failures)
\n
"
);
TestPartResultArray
results
;
{
ScopedFakeTestPartResultReporter
reporter
(
ScopedFakeTestPartResultReporter
::
INTERCEPT_ONLY_CURRENT_THREAD
,
&
results
);
AddFailureInOtherThread
(
FATAL_FAILURE
);
AddFailureInOtherThread
(
NONFATAL_FAILURE
);
}
// The two failures should not have been intercepted.
EXPECT_EQ
(
0
,
results
.
size
())
<<
"This shouldn't fail."
;
}
#endif
// GTEST_IS_THREADSAFE
TEST_F
(
ExpectFailureTest
,
ExpectFatalFailureOnAllThreads
)
{
// Expected fatal failure, but succeeds.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE_ON_ALL_THREADS
(
SUCCEED
(),
"Expected fatal failure."
);
// Expected fatal failure, but got a non-fatal failure.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE_ON_ALL_THREADS
(
AddFailure
(
NONFATAL_FAILURE
),
"Expected non-fatal failure."
);
// Wrong message.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_FATAL_FAILURE_ON_ALL_THREADS
(
AddFailure
(
FATAL_FAILURE
),
"Some other fatal failure expected."
);
}
TEST_F
(
ExpectFailureTest
,
ExpectNonFatalFailureOnAllThreads
)
{
// Expected non-fatal failure, but succeeds.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS
(
SUCCEED
(),
"Expected non-fatal "
"failure."
);
// Expected non-fatal failure, but got a fatal failure.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS
(
AddFailure
(
FATAL_FAILURE
),
"Expected fatal failure."
);
// Wrong message.
printf
(
"(expecting 1 failure)
\n
"
);
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS
(
AddFailure
(
NONFATAL_FAILURE
),
"Some other non-fatal failure."
);
}
// Two test environments for testing testing::AddGlobalTestEnvironment().
class
FooEnvironment
:
public
testing
::
Environment
{
public
:
virtual
void
SetUp
()
{
printf
(
"%s"
,
"FooEnvironment::SetUp() called.
\n
"
);
}
virtual
void
TearDown
()
{
printf
(
"%s"
,
"FooEnvironment::TearDown() called.
\n
"
);
FAIL
()
<<
"Expected fatal failure."
;
}
};
class
BarEnvironment
:
public
testing
::
Environment
{
public
:
virtual
void
SetUp
()
{
printf
(
"%s"
,
"BarEnvironment::SetUp() called.
\n
"
);
}
virtual
void
TearDown
()
{
printf
(
"%s"
,
"BarEnvironment::TearDown() called.
\n
"
);
ADD_FAILURE
()
<<
"Expected non-fatal failure."
;
}
};
// The main function.
//
// The idea is to use Google Test to run all the tests we have defined (some
// of them are intended to fail), and then compare the test results
// with the "golden" file.
int
main
(
int
argc
,
char
**
argv
)
{
testing
::
GTEST_FLAG
(
print_time
)
=
false
;
// We just run the tests, knowing some of them are intended to fail.
// We will use a separate Python script to compare the output of
// this program with the golden file.
// It's hard to test InitGoogleTest() directly, as it has many
// global side effects. The following line serves as a sanity test
// for it.
testing
::
InitGoogleTest
(
&
argc
,
argv
);
bool
internal_skip_environment_and_ad_hoc_tests
=
std
::
count
(
argv
,
argv
+
argc
,
std
::
string
(
"internal_skip_environment_and_ad_hoc_tests"
))
>
0
;
#if GTEST_HAS_DEATH_TEST
if
(
testing
::
internal
::
GTEST_FLAG
(
internal_run_death_test
)
!=
""
)
{
// Skip the usual output capturing if we're running as the child
// process of an threadsafe-style death test.
# if GTEST_OS_WINDOWS
posix
::
FReopen
(
"nul:"
,
"w"
,
stdout
);
# else
posix
::
FReopen
(
"/dev/null"
,
"w"
,
stdout
);
# endif
// GTEST_OS_WINDOWS
return
RUN_ALL_TESTS
();
}
#endif
// GTEST_HAS_DEATH_TEST
if
(
internal_skip_environment_and_ad_hoc_tests
)
return
RUN_ALL_TESTS
();
// Registers two global test environments.
// The golden file verifies that they are set up in the order they
// are registered, and torn down in the reverse order.
testing
::
AddGlobalTestEnvironment
(
new
FooEnvironment
);
testing
::
AddGlobalTestEnvironment
(
new
BarEnvironment
);
return
RunAllTests
();
}
Event Timeline
Log In to Comment