External/googletest
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adds exception assertions. By balaz.dan@gmail.com.

Browse Source
This commit is contained in:
shiqian 2008-09-12 20:57:22 +00:00
parent 0bbdb14f74
commit 36865d8d35
3 changed files with 268 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/gtest/gtest.h
View File

@ -928,6 +928,28 @@ class AssertHelper {
// Generates a success with a generic message.
#define SUCCEED() GTEST_SUCCESS("Succeeded")
// Macros for testing exceptions.
//
// * {ASSERT|EXPECT}_THROW(statement, expected_exception):
// Tests that the statement throws the expected exception.
// * {ASSERT|EXPECT}_NO_THROW(statement):
// Tests that the statement doesn't throw any exception.
// * {ASSERT|EXPECT}_ANY_THROW(statement):
// Tests that the statement throws an exception.
#define EXPECT_THROW(statement, expected_exception) \
GTEST_TEST_THROW(statement, expected_exception, GTEST_NONFATAL_FAILURE)
#define EXPECT_NO_THROW(statement) \
GTEST_TEST_NO_THROW(statement, GTEST_NONFATAL_FAILURE)
#define EXPECT_ANY_THROW(statement) \
GTEST_TEST_ANY_THROW(statement, GTEST_NONFATAL_FAILURE)
#define ASSERT_THROW(statement, expected_exception) \
GTEST_TEST_THROW(statement, expected_exception, GTEST_FATAL_FAILURE)
#define ASSERT_NO_THROW(statement) \
GTEST_TEST_NO_THROW(statement, GTEST_FATAL_FAILURE)
#define ASSERT_ANY_THROW(statement) \
GTEST_TEST_ANY_THROW(statement, GTEST_FATAL_FAILURE)
// Boolean assertions.
#define EXPECT_TRUE(condition) \
GTEST_TEST_BOOLEAN(condition, #condition, false, true, \

61
include/gtest/internal/gtest-internal.h
View File

@ -717,6 +717,67 @@ class TypeParameterizedTestCase<Fixture, Templates0, Types> {
#define GTEST_SUCCESS(message) \
GTEST_MESSAGE(message, ::testing::TPRT_SUCCESS)
#define GTEST_TEST_THROW(statement, expected_exception, fail) \
GTEST_AMBIGUOUS_ELSE_BLOCKER \
if (const char* gtest_msg = "") { \
bool gtest_caught_expected = false; \
try { \
statement; \
} \
catch (expected_exception const&) { \
gtest_caught_expected = true; \
} \
catch (...) { \
gtest_msg = "Expected: " #statement " throws an exception of type " \
#expected_exception ".\n Actual: it throws a different " \
"type."; \
goto GTEST_CONCAT_TOKEN(gtest_label_testthrow_, __LINE__); \
} \
if (!gtest_caught_expected) { \
gtest_msg = "Expected: " #statement " throws an exception of type " \
#expected_exception ".\n Actual: it throws nothing."; \
goto GTEST_CONCAT_TOKEN(gtest_label_testthrow_, __LINE__); \
} \
} else \
GTEST_CONCAT_TOKEN(gtest_label_testthrow_, __LINE__): \
fail(gtest_msg)
#define GTEST_TEST_NO_THROW(statement, fail) \
GTEST_AMBIGUOUS_ELSE_BLOCKER \
if (const char* gtest_msg = "") { \
try { \
statement; \
} \
catch (...) { \
gtest_msg = "Expected: " #statement " doesn't throw an exception.\n" \
" Actual: it throws."; \
goto GTEST_CONCAT_TOKEN(gtest_label_testnothrow_, __LINE__); \
} \
} else \
GTEST_CONCAT_TOKEN(gtest_label_testnothrow_, __LINE__): \
fail(gtest_msg)
#define GTEST_TEST_ANY_THROW(statement, fail) \
GTEST_AMBIGUOUS_ELSE_BLOCKER \
if (const char* gtest_msg = "") { \
bool gtest_caught_any = false; \
try { \
statement; \
} \
catch (...) { \
gtest_caught_any = true; \
} \
if (!gtest_caught_any) { \
gtest_msg = "Expected: " #statement " throws an exception.\n" \
" Actual: it doesn't."; \
goto GTEST_CONCAT_TOKEN(gtest_label_testanythrow_, __LINE__); \
} \
} else \
GTEST_CONCAT_TOKEN(gtest_label_testanythrow_, __LINE__): \
fail(gtest_msg)
#define GTEST_TEST_BOOLEAN(boolexpr, booltext, actual, expected, fail) \
GTEST_AMBIGUOUS_ELSE_BLOCKER \
if (boolexpr) \

185
test/gtest_unittest.cc
View File

@ -2314,6 +2314,56 @@ TEST_F(SingleEvaluationTest, OtherCases) {
EXPECT_EQ(3, b_);
}
#if GTEST_HAS_EXCEPTIONS
void ThrowAnInteger() {
throw 1;
}
// Tests that assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest, ExceptionTests) {
// successful EXPECT_THROW
EXPECT_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}, int);
EXPECT_EQ(1, a_);
// failed EXPECT_THROW, throws different
EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}, bool), "throws a different type");
EXPECT_EQ(2, a_);
// failed EXPECT_THROW, throws nothing
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
EXPECT_EQ(3, a_);
// successful EXPECT_NO_THROW
EXPECT_NO_THROW(a_++);
EXPECT_EQ(4, a_);
// failed EXPECT_NO_THROW
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}), "it throws");
EXPECT_EQ(5, a_);
// successful EXPECT_ANY_THROW
EXPECT_ANY_THROW({ // NOLINT
a_++;
ThrowAnInteger();
});
EXPECT_EQ(6, a_);
// failed EXPECT_ANY_THROW
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
EXPECT_EQ(7, a_);
}
#endif // GTEST_HAS_EXCEPTIONS
// Tests non-string assertions.
@ -2487,6 +2537,37 @@ TEST(AssertionTest, ASSERT_GT) {
"Expected: (2) > (2), actual: 2 vs 2");
}
#if GTEST_HAS_EXCEPTIONS
// Tests ASSERT_THROW.
TEST(AssertionTest, ASSERT_THROW) {
ASSERT_THROW(ThrowAnInteger(), int);
EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool),
"Expected: ThrowAnInteger() throws an exception of type"\
" bool.\n Actual: it throws a different type.");
EXPECT_FATAL_FAILURE(ASSERT_THROW(1, bool),
"Expected: 1 throws an exception of type bool.\n"\
" Actual: it throws nothing.");
}
// Tests ASSERT_NO_THROW.
TEST(AssertionTest, ASSERT_NO_THROW) {
ASSERT_NO_THROW(1);
EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
"Expected: ThrowAnInteger() doesn't throw an exception."\
"\n Actual: it throws.");
}
// Tests ASSERT_ANY_THROW.
TEST(AssertionTest, ASSERT_ANY_THROW) {
ASSERT_ANY_THROW(ThrowAnInteger());
EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(1),
"Expected: 1 throws an exception.\n Actual: it "\
"doesn't.");
}
#endif // GTEST_HAS_EXCEPTIONS
// Makes sure we deal with the precedence of <<. This test should
// compile.
TEST(AssertionTest, AssertPrecedence) {
@ -2764,6 +2845,32 @@ TEST(AssertionSyntaxTest, BehavesLikeSingleStatement) {
;
else
EXPECT_GT(3, 2) << "";
#if GTEST_HAS_EXCEPTIONS
if (false)
EXPECT_THROW(1, bool);
if (true)
EXPECT_THROW(ThrowAnInteger(), int);
else
;
if (false)
EXPECT_NO_THROW(ThrowAnInteger());
if (true)
EXPECT_NO_THROW(1);
else
;
if (false)
EXPECT_ANY_THROW(1);
if (true)
EXPECT_ANY_THROW(ThrowAnInteger());
else
;
#endif // GTEST_HAS_EXCEPTIONS
}
// Tests that the assertion macros work well with switch statements.
@ -2792,6 +2899,22 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
EXPECT_NE(1, 2);
}
#if GTEST_HAS_EXCEPTIONS
void ThrowAString() {
throw "String";
}
// Test that the exception assertion macros compile and work with const
// type qualifier.
TEST(AssertionSyntaxTest, WorksWithConst) {
ASSERT_THROW(ThrowAString(), const char*);
EXPECT_THROW(ThrowAString(), const char*);
}
#endif // GTEST_HAS_EXCEPTIONS
} // namespace
// Returns the number of successful parts in the current test.
@ -2971,6 +3094,37 @@ TEST(ExpectTest, EXPECT_GT) {
"(2) > (3)");
}
#if GTEST_HAS_EXCEPTIONS
// Tests EXPECT_THROW.
TEST(ExpectTest, EXPECT_THROW) {
EXPECT_THROW(ThrowAnInteger(), int);
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
"Expected: ThrowAnInteger() throws an exception of "\
"type bool.\n Actual: it throws a different type.");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(1, bool),
"Expected: 1 throws an exception of type bool.\n"\
" Actual: it throws nothing.");
}
// Tests EXPECT_NO_THROW.
TEST(ExpectTest, EXPECT_NO_THROW) {
EXPECT_NO_THROW(1);
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
"Expected: ThrowAnInteger() doesn't throw an "\
"exception.\n Actual: it throws.");
}
// Tests EXPECT_ANY_THROW.
TEST(ExpectTest, EXPECT_ANY_THROW) {
EXPECT_ANY_THROW(ThrowAnInteger());
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(1),
"Expected: 1 throws an exception.\n Actual: it "\
"doesn't.");
}
#endif // GTEST_HAS_EXCEPTIONS
// Make sure we deal with the precedence of <<.
TEST(ExpectTest, ExpectPrecedence) {
EXPECT_EQ(1 < 2, true);
@ -4477,6 +4631,37 @@ TEST(StreamingAssertionsTest, FloatingPointEquals) {
"expected failure");
}
#if GTEST_HAS_EXCEPTIONS
TEST(StreamingAssertionsTest, Throw) {
EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
"expected failure", "expected failure");
}
TEST(StreamingAssertionsTest, NoThrow) {
EXPECT_NO_THROW(1) << "unexpected failure";
ASSERT_NO_THROW(1) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
"expected failure", "expected failure");
}
TEST(StreamingAssertionsTest, AnyThrow) {
EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(1) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(1) <<
"expected failure", "expected failure");
}
#endif // GTEST_HAS_EXCEPTIONS
// Tests that Google Test correctly decides whether to use colors in the output.
TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {