gitMirror/googletest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Makes googlemock throw a runtime_error instead of abort when a mock

Browse Source 
method with no default value is invoked (if exceptions are enabled).
This commit is contained in:
zhanyong.wan
2013-02-28 22:58:51 +00:00
parent cf40604cf0
commit edd4ab4945
4 changed files with 283 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
test/gmock-spec-builders_test.cc
View File

@@ -1111,7 +1111,11 @@ TEST(UndefinedReturnValueTest, ReturnValueIsMandatory) {
// TODO(wan@google.com): We should really verify the output message,
// but we cannot yet due to that EXPECT_DEATH only captures stderr
// while Google Mock logs to stdout.
#if GTEST_HAS_EXCEPTIONS
EXPECT_ANY_THROW(a.ReturnResult(1));
#else
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(1), "");
#endif
}
// Tests that an excessive call (one whose arguments match the
@@ -1260,87 +1264,116 @@ TEST(SequenceTest, AnyOrderIsOkByDefault) {
// Tests that the calls must be in strict order when a complete order
// is specified.
TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo) {
TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
MockA a;
ON_CALL(a, ReturnResult(_))
.WillByDefault(Return(Result()));
Sequence s;
EXPECT_CALL(a, ReturnResult(1))
.InSequence(s)
.WillOnce(Return(Result()));
.InSequence(s);
EXPECT_CALL(a, ReturnResult(2))
.InSequence(s)
.WillOnce(Return(Result()));
.InSequence(s);
EXPECT_CALL(a, ReturnResult(3))
.InSequence(s)
.WillOnce(Return(Result()));
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(1);
a.ReturnResult(3);
a.ReturnResult(2);
}, "");
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(2);
a.ReturnResult(1);
a.ReturnResult(3);
}, "");
.InSequence(s);
a.ReturnResult(1);
// May only be called after a.ReturnResult(2).
EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
a.ReturnResult(2);
a.ReturnResult(3);
}
// Tests specifying a DAG using multiple sequences.
TEST(SequenceTest, CallsMustConformToSpecifiedDag) {
// Tests that the calls must be in strict order when a complete order
// is specified.
TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
MockA a;
MockB b;
Sequence x, y;
ON_CALL(a, ReturnResult(_))
.WillByDefault(Return(Result()));
Sequence s;
EXPECT_CALL(a, ReturnResult(1))
.InSequence(x)
.WillOnce(Return(Result()));
EXPECT_CALL(b, DoB())
.Times(2)
.InSequence(y);
.InSequence(s);
EXPECT_CALL(a, ReturnResult(2))
.InSequence(x, y)
.WillRepeatedly(Return(Result()));
.InSequence(s);
EXPECT_CALL(a, ReturnResult(3))
.InSequence(x)
.WillOnce(Return(Result()));
// May only be called after a.ReturnResult(1).
EXPECT_NONFATAL_FAILURE(a.ReturnResult(2), "Unexpected mock function call");
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(1);
b.DoB();
a.ReturnResult(2);
}, "");
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(2);
}, "");
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(3);
}, "");
EXPECT_DEATH_IF_SUPPORTED({
a.ReturnResult(1);
b.DoB();
b.DoB();
a.ReturnResult(3);
a.ReturnResult(2);
}, "");
b.DoB();
a.ReturnResult(1);
b.DoB();
a.ReturnResult(3);
a.ReturnResult(2);
}
// Tests specifying a DAG using multiple sequences.
class PartialOrderTest : public testing::Test {
protected:
PartialOrderTest() {
ON_CALL(a_, ReturnResult(_))
.WillByDefault(Return(Result()));
// Specifies this partial ordering:
//
// a.ReturnResult(1) ==>
// a.ReturnResult(2) * n ==> a.ReturnResult(3)
// b.DoB() * 2 ==>
Sequence x, y;
EXPECT_CALL(a_, ReturnResult(1))
.InSequence(x);
EXPECT_CALL(b_, DoB())
.Times(2)
.InSequence(y);
EXPECT_CALL(a_, ReturnResult(2))
.Times(AnyNumber())
.InSequence(x, y);
EXPECT_CALL(a_, ReturnResult(3))
.InSequence(x);
}
MockA a_;
MockB b_;
};
TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
a_.ReturnResult(1);
b_.DoB();
// May only be called after the second DoB().
EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
b_.DoB();
a_.ReturnResult(3);
}
TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
// May only be called after ReturnResult(1).
EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
a_.ReturnResult(1);
b_.DoB();
b_.DoB();
a_.ReturnResult(3);
}
TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
// May only be called last.
EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3), "Unexpected mock function call");
a_.ReturnResult(1);
b_.DoB();
b_.DoB();
a_.ReturnResult(3);
}
TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
a_.ReturnResult(1);
b_.DoB();
b_.DoB();
a_.ReturnResult(3);
// May only be called before ReturnResult(3).
EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2), "Unexpected mock function call");
}
TEST(SequenceTest, Retirement) {
@@ -1530,71 +1563,112 @@ TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
a.DoA(2);
}
// Calls must be in strict order when specified so.
TEST(AfterDeathTest, CallsMustBeInStrictOrderWhenSpecifiedSo) {
// Calls must be in strict order when specified so using .After().
TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
MockA a;
MockB b;
// Define ordering:
// a.DoA(1) ==> b.DoB() ==> a.DoA(2)
Expectation e1 = EXPECT_CALL(a, DoA(1));
Expectation e2 = EXPECT_CALL(b, DoB())
.After(e1);
EXPECT_CALL(a, DoA(2))
.After(e2);
a.DoA(1);
// May only be called after DoB().
EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
b.DoB();
a.DoA(2);
}
// Calls must be in strict order when specified so using .After().
TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
MockA a;
MockB b;
// Define ordering:
// a.DoA(1) ==> b.DoB() * 2 ==> a.DoA(2)
Expectation e1 = EXPECT_CALL(a, DoA(1));
Expectation e2 = EXPECT_CALL(b, DoB())
.Times(2)
.After(e1);
EXPECT_CALL(a, ReturnResult(2))
.After(e2)
.WillOnce(Return(Result()));
EXPECT_CALL(a, DoA(2))
.After(e2);
a.DoA(1);
// If a call to ReturnResult() violates the specified order, no
// matching expectation will be found, and thus the default action
// will be done. Since the return type of ReturnResult() is not a
// built-in type, gmock won't know what to return and will thus
// abort the program. Therefore a death test can tell us whether
// gmock catches the order violation correctly.
//
// gtest and gmock print messages to stdout, which isn't captured by
// death tests. Therefore we have to match with an empty regular
// expression in all the EXPECT_DEATH()s.
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(2), "");
b.DoB();
// May only be called after the second DoB().
EXPECT_NONFATAL_FAILURE(a.DoA(2), "Unexpected mock function call");
b.DoB();
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(2), "");
b.DoB();
a.ReturnResult(2);
a.DoA(2);
}
// Calls must satisfy the partial order when specified so.
TEST(AfterDeathTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
MockA a;
ON_CALL(a, ReturnResult(_))
.WillByDefault(Return(Result()));
// Define ordering:
// a.DoA(1) ==>
// a.DoA(2) ==> a.ReturnResult(3)
Expectation e = EXPECT_CALL(a, DoA(1));
const ExpectationSet es = EXPECT_CALL(a, DoA(2));
EXPECT_CALL(a, ReturnResult(3))
.After(e, es)
.WillOnce(Return(Result()));
.After(e, es);
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(3), "");
// May only be called last.
EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
a.DoA(2);
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(3), "");
a.DoA(1);
a.ReturnResult(3);
}
// Calls must satisfy the partial order when specified so.
TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
MockA a;
// Define ordering:
// a.DoA(1) ==>
// a.DoA(2) ==> a.DoA(3)
Expectation e = EXPECT_CALL(a, DoA(1));
const ExpectationSet es = EXPECT_CALL(a, DoA(2));
EXPECT_CALL(a, DoA(3))
.After(e, es);
a.DoA(2);
// May only be called last.
EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
a.DoA(1);
a.DoA(3);
}
// .After() can be combined with .InSequence().
TEST(AfterDeathTest, CanBeUsedWithInSequence) {
TEST(AfterTest, CanBeUsedWithInSequence) {
MockA a;
Sequence s;
Expectation e = EXPECT_CALL(a, DoA(1));
EXPECT_CALL(a, DoA(2)).InSequence(s);
EXPECT_CALL(a, ReturnResult(3))
.InSequence(s).After(e)
.WillOnce(Return(Result()));
EXPECT_CALL(a, DoA(3))
.InSequence(s)
.After(e);
a.DoA(1);
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(3), "");
// May only be after DoA(2).
EXPECT_NONFATAL_FAILURE(a.DoA(3), "Unexpected mock function call");
a.DoA(2);
a.ReturnResult(3);
a.DoA(3);
}
// .After() can be called multiple times.
@@ -1636,17 +1710,24 @@ TEST(AfterTest, AcceptsUpToFiveArguments) {
// .After() allows input to contain duplicated Expectations.
TEST(AfterTest, AcceptsDuplicatedInput) {
MockA a;
ON_CALL(a, ReturnResult(_))
.WillByDefault(Return(Result()));
// Define ordering:
// DoA(1) ==>
// DoA(2) ==> ReturnResult(3)
Expectation e1 = EXPECT_CALL(a, DoA(1));
Expectation e2 = EXPECT_CALL(a, DoA(2));
ExpectationSet es;
es += e1;
es += e2;
EXPECT_CALL(a, ReturnResult(3))
.After(e1, e2, es, e1)
.WillOnce(Return(Result()));
.After(e1, e2, es, e1);
a.DoA(1);
EXPECT_DEATH_IF_SUPPORTED(a.ReturnResult(3), "");
// May only be after DoA(2).
EXPECT_NONFATAL_FAILURE(a.ReturnResult(3), "Unexpected mock function call");
a.DoA(2);
a.ReturnResult(3);