35#include "gmock/gmock-spec-builders.h"
42#include "gmock/gmock.h"
43#include "gmock/internal/gmock-port.h"
44#include "gtest/gtest.h"
45#include "gtest/gtest-spi.h"
46#include "gtest/internal/gtest-port.h"
55 void SetCallCount(
int n, ExpectationBase* exp) {
66using testing::AnyNumber;
67using testing::AtLeast;
69using testing::Between;
70using testing::Cardinality;
71using testing::CardinalityInterface;
73using testing::ContainsRegex;
75using testing::DoDefault;
77using testing::Expectation;
78using testing::ExpectationSet;
79using testing::GMOCK_FLAG(verbose);
81using testing::IgnoreResult;
82using testing::InSequence;
84using testing::InvokeWithoutArgs;
85using testing::IsNotSubstring;
86using testing::IsSubstring;
93using testing::SaveArg;
94using testing::Sequence;
95using testing::SetArgPointee;
97using testing::internal::FormatFileLocation;
98using testing::internal::kAllow;
99using testing::internal::kErrorVerbosity;
100using testing::internal::kFail;
101using testing::internal::kInfoVerbosity;
102using testing::internal::kWarn;
103using testing::internal::kWarningVerbosity;
105#if GTEST_HAS_STREAM_REDIRECTION
106using testing::HasSubstr;
107using testing::internal::CaptureStdout;
108using testing::internal::GetCapturedStdout;
113class MockIncomplete {
117 MOCK_METHOD1(ByRefFunc,
void(
const Incomplete& x));
121void PrintTo(
const Incomplete& x, ::std::ostream* os);
123TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
128 MockIncomplete incomplete;
129 EXPECT_CALL(incomplete, ByRefFunc(_))
135void PrintTo(
const Incomplete& , ::std::ostream* os) {
142class NonDefaultConstructible {
144 explicit NonDefaultConstructible(
int ) {}
151 MOCK_METHOD1(DoA,
void(
int n));
152 MOCK_METHOD1(ReturnResult, Result(
int n));
153 MOCK_METHOD0(ReturnNonDefaultConstructible, NonDefaultConstructible());
154 MOCK_METHOD2(Binary,
bool(
int x,
int y));
155 MOCK_METHOD2(ReturnInt,
int(
int x,
int y));
158 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
165 MOCK_CONST_METHOD0(DoB,
int());
166 MOCK_METHOD1(DoB,
int(
int n));
169 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
172class ReferenceHoldingMock {
174 ReferenceHoldingMock() {}
176 MOCK_METHOD1(AcceptReference,
void(std::shared_ptr<MockA>*));
179 GTEST_DISALLOW_COPY_AND_ASSIGN_(ReferenceHoldingMock);
187#define Method MethodW
192 virtual int Method() = 0;
194class MockCC :
public CC {
198 MOCK_METHOD0(Method,
int());
201 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
205TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
207 ON_CALL(cc, Method());
212TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
214 ON_CALL(cc, Method()).WillByDefault(Return(42));
215 EXPECT_EQ(42, cc.Method());
219TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
221 EXPECT_CALL(cc, Method());
226TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
228 EXPECT_CALL(cc, Method()).WillOnce(Return(42));
229 EXPECT_EQ(42, cc.Method());
236TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
240 ON_CALL(*pa++, DoA(_));
241 EXPECT_EQ(&a + 1, pa);
244TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
248 ON_CALL(a, DoA(n++));
254TEST(OnCallSyntaxTest, WithIsOptional) {
258 .WillByDefault(Return());
261 .WillByDefault(Return());
264TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
267 EXPECT_NONFATAL_FAILURE({
268 ON_CALL(a, ReturnResult(_))
271 .WillByDefault(Return(Result()));
272 },
".With() cannot appear more than once in an ON_CALL()");
275TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
278 EXPECT_DEATH_IF_SUPPORTED({
284TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
287 EXPECT_NONFATAL_FAILURE({
289 .WillByDefault(Return())
290 .WillByDefault(Return());
291 },
".WillByDefault() must appear exactly once in an ON_CALL()");
296TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
300 EXPECT_CALL(*pa++, DoA(_));
302 EXPECT_EQ(&a + 1, pa);
305TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
309 EXPECT_CALL(a, DoA(n++));
316TEST(ExpectCallSyntaxTest, WithIsOptional) {
319 EXPECT_CALL(a, DoA(5))
321 EXPECT_CALL(a, DoA(6))
326TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
329 EXPECT_NONFATAL_FAILURE({
330 EXPECT_CALL(a, DoA(6))
333 },
".With() cannot appear more than once in an EXPECT_CALL()");
338TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
341 EXPECT_NONFATAL_FAILURE({
342 EXPECT_CALL(a, DoA(1))
345 },
".With() must be the first clause in an EXPECT_CALL()");
349 EXPECT_NONFATAL_FAILURE({
350 EXPECT_CALL(a, DoA(2))
353 },
".With() must be the first clause in an EXPECT_CALL()");
358TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
361 EXPECT_CALL(a, DoA(1))
364 EXPECT_CALL(a, DoA(2))
366 .WillRepeatedly(Return());
373TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
376 EXPECT_NONFATAL_FAILURE({
377 EXPECT_CALL(a, DoA(1))
380 },
".Times() cannot appear more than once in an EXPECT_CALL()");
386TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
390 EXPECT_NONFATAL_FAILURE({
391 EXPECT_CALL(a, DoA(1))
394 },
".Times() cannot appear after ");
399TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
403 EXPECT_CALL(a, DoA(1));
404 EXPECT_CALL(a, DoA(2))
411TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
415 EXPECT_CALL(a, DoA(1))
422TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
426 Expectation e = EXPECT_CALL(a, DoA(1))
428 EXPECT_NONFATAL_FAILURE({
429 EXPECT_CALL(a, DoA(2))
432 },
".InSequence() cannot appear after ");
437TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
441 EXPECT_NONFATAL_FAILURE({
442 EXPECT_CALL(a, DoA(1))
445 },
".InSequence() cannot appear after ");
450TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
453 Expectation e = EXPECT_CALL(a, DoA(1));
454 EXPECT_NONFATAL_FAILURE({
455 EXPECT_CALL(a, DoA(2))
458 },
".After() cannot appear after ");
464TEST(ExpectCallSyntaxTest, WillIsOptional) {
467 EXPECT_CALL(a, DoA(1));
468 EXPECT_CALL(a, DoA(2))
475TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
478 EXPECT_CALL(a, DoA(1))
485TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
488 EXPECT_NONFATAL_FAILURE({
489 EXPECT_CALL(a, DoA(1))
490 .WillRepeatedly(Return())
492 },
".WillOnce() cannot appear after ");
497TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
500 EXPECT_CALL(a, DoA(1))
502 EXPECT_CALL(a, DoA(2))
504 .WillRepeatedly(Return());
511TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
514 EXPECT_NONFATAL_FAILURE({
515 EXPECT_CALL(a, DoA(1))
516 .WillRepeatedly(Return())
517 .WillRepeatedly(Return());
518 },
".WillRepeatedly() cannot appear more than once in an "
522TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
525 EXPECT_NONFATAL_FAILURE({
526 EXPECT_CALL(a, DoA(1))
527 .RetiresOnSaturation()
528 .WillRepeatedly(Return());
529 },
".WillRepeatedly() cannot appear after ");
532TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
535 EXPECT_CALL(a, DoA(1));
536 EXPECT_CALL(a, DoA(1))
537 .RetiresOnSaturation();
543TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
546 EXPECT_NONFATAL_FAILURE({
547 EXPECT_CALL(a, DoA(1))
548 .RetiresOnSaturation()
549 .RetiresOnSaturation();
550 },
".RetiresOnSaturation() cannot appear more than once");
555TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
558 EXPECT_CALL(a, DoA(1));
561 EXPECT_NONFATAL_FAILURE({
563 EXPECT_CALL(a, DoA(1));
564 },
"to be called once");
565 EXPECT_NONFATAL_FAILURE({
567 EXPECT_CALL(a, DoA(1));
570 },
"to be called once");
573#if GTEST_HAS_STREAM_REDIRECTION
577TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
583 EXPECT_CALL(b, DoB())
585 EXPECT_CALL(b, DoB(1))
587 EXPECT_CALL(b, DoB(2))
589 .WillRepeatedly(Return(1));
592 EXPECT_CALL(b, DoB(3))
593 .Times(Between(1, 2))
595 .WillOnce(Return(2));
599 EXPECT_CALL(b, DoB(4))
602 .WillRepeatedly(Return(2));
608 EXPECT_STREQ(
"", GetCapturedStdout().c_str());
613TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
619 EXPECT_CALL(b, DoB())
621 .WillOnce(Return(1));
622 EXPECT_CALL(b, DoB())
625 .WillOnce(Return(2));
626 EXPECT_CALL(b, DoB(1))
630 .RetiresOnSaturation();
634 EXPECT_CALL(b, DoB())
636 .WillRepeatedly(Return(1));
637 EXPECT_CALL(b, DoB(2))
640 .WillRepeatedly(Return(2));
646 const std::string output = GetCapturedStdout();
649 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
650 "Expected to be never called, but has 1 WillOnce().",
654 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
655 "Expected to be called at most once, "
656 "but has 2 WillOnce()s.",
660 "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
661 "Expected to be called once, but has 2 WillOnce()s.",
665 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
666 "Expected to be never called, but has 0 WillOnce()s "
667 "and a WillRepeatedly().",
671 "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
672 "Expected to be called once, but has 1 WillOnce() "
673 "and a WillRepeatedly().",
679TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
682 EXPECT_CALL(b, DoB())
683 .Times(Between(2, 3))
684 .WillOnce(Return(1));
688 const std::string output = GetCapturedStdout();
691 "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
692 "Expected to be called between 2 and 3 times, "
693 "but has only 1 WillOnce().",
698TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
699 int original_behavior = testing::GMOCK_FLAG(default_mock_behavior);
701 testing::GMOCK_FLAG(default_mock_behavior) = kAllow;
707 std::string output = GetCapturedStdout();
708 EXPECT_TRUE(output.empty()) << output;
710 testing::GMOCK_FLAG(default_mock_behavior) = kWarn;
716 std::string warning_output = GetCapturedStdout();
717 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
718 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
721 testing::GMOCK_FLAG(default_mock_behavior) = kFail;
722 EXPECT_NONFATAL_FAILURE({
725 },
"Uninteresting mock function call");
728 testing::GMOCK_FLAG(default_mock_behavior) = -1;
734 warning_output = GetCapturedStdout();
735 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
736 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
738 testing::GMOCK_FLAG(default_mock_behavior) = 3;
744 warning_output = GetCapturedStdout();
745 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
746 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
749 testing::GMOCK_FLAG(default_mock_behavior) = original_behavior;
758TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
760 EXPECT_CALL(b, DoB());
762 EXPECT_EQ(0, b.DoB());
767TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
770 .WillByDefault(Return(1));
771 EXPECT_CALL(b, DoB(_));
773 EXPECT_EQ(0, b.DoB(2));
777TEST(OnCallTest, PicksLastMatchingOnCall) {
780 .WillByDefault(Return(3));
782 .WillByDefault(Return(2));
784 .WillByDefault(Return(1));
785 EXPECT_CALL(b, DoB(_));
787 EXPECT_EQ(2, b.DoB(2));
793TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
795 EXPECT_CALL(b, DoB());
806TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
808 EXPECT_CALL(b, DoB(_))
809 .WillRepeatedly(Return(2));
810 EXPECT_CALL(b, DoB(1))
811 .WillRepeatedly(Return(1));
813 EXPECT_EQ(1, b.DoB(1));
817TEST(ExpectCallTest, CatchesTooFewCalls) {
818 EXPECT_NONFATAL_FAILURE({
820 EXPECT_CALL(b, DoB(5))
824 },
"Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
825 " Expected: to be called at least twice\n"
826 " Actual: called once - unsatisfied and active");
831TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
834 EXPECT_CALL(b, DoB())
836 .WillOnce(Return(2));
838 EXPECT_EQ(1, b.DoB());
839 EXPECT_EQ(2, b.DoB());
842 EXPECT_NONFATAL_FAILURE({
844 EXPECT_CALL(b, DoB())
846 .WillOnce(Return(2));
848 EXPECT_EQ(1, b.DoB());
849 },
"to be called twice");
853 EXPECT_CALL(b, DoB())
855 .WillOnce(Return(2));
857 EXPECT_EQ(1, b.DoB());
858 EXPECT_EQ(2, b.DoB());
859 EXPECT_NONFATAL_FAILURE(b.DoB(),
"to be called twice");
863TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
866 EXPECT_CALL(b, DoB())
868 .WillRepeatedly(Return(2));
870 EXPECT_EQ(1, b.DoB());
875 EXPECT_CALL(b, DoB())
877 .WillRepeatedly(Return(2));
879 EXPECT_EQ(1, b.DoB());
880 EXPECT_EQ(2, b.DoB());
881 EXPECT_EQ(2, b.DoB());
884 EXPECT_NONFATAL_FAILURE({
886 EXPECT_CALL(b, DoB())
888 .WillRepeatedly(Return(2));
889 },
"to be called at least once");
894TEST(ExpectCallTest, NthMatchTakesNthAction) {
896 EXPECT_CALL(b, DoB())
899 .WillOnce(Return(3));
901 EXPECT_EQ(1, b.DoB());
902 EXPECT_EQ(2, b.DoB());
903 EXPECT_EQ(3, b.DoB());
908TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
910 EXPECT_CALL(b, DoB())
912 .WillRepeatedly(Return(2));
914 EXPECT_EQ(1, b.DoB());
915 EXPECT_EQ(2, b.DoB());
916 EXPECT_EQ(2, b.DoB());
919#if GTEST_HAS_STREAM_REDIRECTION
923TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
925 EXPECT_CALL(b, DoB(_))
927 EXPECT_CALL(b, DoB())
930 .WillOnce(Return(2));
933 EXPECT_EQ(0, b.DoB(1));
935 EXPECT_EQ(1, b.DoB());
936 EXPECT_EQ(2, b.DoB());
937 const std::string output1 = GetCapturedStdout();
938 EXPECT_STREQ(
"", output1.c_str());
941 EXPECT_EQ(0, b.DoB());
942 EXPECT_EQ(0, b.DoB());
943 const std::string output2 = GetCapturedStdout();
944 EXPECT_THAT(output2.c_str(),
945 HasSubstr(
"Actions ran out in EXPECT_CALL(b, DoB())...\n"
946 "Called 3 times, but only 2 WillOnce()s are specified"
947 " - returning default value."));
948 EXPECT_THAT(output2.c_str(),
949 HasSubstr(
"Actions ran out in EXPECT_CALL(b, DoB())...\n"
950 "Called 4 times, but only 2 WillOnce()s are specified"
951 " - returning default value."));
954TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
956 std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
957 EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
959 EXPECT_EQ(1, b.DoB());
962 EXPECT_EQ(0, b.DoB());
963 const std::string output = GetCapturedStdout();
965 EXPECT_PRED_FORMAT2(IsSubstring, expect_call_location, output);
968TEST(FunctionMockerMessageTest,
969 ReportsDefaultActionLocationOfUninterestingCallsForNaggyMock) {
970 std::string on_call_location;
974 on_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
975 ON_CALL(b, DoB(_)).WillByDefault(Return(0));
978 EXPECT_PRED_FORMAT2(IsSubstring, on_call_location, GetCapturedStdout());
984TEST(UninterestingCallTest, DoesDefaultAction) {
988 ON_CALL(a, Binary(_, _))
989 .WillByDefault(Return(
true));
990 EXPECT_TRUE(a.Binary(1, 2));
995 EXPECT_EQ(0, b.DoB());
999TEST(UnexpectedCallTest, DoesDefaultAction) {
1003 ON_CALL(a, Binary(_, _))
1004 .WillByDefault(Return(
true));
1005 EXPECT_CALL(a, Binary(0, 0));
1007 bool result =
false;
1008 EXPECT_NONFATAL_FAILURE(result = a.Binary(1, 2),
1009 "Unexpected mock function call");
1010 EXPECT_TRUE(result);
1015 EXPECT_CALL(b, DoB(0))
1018 EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
1019 "Unexpected mock function call");
1025TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
1028 EXPECT_CALL(a1, DoA(1));
1033 EXPECT_NONFATAL_FAILURE(
1035 "Unexpected mock function call - returning directly.\n"
1036 " Function call: DoA(9)\n"
1037 "Google Mock tried the following 1 expectation, but it didn't match:");
1038 EXPECT_NONFATAL_FAILURE(
1040 " Expected arg #0: is equal to 1\n"
1042 " Expected: to be called once\n"
1043 " Actual: called once - saturated and active");
1047 EXPECT_CALL(a2, DoA(1));
1048 EXPECT_CALL(a2, DoA(3));
1050 EXPECT_NONFATAL_FAILURE(
1052 "Unexpected mock function call - returning directly.\n"
1053 " Function call: DoA(2)\n"
1054 "Google Mock tried the following 2 expectations, but none matched:");
1055 EXPECT_NONFATAL_FAILURE(
1057 "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
1058 " Expected arg #0: is equal to 1\n"
1060 " Expected: to be called once\n"
1061 " Actual: called once - saturated and active");
1062 EXPECT_NONFATAL_FAILURE(
1064 "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
1065 " Expected arg #0: is equal to 3\n"
1067 " Expected: to be called once\n"
1068 " Actual: never called - unsatisfied and active");
1074TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
1076 EXPECT_CALL(b1, DoB(1));
1078 EXPECT_NONFATAL_FAILURE(
1080 "Unexpected mock function call - returning default value.\n"
1081 " Function call: DoB(2)\n"
1083 "Google Mock tried the following 1 expectation, but it didn't match:");
1084 EXPECT_NONFATAL_FAILURE(
1086 " Expected arg #0: is equal to 1\n"
1088 " Expected: to be called once\n"
1089 " Actual: called once - saturated and active");
1094TEST(UnexpectedCallTest, RetiredExpectation) {
1096 EXPECT_CALL(b, DoB(1))
1097 .RetiresOnSaturation();
1100 EXPECT_NONFATAL_FAILURE(
1102 " Expected: the expectation is active\n"
1103 " Actual: it is retired");
1108TEST(UnexpectedCallTest, UnmatchedArguments) {
1110 EXPECT_CALL(b, DoB(1));
1112 EXPECT_NONFATAL_FAILURE(
1114 " Expected arg #0: is equal to 1\n"
1121TEST(UnexpectedCallTest, UnsatisifiedPrerequisites) {
1124 EXPECT_CALL(b, DoB(1))
1126 EXPECT_CALL(b, DoB(2))
1129 EXPECT_CALL(b, DoB(3))
1131 EXPECT_CALL(b, DoB(4))
1132 .InSequence(s1, s2);
1134 ::testing::TestPartResultArray failures;
1136 ::testing::ScopedFakeTestPartResultReporter reporter(&failures);
1143 ASSERT_EQ(1, failures.size());
1144 const ::testing::TestPartResult& r = failures.GetTestPartResult(0);
1145 EXPECT_EQ(::testing::TestPartResult::kNonFatalFailure, r.type());
1150 EXPECT_THAT(r.message(), ContainsRegex(
1153 "(?s)the following immediate pre-requisites are not satisfied:\n"
1154 ".*: pre-requisite #0\n"
1155 ".*: pre-requisite #1"));
1156#elif GTEST_USES_POSIX_RE
1157 EXPECT_THAT(r.message(), ContainsRegex(
1160 "the following immediate pre-requisites are not satisfied:\n"
1161 "(.|\n)*: pre-requisite #0\n"
1162 "(.|\n)*: pre-requisite #1"));
1165 EXPECT_THAT(r.message(), ContainsRegex(
1166 "the following immediate pre-requisites are not satisfied:"));
1167 EXPECT_THAT(r.message(), ContainsRegex(
": pre-requisite #0"));
1168 EXPECT_THAT(r.message(), ContainsRegex(
": pre-requisite #1"));
1176TEST(UndefinedReturnValueTest,
1177 ReturnValueIsMandatoryWhenNotDefaultConstructible) {
1182#if GTEST_HAS_EXCEPTIONS
1183 EXPECT_ANY_THROW(a.ReturnNonDefaultConstructible());
1185 EXPECT_DEATH_IF_SUPPORTED(a.ReturnNonDefaultConstructible(),
"");
1191TEST(ExcessiveCallTest, DoesDefaultAction) {
1195 ON_CALL(a, Binary(_, _))
1196 .WillByDefault(Return(
true));
1197 EXPECT_CALL(a, Binary(0, 0));
1199 bool result =
false;
1200 EXPECT_NONFATAL_FAILURE(result = a.Binary(0, 0),
1201 "Mock function called more times than expected");
1202 EXPECT_TRUE(result);
1207 EXPECT_CALL(b, DoB(0))
1210 EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
1211 "Mock function called more times than expected");
1217TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
1219 EXPECT_CALL(a, DoA(_))
1221 EXPECT_NONFATAL_FAILURE(
1223 "Mock function called more times than expected - returning directly.\n"
1224 " Function call: DoA(9)\n"
1225 " Expected: to be never called\n"
1226 " Actual: called once - over-saturated and active");
1231TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
1233 EXPECT_CALL(b, DoB(_));
1235 EXPECT_NONFATAL_FAILURE(
1237 "Mock function called more times than expected - "
1238 "returning default value.\n"
1239 " Function call: DoB(2)\n"
1241 " Expected: to be called once\n"
1242 " Actual: called twice - over-saturated and active");
1247TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
1252 EXPECT_CALL(a, DoA(1));
1253 EXPECT_CALL(a, DoA(2));
1256 EXPECT_NONFATAL_FAILURE({
1258 },
"Unexpected mock function call");
1264TEST(InSequenceTest, NestedInSequence) {
1269 EXPECT_CALL(a, DoA(1));
1273 EXPECT_CALL(a, DoA(2));
1274 EXPECT_CALL(a, DoA(3));
1278 EXPECT_NONFATAL_FAILURE({
1281 },
"Unexpected mock function call");
1287TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
1292 EXPECT_CALL(a, DoA(1));
1293 EXPECT_CALL(a, DoA(2));
1295 EXPECT_CALL(a, DoA(3));
1297 EXPECT_NONFATAL_FAILURE({
1299 },
"Unexpected mock function call");
1307TEST(SequenceTest, AnyOrderIsOkByDefault) {
1312 EXPECT_CALL(a, DoA(1));
1313 EXPECT_CALL(b, DoB())
1314 .Times(AnyNumber());
1324 EXPECT_CALL(a, DoA(1));
1325 EXPECT_CALL(b, DoB())
1326 .Times(AnyNumber());
1335TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
1337 ON_CALL(a, ReturnResult(_))
1338 .WillByDefault(Return(Result()));
1341 EXPECT_CALL(a, ReturnResult(1))
1343 EXPECT_CALL(a, ReturnResult(2))
1345 EXPECT_CALL(a, ReturnResult(3))
1351 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1359TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
1361 ON_CALL(a, ReturnResult(_))
1362 .WillByDefault(Return(Result()));
1365 EXPECT_CALL(a, ReturnResult(1))
1367 EXPECT_CALL(a, ReturnResult(2))
1371 EXPECT_NONFATAL_FAILURE(a.ReturnResult(2),
"Unexpected mock function call");
1380 PartialOrderTest() {
1381 ON_CALL(a_, ReturnResult(_))
1382 .WillByDefault(Return(Result()));
1390 EXPECT_CALL(a_, ReturnResult(1))
1392 EXPECT_CALL(b_, DoB())
1395 EXPECT_CALL(a_, ReturnResult(2))
1398 EXPECT_CALL(a_, ReturnResult(3))
1406TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
1411 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1417TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
1419 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1427TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
1429 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3),
"Unexpected mock function call");
1437TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
1444 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1447TEST(SequenceTest, Retirement) {
1451 EXPECT_CALL(a, DoA(1))
1453 EXPECT_CALL(a, DoA(_))
1455 .RetiresOnSaturation();
1456 EXPECT_CALL(a, DoA(1))
1466TEST(ExpectationTest, ConstrutorsWork) {
1471 Expectation e2 = EXPECT_CALL(a, DoA(2));
1472 Expectation e3 = EXPECT_CALL(a, DoA(3)).With(_);
1475 Expectation e4 = EXPECT_CALL(a, DoA(4)).Times(1);
1476 Expectation e5 = EXPECT_CALL(a, DoA(5)).InSequence(s);
1478 Expectation e6 = EXPECT_CALL(a, DoA(6)).After(e2);
1479 Expectation e7 = EXPECT_CALL(a, DoA(7)).WillOnce(Return());
1480 Expectation e8 = EXPECT_CALL(a, DoA(8)).WillRepeatedly(Return());
1481 Expectation e9 = EXPECT_CALL(a, DoA(9)).RetiresOnSaturation();
1483 Expectation e10 = e2;
1485 EXPECT_THAT(e1, Ne(e2));
1486 EXPECT_THAT(e2, Eq(e10));
1498TEST(ExpectationTest, AssignmentWorks) {
1501 Expectation e2 = EXPECT_CALL(a, DoA(1));
1503 EXPECT_THAT(e1, Ne(e2));
1506 EXPECT_THAT(e1, Eq(e2));
1513TEST(ExpectationSetTest, MemberTypesAreCorrect) {
1514 ::testing::StaticAssertTypeEq<Expectation, ExpectationSet::value_type>();
1517TEST(ExpectationSetTest, ConstructorsWork) {
1521 const Expectation e2;
1523 ExpectationSet es2 = EXPECT_CALL(a, DoA(1));
1524 ExpectationSet es3 = e1;
1525 ExpectationSet es4(e1);
1526 ExpectationSet es5 = e2;
1527 ExpectationSet es6(e2);
1528 ExpectationSet es7 = es2;
1530 EXPECT_EQ(0, es1.size());
1531 EXPECT_EQ(1, es2.size());
1532 EXPECT_EQ(1, es3.size());
1533 EXPECT_EQ(1, es4.size());
1534 EXPECT_EQ(1, es5.size());
1535 EXPECT_EQ(1, es6.size());
1536 EXPECT_EQ(1, es7.size());
1538 EXPECT_THAT(es3, Ne(es2));
1539 EXPECT_THAT(es4, Eq(es3));
1540 EXPECT_THAT(es5, Eq(es4));
1541 EXPECT_THAT(es6, Eq(es5));
1542 EXPECT_THAT(es7, Eq(es2));
1546TEST(ExpectationSetTest, AssignmentWorks) {
1548 ExpectationSet es2 = Expectation();
1551 EXPECT_EQ(1, es1.size());
1552 EXPECT_THAT(*(es1.begin()), Eq(Expectation()));
1553 EXPECT_THAT(es1, Eq(es2));
1556TEST(ExpectationSetTest, InsertionWorks) {
1560 EXPECT_EQ(1, es1.size());
1561 EXPECT_THAT(*(es1.begin()), Eq(e1));
1564 Expectation e2 = EXPECT_CALL(a, DoA(1));
1566 EXPECT_EQ(2, es1.size());
1568 ExpectationSet::const_iterator it1 = es1.begin();
1569 ExpectationSet::const_iterator it2 = it1;
1571 EXPECT_TRUE(*it1 == e1 || *it2 == e1);
1572 EXPECT_TRUE(*it1 == e2 || *it2 == e2);
1576TEST(ExpectationSetTest, SizeWorks) {
1578 EXPECT_EQ(0, es.size());
1580 es += Expectation();
1581 EXPECT_EQ(1, es.size());
1584 es += EXPECT_CALL(a, DoA(1));
1585 EXPECT_EQ(2, es.size());
1590TEST(ExpectationSetTest, IsEnumerable) {
1592 EXPECT_TRUE(es.begin() == es.end());
1594 es += Expectation();
1595 ExpectationSet::const_iterator it = es.begin();
1596 EXPECT_TRUE(it != es.end());
1597 EXPECT_THAT(*it, Eq(Expectation()));
1599 EXPECT_TRUE(it== es.end());
1604TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
1607 es += EXPECT_CALL(a, DoA(1));
1608 es += EXPECT_CALL(a, DoA(2));
1609 EXPECT_CALL(a, DoA(3))
1617TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
1622 const Expectation e1 = EXPECT_CALL(a, DoA(1));
1623 const Expectation e2 = EXPECT_CALL(b, DoB())
1626 EXPECT_CALL(a, DoA(2)).After(e2);
1635TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
1641 Expectation e1 = EXPECT_CALL(a, DoA(1));
1642 Expectation e2 = EXPECT_CALL(b, DoB())
1644 EXPECT_CALL(a, DoA(2))
1650 EXPECT_NONFATAL_FAILURE(a.DoA(2),
"Unexpected mock function call");
1657TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
1663 Expectation e1 = EXPECT_CALL(a, DoA(1));
1664 Expectation e2 = EXPECT_CALL(b, DoB())
1667 EXPECT_CALL(a, DoA(2))
1674 EXPECT_NONFATAL_FAILURE(a.DoA(2),
"Unexpected mock function call");
1681TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
1683 ON_CALL(a, ReturnResult(_))
1684 .WillByDefault(Return(Result()));
1689 Expectation e = EXPECT_CALL(a, DoA(1));
1690 const ExpectationSet es = EXPECT_CALL(a, DoA(2));
1691 EXPECT_CALL(a, ReturnResult(3))
1695 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1703TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
1709 Expectation e = EXPECT_CALL(a, DoA(1));
1710 const ExpectationSet es = EXPECT_CALL(a, DoA(2));
1711 EXPECT_CALL(a, DoA(3))
1717 EXPECT_NONFATAL_FAILURE(a.DoA(3),
"Unexpected mock function call");
1724TEST(AfterTest, CanBeUsedWithInSequence) {
1727 Expectation e = EXPECT_CALL(a, DoA(1));
1728 EXPECT_CALL(a, DoA(2)).InSequence(s);
1729 EXPECT_CALL(a, DoA(3))
1736 EXPECT_NONFATAL_FAILURE(a.DoA(3),
"Unexpected mock function call");
1743TEST(AfterTest, CanBeCalledManyTimes) {
1745 Expectation e1 = EXPECT_CALL(a, DoA(1));
1746 Expectation e2 = EXPECT_CALL(a, DoA(2));
1747 Expectation e3 = EXPECT_CALL(a, DoA(3));
1748 EXPECT_CALL(a, DoA(4))
1760TEST(AfterTest, AcceptsUpToFiveArguments) {
1762 Expectation e1 = EXPECT_CALL(a, DoA(1));
1763 Expectation e2 = EXPECT_CALL(a, DoA(2));
1764 Expectation e3 = EXPECT_CALL(a, DoA(3));
1765 ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
1766 ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
1767 EXPECT_CALL(a, DoA(6))
1768 .After(e1, e2, e3, es1, es2);
1779TEST(AfterTest, AcceptsDuplicatedInput) {
1781 ON_CALL(a, ReturnResult(_))
1782 .WillByDefault(Return(Result()));
1787 Expectation e1 = EXPECT_CALL(a, DoA(1));
1788 Expectation e2 = EXPECT_CALL(a, DoA(2));
1792 EXPECT_CALL(a, ReturnResult(3))
1793 .After(e1, e2, es, e1);
1798 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1806TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
1808 ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
1809 Expectation e2 = EXPECT_CALL(a, DoA(2));
1810 EXPECT_CALL(a, DoA(3))
1823TEST(DeletingMockEarlyTest, Success1) {
1824 MockB*
const b1 =
new MockB;
1825 MockA*
const a =
new MockA;
1826 MockB*
const b2 =
new MockB;
1830 EXPECT_CALL(*b1, DoB(_))
1831 .WillOnce(Return(1));
1832 EXPECT_CALL(*a, Binary(_, _))
1834 .WillRepeatedly(Return(
true));
1835 EXPECT_CALL(*b2, DoB(_))
1837 .WillRepeatedly(Return(2));
1840 EXPECT_EQ(1, b1->DoB(1));
1843 EXPECT_TRUE(a->Binary(0, 1));
1846 EXPECT_TRUE(a->Binary(1, 2));
1851TEST(DeletingMockEarlyTest, Success2) {
1852 MockB*
const b1 =
new MockB;
1853 MockA*
const a =
new MockA;
1854 MockB*
const b2 =
new MockB;
1858 EXPECT_CALL(*b1, DoB(_))
1859 .WillOnce(Return(1));
1860 EXPECT_CALL(*a, Binary(_, _))
1861 .Times(AnyNumber());
1862 EXPECT_CALL(*b2, DoB(_))
1864 .WillRepeatedly(Return(2));
1868 EXPECT_EQ(1, b1->DoB(1));
1869 EXPECT_EQ(2, b2->DoB(2));
1879# pragma warning(push)
1880# pragma warning(disable:4100)
1883ACTION_P(Delete, ptr) {
delete ptr; }
1886# pragma warning(pop)
1889TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
1890 MockA*
const a =
new MockA;
1891 EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
1895TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
1896 MockA*
const a =
new MockA;
1897 EXPECT_CALL(*a, ReturnResult(_))
1898 .WillOnce(DoAll(Delete(a), Return(Result())));
1899 a->ReturnResult(42);
1903TEST(DeletingMockEarlyTest, Failure1) {
1904 MockB*
const b1 =
new MockB;
1905 MockA*
const a =
new MockA;
1906 MockB*
const b2 =
new MockB;
1910 EXPECT_CALL(*b1, DoB(_))
1911 .WillOnce(Return(1));
1912 EXPECT_CALL(*a, Binary(_, _))
1913 .Times(AnyNumber());
1914 EXPECT_CALL(*b2, DoB(_))
1916 .WillRepeatedly(Return(2));
1920 EXPECT_NONFATAL_FAILURE({
1922 },
"Unexpected mock function call");
1923 EXPECT_EQ(1, b1->DoB(1));
1929TEST(DeletingMockEarlyTest, Failure2) {
1930 MockB*
const b1 =
new MockB;
1931 MockA*
const a =
new MockA;
1932 MockB*
const b2 =
new MockB;
1936 EXPECT_CALL(*b1, DoB(_));
1937 EXPECT_CALL(*a, Binary(_, _))
1938 .Times(AnyNumber());
1939 EXPECT_CALL(*b2, DoB(_))
1940 .Times(AnyNumber());
1943 EXPECT_NONFATAL_FAILURE(
delete b1,
1944 "Actual: never called");
1945 EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
1946 "Unexpected mock function call");
1947 EXPECT_NONFATAL_FAILURE(b2->DoB(1),
1948 "Unexpected mock function call");
1953class EvenNumberCardinality :
public CardinalityInterface {
1957 bool IsSatisfiedByCallCount(
int call_count)
const override {
1958 return call_count % 2 == 0;
1963 bool IsSaturatedByCallCount(
int )
const override {
1968 void DescribeTo(::std::ostream* os)
const override {
1969 *os <<
"called even number of times";
1973Cardinality EvenNumber() {
1974 return Cardinality(
new EvenNumberCardinality);
1977TEST(ExpectationBaseTest,
1978 AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
1979 MockA* a =
new MockA;
1982 EXPECT_CALL(*a, DoA(1))
1983 .Times(EvenNumber())
1985 EXPECT_CALL(*a, DoA(2))
1988 EXPECT_CALL(*a, DoA(3))
1989 .Times(AnyNumber());
1993 EXPECT_NONFATAL_FAILURE(a->DoA(2),
"Unexpected mock function call");
1994 EXPECT_NONFATAL_FAILURE(
delete a,
"to be called even number of times");
2003inline void operator<<(::std::ostream& os,
const Printable&) {
2008 Unprintable() : value(0) {}
2016 MOCK_METHOD6(VoidMethod,
void(
bool cond,
int n, std::string s,
void* p,
2017 const Printable& x, Unprintable y));
2018 MOCK_METHOD0(NonVoidMethod,
int());
2021 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
2026 VerboseFlagPreservingFixture()
2027 : saved_verbose_flag_(GMOCK_FLAG(verbose)) {}
2029 ~VerboseFlagPreservingFixture()
override {
2030 GMOCK_FLAG(verbose) = saved_verbose_flag_;
2034 const std::string saved_verbose_flag_;
2036 GTEST_DISALLOW_COPY_AND_ASSIGN_(VerboseFlagPreservingFixture);
2039#if GTEST_HAS_STREAM_REDIRECTION
2044TEST(FunctionCallMessageTest,
2045 UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
2046 GMOCK_FLAG(verbose) = kWarningVerbosity;
2049 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
2050 const std::string output = GetCapturedStdout();
2051 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", output);
2052 EXPECT_PRED_FORMAT2(IsNotSubstring,
"Stack trace:", output);
2058TEST(FunctionCallMessageTest,
2059 UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
2060 GMOCK_FLAG(verbose) = kInfoVerbosity;
2063 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
2064 const std::string output = GetCapturedStdout();
2065 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", output);
2066 EXPECT_PRED_FORMAT2(IsSubstring,
"Stack trace:", output);
2075 EXPECT_PRED_FORMAT2(IsSubstring,
"VoidMethod(", output);
2081 const std::string output2 = GetCapturedStdout();
2082 EXPECT_PRED_FORMAT2(IsSubstring,
"NonVoidMethod(", output2);
2089TEST(FunctionCallMessageTest,
2090 UninterestingCallOnNaggyMockPrintsArgumentsAndReturnValue) {
2095 const std::string output1 = GetCapturedStdout();
2096 EXPECT_PRED_FORMAT2(
2098 "Uninteresting mock function call - returning default value.\n"
2099 " Function call: DoB()\n"
2100 " Returns: 0\n", output1.c_str());
2106 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
2107 const std::string output2 = GetCapturedStdout();
2108 EXPECT_THAT(output2.c_str(),
2110 "Uninteresting mock function call - returning directly\\.\n"
2111 " Function call: VoidMethod"
2112 "\\(false, 5, \"Hi\", NULL, @.+ "
2113 "Printable, 4-byte object <00-00 00-00>\\)"));
2119class GMockVerboseFlagTest :
public VerboseFlagPreservingFixture {
2125 void VerifyOutput(
const std::string& output,
bool should_print,
2126 const std::string& expected_substring,
2127 const std::string& function_name) {
2129 EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
2133 EXPECT_THAT(output.c_str(), HasSubstr(function_name));
2136 static_cast<void>(function_name);
2139 EXPECT_STREQ(
"", output.c_str());
2144 void TestExpectedCall(
bool should_print) {
2146 EXPECT_CALL(a, DoA(5));
2147 EXPECT_CALL(a, Binary(_, 1))
2148 .WillOnce(Return(
true));
2154 GetCapturedStdout(),
2156 "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
2157 " Function call: DoA(5)\n"
2165 GetCapturedStdout(),
2167 "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
2168 " Function call: Binary(2, 1)\n"
2175 void TestUninterestingCallOnNaggyMock(
bool should_print) {
2177 const std::string note =
2178 "NOTE: You can safely ignore the above warning unless this "
2179 "call should not happen. Do not suppress it by blindly adding "
2180 "an EXPECT_CALL() if you don't mean to enforce the call. "
2182 "https://github.com/google/googletest/blob/master/docs/"
2183 "gmock_cook_book.md#"
2184 "knowing-when-to-expect for details.";
2190 GetCapturedStdout(),
2192 "\nGMOCK WARNING:\n"
2193 "Uninteresting mock function call - returning directly.\n"
2194 " Function call: DoA(5)\n" +
2202 GetCapturedStdout(),
2204 "\nGMOCK WARNING:\n"
2205 "Uninteresting mock function call - returning default value.\n"
2206 " Function call: Binary(2, 1)\n"
2207 " Returns: false\n" +
2215TEST_F(GMockVerboseFlagTest, Info) {
2216 GMOCK_FLAG(verbose) = kInfoVerbosity;
2217 TestExpectedCall(
true);
2218 TestUninterestingCallOnNaggyMock(
true);
2223TEST_F(GMockVerboseFlagTest, Warning) {
2224 GMOCK_FLAG(verbose) = kWarningVerbosity;
2225 TestExpectedCall(
false);
2226 TestUninterestingCallOnNaggyMock(
true);
2231TEST_F(GMockVerboseFlagTest, Error) {
2232 GMOCK_FLAG(verbose) = kErrorVerbosity;
2233 TestExpectedCall(
false);
2234 TestUninterestingCallOnNaggyMock(
false);
2239TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
2240 GMOCK_FLAG(verbose) =
"invalid";
2241 TestExpectedCall(
false);
2242 TestUninterestingCallOnNaggyMock(
true);
2252void PrintTo(PrintMeNot , ::std::ostream* ) {
2253 ADD_FAILURE() <<
"Google Mock is printing a value that shouldn't be "
2254 <<
"printed even to an internal buffer.";
2257class LogTestHelper {
2261 MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
2264 GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
2267class GMockLogTest :
public VerboseFlagPreservingFixture {
2269 LogTestHelper helper_;
2272TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
2273 GMOCK_FLAG(verbose) = kWarningVerbosity;
2274 EXPECT_CALL(helper_, Foo(_))
2275 .WillOnce(Return(PrintMeNot()));
2276 helper_.Foo(PrintMeNot());
2279TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
2280 GMOCK_FLAG(verbose) = kErrorVerbosity;
2281 EXPECT_CALL(helper_, Foo(_))
2282 .WillOnce(Return(PrintMeNot()));
2283 helper_.Foo(PrintMeNot());
2286TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
2287 GMOCK_FLAG(verbose) = kErrorVerbosity;
2288 ON_CALL(helper_, Foo(_))
2289 .WillByDefault(Return(PrintMeNot()));
2290 helper_.Foo(PrintMeNot());
2295TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
2296 MockA* a =
new MockA;
2300TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
2301 MockA* a =
new MockA;
2303 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2307TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
2308 MockA* a =
new MockA;
2309 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2313TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
2314 MockA* a =
new MockA;
2316 EXPECT_CALL(*a, DoA(_));
2320TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
2321 MockA* a =
new MockA;
2322 EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
2326TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
2327 MockA* a =
new MockA;
2328 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2329 EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
2335TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
2337 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2341 EXPECT_EQ(0, b.DoB());
2342 EXPECT_EQ(0, b.DoB(1));
2348TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
2350 EXPECT_CALL(b, DoB())
2351 .WillOnce(Return(1));
2353 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2357 EXPECT_EQ(0, b.DoB());
2358 EXPECT_EQ(0, b.DoB(1));
2364TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
2366 EXPECT_CALL(b, DoB())
2367 .WillOnce(Return(1));
2369 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
2370 "Actual: never called");
2371 ASSERT_FALSE(result);
2375 EXPECT_EQ(0, b.DoB());
2376 EXPECT_EQ(0, b.DoB(1));
2381TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
2383 EXPECT_CALL(b, DoB())
2384 .WillOnce(Return(1));
2385 EXPECT_CALL(b, DoB(_))
2386 .WillOnce(Return(2));
2389 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2393 EXPECT_EQ(0, b.DoB());
2394 EXPECT_EQ(0, b.DoB(1));
2399TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
2401 EXPECT_CALL(b, DoB(0))
2402 .WillOnce(Return(1));
2403 EXPECT_CALL(b, DoB(_))
2404 .WillOnce(Return(2));
2407 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
2408 "Actual: never called");
2409 ASSERT_FALSE(result);
2413 EXPECT_EQ(0, b.DoB());
2414 EXPECT_EQ(0, b.DoB(1));
2419TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
2421 EXPECT_CALL(b, DoB());
2423 Mock::VerifyAndClearExpectations(&b);
2425 EXPECT_CALL(b, DoB(_))
2426 .WillOnce(Return(1));
2428 Mock::VerifyAndClearExpectations(&b);
2429 Mock::VerifyAndClearExpectations(&b);
2433 EXPECT_EQ(0, b.DoB());
2434 EXPECT_EQ(0, b.DoB(1));
2439TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
2442 Mock::VerifyAndClear(&b);
2443 EXPECT_EQ(0, b.DoB());
2448TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
2451 .WillByDefault(Return(1));
2453 Mock::VerifyAndClear(&b);
2456 EXPECT_EQ(0, b.DoB());
2461TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
2464 .WillByDefault(Return(1));
2466 .WillByDefault(Return(2));
2468 Mock::VerifyAndClear(&b);
2471 EXPECT_EQ(0, b.DoB());
2474 EXPECT_EQ(0, b.DoB(0));
2479TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
2482 .WillByDefault(Return(1));
2484 .WillByDefault(Return(2));
2486 Mock::VerifyAndClear(&b);
2490 EXPECT_EQ(0, b.DoB(0));
2491 EXPECT_EQ(0, b.DoB(1));
2496TEST(VerifyAndClearTest, CanCallManyTimes) {
2499 .WillByDefault(Return(1));
2500 Mock::VerifyAndClear(&b);
2501 Mock::VerifyAndClear(&b);
2504 .WillByDefault(Return(1));
2505 Mock::VerifyAndClear(&b);
2507 EXPECT_EQ(0, b.DoB());
2508 EXPECT_EQ(0, b.DoB(1));
2512TEST(VerifyAndClearTest, Success) {
2515 .WillByDefault(Return(1));
2516 EXPECT_CALL(b, DoB(1))
2517 .WillOnce(Return(2));
2521 ASSERT_TRUE(Mock::VerifyAndClear(&b));
2525 EXPECT_EQ(0, b.DoB());
2526 EXPECT_EQ(0, b.DoB(1));
2530TEST(VerifyAndClearTest, Failure) {
2533 .WillByDefault(Return(1));
2534 EXPECT_CALL(b, DoB())
2535 .WillOnce(Return(2));
2539 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
2540 "Actual: never called");
2541 ASSERT_FALSE(result);
2545 EXPECT_EQ(0, b.DoB());
2546 EXPECT_EQ(0, b.DoB(1));
2551TEST(VerifyAndClearTest, Const) {
2553 ON_CALL(Const(b), DoB())
2554 .WillByDefault(Return(1));
2556 EXPECT_CALL(Const(b), DoB())
2557 .WillOnce(DoDefault())
2558 .WillOnce(Return(2));
2562 ASSERT_TRUE(Mock::VerifyAndClear(&b));
2566 EXPECT_EQ(0, b.DoB());
2567 EXPECT_EQ(0, b.DoB(1));
2572TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
2575 .WillByDefault(Return(1));
2576 EXPECT_CALL(b, DoB(_))
2577 .WillOnce(Return(2));
2580 Mock::VerifyAndClear(&b);
2582 EXPECT_CALL(b, DoB())
2583 .WillOnce(Return(3));
2585 .WillByDefault(Return(4));
2587 EXPECT_EQ(3, b.DoB());
2588 EXPECT_EQ(4, b.DoB(1));
2593TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
2598 ON_CALL(a, Binary(_, _))
2599 .WillByDefault(Return(
true));
2600 EXPECT_CALL(a, Binary(_, _))
2601 .WillOnce(DoDefault())
2602 .WillOnce(Return(
false));
2605 .WillByDefault(Return(1));
2606 EXPECT_CALL(b1, DoB(_))
2607 .WillOnce(Return(2));
2610 .WillByDefault(Return(3));
2611 EXPECT_CALL(b2, DoB(_));
2614 Mock::VerifyAndClear(&b2);
2618 EXPECT_TRUE(a.Binary(0, 0));
2619 EXPECT_FALSE(a.Binary(0, 0));
2621 EXPECT_EQ(1, b1.DoB());
2622 EXPECT_EQ(2, b1.DoB(0));
2625TEST(VerifyAndClearTest,
2626 DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
2627 std::shared_ptr<MockA> a(
new MockA);
2628 ReferenceHoldingMock test_mock;
2631 EXPECT_CALL(test_mock, AcceptReference(_))
2632 .WillRepeatedly(SetArgPointee<0>(a));
2645TEST(VerifyAndClearTest,
2646 DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
2647 std::shared_ptr<MockA> a(
new MockA);
2648 ReferenceHoldingMock test_mock;
2651 ON_CALL(test_mock, AcceptReference(_))
2652 .WillByDefault(SetArgPointee<0>(a));
2670TEST(SynchronizationTest, CanCallMockMethodInAction) {
2674 .WillByDefault(IgnoreResult(InvokeWithoutArgs(&c,
2675 &MockC::NonVoidMethod)));
2676 EXPECT_CALL(a, DoA(1));
2677 EXPECT_CALL(a, DoA(1))
2678 .WillOnce(Invoke(&a, &MockA::DoA))
2679 .RetiresOnSaturation();
2680 EXPECT_CALL(c, NonVoidMethod());
2689TEST(ParameterlessExpectationsTest, CanSetExpectationsWithoutMatchers) {
2692 ON_CALL(a, DoA).WillByDefault(SaveArg<0>(&do_a_arg0));
2693 int do_a_47_arg0 = 0;
2694 ON_CALL(a, DoA(47)).WillByDefault(SaveArg<0>(&do_a_47_arg0));
2697 EXPECT_THAT(do_a_arg0, 17);
2698 EXPECT_THAT(do_a_47_arg0, 0);
2700 EXPECT_THAT(do_a_arg0, 17);
2701 EXPECT_THAT(do_a_47_arg0, 47);
2703 ON_CALL(a, Binary).WillByDefault(Return(
true));
2704 ON_CALL(a, Binary(_, 14)).WillByDefault(Return(
false));
2705 EXPECT_THAT(a.Binary(14, 17),
true);
2706 EXPECT_THAT(a.Binary(17, 14),
false);
2709TEST(ParameterlessExpectationsTest, CanSetExpectationsForOverloadedMethods) {
2711 ON_CALL(b, DoB()).WillByDefault(Return(9));
2712 ON_CALL(b, DoB(5)).WillByDefault(Return(11));
2714 EXPECT_THAT(b.DoB(), 9);
2715 EXPECT_THAT(b.DoB(1), 0);
2716 EXPECT_THAT(b.DoB(5), 11);
2719struct MockWithConstMethods {
2721 MOCK_CONST_METHOD1(Foo,
int(
int));
2722 MOCK_CONST_METHOD2(Bar,
int(
int,
const char*));
2725TEST(ParameterlessExpectationsTest, CanSetExpectationsForConstMethods) {
2726 MockWithConstMethods mock;
2727 ON_CALL(mock, Foo).WillByDefault(Return(7));
2728 ON_CALL(mock, Bar).WillByDefault(Return(33));
2730 EXPECT_THAT(mock.Foo(17), 7);
2731 EXPECT_THAT(mock.Bar(27,
"purple"), 33);
2734class MockConstOverload {
2736 MOCK_METHOD1(Overloaded,
int(
int));
2737 MOCK_CONST_METHOD1(Overloaded,
int(
int));
2740TEST(ParameterlessExpectationsTest,
2741 CanSetExpectationsForConstOverloadedMethods) {
2742 MockConstOverload mock;
2743 ON_CALL(mock, Overloaded(_)).WillByDefault(Return(7));
2744 ON_CALL(mock, Overloaded(5)).WillByDefault(Return(9));
2745 ON_CALL(Const(mock), Overloaded(5)).WillByDefault(Return(11));
2746 ON_CALL(Const(mock), Overloaded(7)).WillByDefault(Return(13));
2748 EXPECT_THAT(mock.Overloaded(1), 7);
2749 EXPECT_THAT(mock.Overloaded(5), 9);
2750 EXPECT_THAT(mock.Overloaded(7), 7);
2752 const MockConstOverload& const_mock = mock;
2753 EXPECT_THAT(const_mock.Overloaded(1), 0);
2754 EXPECT_THAT(const_mock.Overloaded(5), 11);
2755 EXPECT_THAT(const_mock.Overloaded(7), 13);
2763#if GMOCK_RENAME_MAIN
2764int gmock_main(
int argc,
char **argv) {
2766int main(
int argc,
char **argv) {
2768 testing::InitGoogleMock(&argc, argv);
2771 testing::GMOCK_FLAG(catch_leaked_mocks) =
true;
2772 testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
2774 return RUN_ALL_TESTS();
Definition gtest-message.h:91
Definition gmock-nice-strict.h:179
Definition gmock-spec-builders_test.cc:52