34#include "gmock/gmock-spec-builders.h"
42#include "gmock/gmock.h"
43#include "gmock/internal/gmock-port.h"
44#include "gtest/gtest-spi.h"
45#include "gtest/gtest.h"
46#include "gtest/internal/gtest-port.h"
51using ::testing::internal::FormatFileLocation;
52using ::testing::internal::kAllow;
53using ::testing::internal::kErrorVerbosity;
54using ::testing::internal::kFail;
55using ::testing::internal::kInfoVerbosity;
56using ::testing::internal::kWarn;
57using ::testing::internal::kWarningVerbosity;
59#if GTEST_HAS_STREAM_REDIRECTION
60using ::testing::internal::CaptureStdout;
61using ::testing::internal::GetCapturedStdout;
70 MOCK_METHOD1(ByRefFunc,
void(
const Incomplete& x));
74void PrintTo(
const Incomplete& x, ::std::ostream* os);
76TEST(MockMethodTest, CanInstantiateWithIncompleteArgType) {
81 MockIncomplete incomplete;
82 EXPECT_CALL(incomplete, ByRefFunc(_)).Times(AnyNumber());
87void PrintTo(
const Incomplete& , ::std::ostream* os) {
94class NonDefaultConstructible {
96 explicit NonDefaultConstructible(
int ) {}
103 MOCK_METHOD1(DoA,
void(
int n));
104 MOCK_METHOD1(ReturnResult, Result(
int n));
105 MOCK_METHOD0(ReturnNonDefaultConstructible, NonDefaultConstructible());
106 MOCK_METHOD2(Binary,
bool(
int x,
int y));
107 MOCK_METHOD2(ReturnInt,
int(
int x,
int y));
110 MockA(
const MockA&) =
delete;
111 MockA& operator=(
const MockA&) =
delete;
118 MOCK_CONST_METHOD0(DoB,
int());
119 MOCK_METHOD1(DoB,
int(
int n));
122 MockB(
const MockB&) =
delete;
123 MockB& operator=(
const MockB&) =
delete;
126class ReferenceHoldingMock {
128 ReferenceHoldingMock() {}
130 MOCK_METHOD1(AcceptReference,
void(std::shared_ptr<MockA>*));
133 ReferenceHoldingMock(
const ReferenceHoldingMock&) =
delete;
134 ReferenceHoldingMock& operator=(
const ReferenceHoldingMock&) =
delete;
142#define Method MethodW
147 virtual int Method() = 0;
149class MockCC :
public CC {
153 MOCK_METHOD0(Method,
int());
156 MockCC(
const MockCC&) =
delete;
157 MockCC& operator=(
const MockCC&) =
delete;
161TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
163 ON_CALL(cc, Method());
168TEST(OnCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
170 ON_CALL(cc, Method()).WillByDefault(Return(42));
171 EXPECT_EQ(42, cc.Method());
175TEST(ExpectCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
177 EXPECT_CALL(cc, Method());
182TEST(ExpectCallSyntaxTest, WorksWithMethodNameExpandedFromMacro) {
184 EXPECT_CALL(cc, Method()).WillOnce(Return(42));
185 EXPECT_EQ(42, cc.Method());
192TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
196 ON_CALL(*pa++, DoA(_));
197 EXPECT_EQ(&a + 1, pa);
200TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
204 ON_CALL(a, DoA(n++));
210TEST(OnCallSyntaxTest, WithIsOptional) {
213 ON_CALL(a, DoA(5)).WillByDefault(Return());
214 ON_CALL(a, DoA(_)).With(_).WillByDefault(Return());
217TEST(OnCallSyntaxTest, WithCanAppearAtMostOnce) {
220 EXPECT_NONFATAL_FAILURE(
222 ON_CALL(a, ReturnResult(_))
225 .WillByDefault(Return(Result()));
227 ".With() cannot appear more than once in an ON_CALL()");
230TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
233 EXPECT_DEATH_IF_SUPPORTED(
241TEST(OnCallSyntaxTest, WillByDefaultCanAppearAtMostOnce) {
244 EXPECT_NONFATAL_FAILURE(
246 ON_CALL(a, DoA(5)).WillByDefault(Return()).WillByDefault(Return());
248 ".WillByDefault() must appear exactly once in an ON_CALL()");
253TEST(ExpectCallSyntaxTest, EvaluatesFirstArgumentOnce) {
257 EXPECT_CALL(*pa++, DoA(_));
259 EXPECT_EQ(&a + 1, pa);
262TEST(ExpectCallSyntaxTest, EvaluatesSecondArgumentOnce) {
266 EXPECT_CALL(a, DoA(n++));
273TEST(ExpectCallSyntaxTest, WithIsOptional) {
276 EXPECT_CALL(a, DoA(5)).Times(0);
277 EXPECT_CALL(a, DoA(6)).With(_).Times(0);
280TEST(ExpectCallSyntaxTest, WithCanAppearAtMostOnce) {
283 EXPECT_NONFATAL_FAILURE(
285 EXPECT_CALL(a, DoA(6)).With(_).With(_);
287 ".With() cannot appear more than once in an EXPECT_CALL()");
292TEST(ExpectCallSyntaxTest, WithMustBeFirstClause) {
295 EXPECT_NONFATAL_FAILURE(
297 EXPECT_CALL(a, DoA(1)).Times(1).With(_);
299 ".With() must be the first clause in an EXPECT_CALL()");
303 EXPECT_NONFATAL_FAILURE(
305 EXPECT_CALL(a, DoA(2)).WillOnce(Return()).With(_);
307 ".With() must be the first clause in an EXPECT_CALL()");
312TEST(ExpectCallSyntaxTest, TimesCanBeInferred) {
315 EXPECT_CALL(a, DoA(1)).WillOnce(Return());
317 EXPECT_CALL(a, DoA(2)).WillOnce(Return()).WillRepeatedly(Return());
324TEST(ExpectCallSyntaxTest, TimesCanAppearAtMostOnce) {
327 EXPECT_NONFATAL_FAILURE(
329 EXPECT_CALL(a, DoA(1)).Times(1).Times(2);
331 ".Times() cannot appear more than once in an EXPECT_CALL()");
337TEST(ExpectCallSyntaxTest, TimesMustBeBeforeInSequence) {
341 EXPECT_NONFATAL_FAILURE(
343 EXPECT_CALL(a, DoA(1)).InSequence(s).Times(1);
345 ".Times() may only appear *before* ");
350TEST(ExpectCallSyntaxTest, InSequenceIsOptional) {
354 EXPECT_CALL(a, DoA(1));
355 EXPECT_CALL(a, DoA(2)).InSequence(s);
361TEST(ExpectCallSyntaxTest, InSequenceCanAppearMultipleTimes) {
365 EXPECT_CALL(a, DoA(1)).InSequence(s1, s2).InSequence(s1);
370TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeAfter) {
374 Expectation e = EXPECT_CALL(a, DoA(1)).Times(AnyNumber());
375 EXPECT_NONFATAL_FAILURE(
377 EXPECT_CALL(a, DoA(2)).After(e).InSequence(s);
379 ".InSequence() cannot appear after ");
384TEST(ExpectCallSyntaxTest, InSequenceMustBeBeforeWillOnce) {
388 EXPECT_NONFATAL_FAILURE(
390 EXPECT_CALL(a, DoA(1)).WillOnce(Return()).InSequence(s);
392 ".InSequence() cannot appear after ");
397TEST(ExpectCallSyntaxTest, AfterMustBeBeforeWillOnce) {
400 Expectation e = EXPECT_CALL(a, DoA(1));
401 EXPECT_NONFATAL_FAILURE(
402 { EXPECT_CALL(a, DoA(2)).WillOnce(Return()).After(e); },
403 ".After() cannot appear after ");
409TEST(ExpectCallSyntaxTest, WillIsOptional) {
412 EXPECT_CALL(a, DoA(1));
413 EXPECT_CALL(a, DoA(2)).WillOnce(Return());
419TEST(ExpectCallSyntaxTest, WillCanAppearMultipleTimes) {
422 EXPECT_CALL(a, DoA(1))
429TEST(ExpectCallSyntaxTest, WillMustBeBeforeWillRepeatedly) {
432 EXPECT_NONFATAL_FAILURE(
434 EXPECT_CALL(a, DoA(1)).WillRepeatedly(Return()).WillOnce(Return());
436 ".WillOnce() cannot appear after ");
441TEST(ExpectCallSyntaxTest, WillRepeatedlyIsOptional) {
444 EXPECT_CALL(a, DoA(1)).WillOnce(Return());
445 EXPECT_CALL(a, DoA(2)).WillOnce(Return()).WillRepeatedly(Return());
452TEST(ExpectCallSyntaxTest, WillRepeatedlyCannotAppearMultipleTimes) {
455 EXPECT_NONFATAL_FAILURE(
457 EXPECT_CALL(a, DoA(1)).WillRepeatedly(Return()).WillRepeatedly(
460 ".WillRepeatedly() cannot appear more than once in an "
464TEST(ExpectCallSyntaxTest, WillRepeatedlyMustBeBeforeRetiresOnSaturation) {
467 EXPECT_NONFATAL_FAILURE(
469 EXPECT_CALL(a, DoA(1)).RetiresOnSaturation().WillRepeatedly(Return());
471 ".WillRepeatedly() cannot appear after ");
474TEST(ExpectCallSyntaxTest, RetiresOnSaturationIsOptional) {
477 EXPECT_CALL(a, DoA(1));
478 EXPECT_CALL(a, DoA(1)).RetiresOnSaturation();
484TEST(ExpectCallSyntaxTest, RetiresOnSaturationCannotAppearMultipleTimes) {
487 EXPECT_NONFATAL_FAILURE(
489 EXPECT_CALL(a, DoA(1)).RetiresOnSaturation().RetiresOnSaturation();
491 ".RetiresOnSaturation() cannot appear more than once");
496TEST(ExpectCallSyntaxTest, DefaultCardinalityIsOnce) {
499 EXPECT_CALL(a, DoA(1));
502 EXPECT_NONFATAL_FAILURE(
505 EXPECT_CALL(a, DoA(1));
507 "to be called once");
508 EXPECT_NONFATAL_FAILURE(
511 EXPECT_CALL(a, DoA(1));
515 "to be called once");
518#if GTEST_HAS_STREAM_REDIRECTION
522TEST(ExpectCallSyntaxTest, DoesNotWarnOnAdequateActionCount) {
528 EXPECT_CALL(b, DoB()).Times(0);
529 EXPECT_CALL(b, DoB(1)).Times(AtMost(1));
530 EXPECT_CALL(b, DoB(2)).Times(1).WillRepeatedly(Return(1));
533 EXPECT_CALL(b, DoB(3))
534 .Times(Between(1, 2))
536 .WillOnce(Return(2));
540 EXPECT_CALL(b, DoB(4)).Times(AtMost(3)).WillOnce(Return(1)).WillRepeatedly(
547 EXPECT_STREQ(
"", GetCapturedStdout().c_str());
552TEST(ExpectCallSyntaxTest, WarnsOnTooManyActions) {
558 EXPECT_CALL(b, DoB()).Times(0).WillOnce(Return(1));
559 EXPECT_CALL(b, DoB()).Times(AtMost(1)).WillOnce(Return(1)).WillOnce(
561 EXPECT_CALL(b, DoB(1))
565 .RetiresOnSaturation();
569 EXPECT_CALL(b, DoB()).Times(0).WillRepeatedly(Return(1));
570 EXPECT_CALL(b, DoB(2)).Times(1).WillOnce(Return(1)).WillRepeatedly(
577 const std::string output = GetCapturedStdout();
578 EXPECT_PRED_FORMAT2(IsSubstring,
579 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
580 "Expected to be never called, but has 1 WillOnce().",
582 EXPECT_PRED_FORMAT2(IsSubstring,
583 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
584 "Expected to be called at most once, "
585 "but has 2 WillOnce()s.",
589 "Too many actions specified in EXPECT_CALL(b, DoB(1))...\n"
590 "Expected to be called once, but has 2 WillOnce()s.",
592 EXPECT_PRED_FORMAT2(IsSubstring,
593 "Too many actions specified in EXPECT_CALL(b, DoB())...\n"
594 "Expected to be never called, but has 0 WillOnce()s "
595 "and a WillRepeatedly().",
599 "Too many actions specified in EXPECT_CALL(b, DoB(2))...\n"
600 "Expected to be called once, but has 1 WillOnce() "
601 "and a WillRepeatedly().",
607TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
610 EXPECT_CALL(b, DoB()).Times(Between(2, 3)).WillOnce(Return(1));
614 const std::string output = GetCapturedStdout();
615 EXPECT_PRED_FORMAT2(IsSubstring,
616 "Too few actions specified in EXPECT_CALL(b, DoB())...\n"
617 "Expected to be called between 2 and 3 times, "
618 "but has only 1 WillOnce().",
623TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
624 int original_behavior = GMOCK_FLAG_GET(default_mock_behavior);
626 GMOCK_FLAG_SET(default_mock_behavior, kAllow);
632 std::string output = GetCapturedStdout();
633 EXPECT_TRUE(output.empty()) << output;
635 GMOCK_FLAG_SET(default_mock_behavior, kWarn);
641 std::string warning_output = GetCapturedStdout();
642 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
643 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
646 GMOCK_FLAG_SET(default_mock_behavior, kFail);
647 EXPECT_NONFATAL_FAILURE(
652 "Uninteresting mock function call");
655 GMOCK_FLAG_SET(default_mock_behavior, -1);
661 warning_output = GetCapturedStdout();
662 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
663 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
665 GMOCK_FLAG_SET(default_mock_behavior, 3);
671 warning_output = GetCapturedStdout();
672 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", warning_output);
673 EXPECT_PRED_FORMAT2(IsSubstring,
"Uninteresting mock function call",
676 GMOCK_FLAG_SET(default_mock_behavior, original_behavior);
685TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCall) {
687 EXPECT_CALL(b, DoB());
689 EXPECT_EQ(0, b.DoB());
694TEST(OnCallTest, TakesBuiltInDefaultActionWhenNoOnCallMatches) {
696 ON_CALL(b, DoB(1)).WillByDefault(Return(1));
697 EXPECT_CALL(b, DoB(_));
699 EXPECT_EQ(0, b.DoB(2));
703TEST(OnCallTest, PicksLastMatchingOnCall) {
705 ON_CALL(b, DoB(_)).WillByDefault(Return(3));
706 ON_CALL(b, DoB(2)).WillByDefault(Return(2));
707 ON_CALL(b, DoB(1)).WillByDefault(Return(1));
708 EXPECT_CALL(b, DoB(_));
710 EXPECT_EQ(2, b.DoB(2));
716TEST(ExpectCallTest, AllowsAnyCallWhenNoSpec) {
718 EXPECT_CALL(b, DoB());
729TEST(ExpectCallTest, PicksLastMatchingExpectCall) {
731 EXPECT_CALL(b, DoB(_)).WillRepeatedly(Return(2));
732 EXPECT_CALL(b, DoB(1)).WillRepeatedly(Return(1));
734 EXPECT_EQ(1, b.DoB(1));
738TEST(ExpectCallTest, CatchesTooFewCalls) {
739 EXPECT_NONFATAL_FAILURE(
742 EXPECT_CALL(b, DoB(5)).Times(AtLeast(2));
746 "Actual function call count doesn't match EXPECT_CALL(b, DoB(5))...\n"
747 " Expected: to be called at least twice\n"
748 " Actual: called once - unsatisfied and active");
753TEST(ExpectCallTest, InfersCardinalityWhenThereIsNoWillRepeatedly) {
756 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
758 EXPECT_EQ(1, b.DoB());
759 EXPECT_EQ(2, b.DoB());
762 EXPECT_NONFATAL_FAILURE(
765 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
767 EXPECT_EQ(1, b.DoB());
769 "to be called twice");
773 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2));
775 EXPECT_EQ(1, b.DoB());
776 EXPECT_EQ(2, b.DoB());
777 EXPECT_NONFATAL_FAILURE(b.DoB(),
"to be called twice");
781TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
784 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
786 EXPECT_EQ(1, b.DoB());
791 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
793 EXPECT_EQ(1, b.DoB());
794 EXPECT_EQ(2, b.DoB());
795 EXPECT_EQ(2, b.DoB());
798 EXPECT_NONFATAL_FAILURE(
801 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
803 "to be called at least once");
806#if defined(__cplusplus) && __cplusplus >= 201703L
811TEST(ExpectCallTest, NonMoveableType) {
814 explicit Result(
int x_in) : x(x_in) {}
815 Result(Result&&) =
delete;
820 static_assert(!std::is_move_constructible_v<Result>);
821 static_assert(!std::is_copy_constructible_v<Result>);
823 static_assert(!std::is_move_assignable_v<Result>);
824 static_assert(!std::is_copy_assignable_v<Result>);
828 const auto return_17 = [] {
return Result(17); };
830 static_cast<void>(OnceAction<Result()>{return_17});
831 static_cast<void>(Action<Result()>{return_17});
833 static_cast<void>(OnceAction<Result(
int)>{return_17});
834 static_cast<void>(Action<Result(
int)>{return_17});
838 MockFunction<Result()> mock;
839 EXPECT_CALL(mock, Call)
841 .WillRepeatedly(return_17);
843 EXPECT_EQ(17, mock.AsStdFunction()().x);
844 EXPECT_EQ(17, mock.AsStdFunction()().x);
845 EXPECT_EQ(17, mock.AsStdFunction()().x);
852TEST(ExpectCallTest, NthMatchTakesNthAction) {
854 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillOnce(Return(2)).WillOnce(
857 EXPECT_EQ(1, b.DoB());
858 EXPECT_EQ(2, b.DoB());
859 EXPECT_EQ(3, b.DoB());
864TEST(ExpectCallTest, TakesRepeatedActionWhenWillListIsExhausted) {
866 EXPECT_CALL(b, DoB()).WillOnce(Return(1)).WillRepeatedly(Return(2));
868 EXPECT_EQ(1, b.DoB());
869 EXPECT_EQ(2, b.DoB());
870 EXPECT_EQ(2, b.DoB());
873#if GTEST_HAS_STREAM_REDIRECTION
877TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
879 EXPECT_CALL(b, DoB(_)).Times(1);
880 EXPECT_CALL(b, DoB())
883 .WillOnce(Return(2));
886 EXPECT_EQ(0, b.DoB(1));
888 EXPECT_EQ(1, b.DoB());
889 EXPECT_EQ(2, b.DoB());
890 const std::string output1 = GetCapturedStdout();
891 EXPECT_STREQ(
"", output1.c_str());
894 EXPECT_EQ(0, b.DoB());
895 EXPECT_EQ(0, b.DoB());
896 const std::string output2 = GetCapturedStdout();
897 EXPECT_THAT(output2.c_str(),
898 HasSubstr(
"Actions ran out in EXPECT_CALL(b, DoB())...\n"
899 "Called 3 times, but only 2 WillOnce()s are specified"
900 " - returning default value."));
901 EXPECT_THAT(output2.c_str(),
902 HasSubstr(
"Actions ran out in EXPECT_CALL(b, DoB())...\n"
903 "Called 4 times, but only 2 WillOnce()s are specified"
904 " - returning default value."));
907TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
909 std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
910 EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
912 EXPECT_EQ(1, b.DoB());
915 EXPECT_EQ(0, b.DoB());
916 const std::string output = GetCapturedStdout();
918 EXPECT_PRED_FORMAT2(IsSubstring, expect_call_location, output);
921TEST(FunctionMockerMessageTest,
922 ReportsDefaultActionLocationOfUninterestingCallsForNaggyMock) {
923 std::string on_call_location;
927 on_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
928 ON_CALL(b, DoB(_)).WillByDefault(Return(0));
931 EXPECT_PRED_FORMAT2(IsSubstring, on_call_location, GetCapturedStdout());
937TEST(UninterestingCallTest, DoesDefaultAction) {
941 ON_CALL(a, Binary(_, _)).WillByDefault(Return(
true));
942 EXPECT_TRUE(a.Binary(1, 2));
947 EXPECT_EQ(0, b.DoB());
951TEST(UnexpectedCallTest, DoesDefaultAction) {
955 ON_CALL(a, Binary(_, _)).WillByDefault(Return(
true));
956 EXPECT_CALL(a, Binary(0, 0));
959 EXPECT_NONFATAL_FAILURE(result = a.Binary(1, 2),
960 "Unexpected mock function call");
966 EXPECT_CALL(b, DoB(0)).Times(0);
968 EXPECT_NONFATAL_FAILURE(n = b.DoB(1),
"Unexpected mock function call");
974TEST(UnexpectedCallTest, GeneratesFailureForVoidFunction) {
977 EXPECT_CALL(a1, DoA(1));
982 EXPECT_NONFATAL_FAILURE(
984 "Unexpected mock function call - returning directly.\n"
985 " Function call: DoA(9)\n"
986 "Google Mock tried the following 1 expectation, but it didn't match:");
987 EXPECT_NONFATAL_FAILURE(
989 " Expected arg #0: is equal to 1\n"
991 " Expected: to be called once\n"
992 " Actual: called once - saturated and active");
996 EXPECT_CALL(a2, DoA(1));
997 EXPECT_CALL(a2, DoA(3));
999 EXPECT_NONFATAL_FAILURE(
1001 "Unexpected mock function call - returning directly.\n"
1002 " Function call: DoA(2)\n"
1003 "Google Mock tried the following 2 expectations, but none matched:");
1004 EXPECT_NONFATAL_FAILURE(
1006 "tried expectation #0: EXPECT_CALL(a2, DoA(1))...\n"
1007 " Expected arg #0: is equal to 1\n"
1009 " Expected: to be called once\n"
1010 " Actual: called once - saturated and active");
1011 EXPECT_NONFATAL_FAILURE(
1013 "tried expectation #1: EXPECT_CALL(a2, DoA(3))...\n"
1014 " Expected arg #0: is equal to 3\n"
1016 " Expected: to be called once\n"
1017 " Actual: never called - unsatisfied and active");
1023TEST(UnexpectedCallTest, GeneartesFailureForNonVoidFunction) {
1025 EXPECT_CALL(b1, DoB(1));
1027 EXPECT_NONFATAL_FAILURE(
1029 "Unexpected mock function call - returning default value.\n"
1030 " Function call: DoB(2)\n"
1032 "Google Mock tried the following 1 expectation, but it didn't match:");
1033 EXPECT_NONFATAL_FAILURE(
1035 " Expected arg #0: is equal to 1\n"
1037 " Expected: to be called once\n"
1038 " Actual: called once - saturated and active");
1043TEST(UnexpectedCallTest, RetiredExpectation) {
1045 EXPECT_CALL(b, DoB(1)).RetiresOnSaturation();
1048 EXPECT_NONFATAL_FAILURE(b.DoB(1),
1049 " Expected: the expectation is active\n"
1050 " Actual: it is retired");
1055TEST(UnexpectedCallTest, UnmatchedArguments) {
1057 EXPECT_CALL(b, DoB(1));
1059 EXPECT_NONFATAL_FAILURE(b.DoB(2),
1060 " Expected arg #0: is equal to 1\n"
1067TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) {
1070 EXPECT_CALL(b, DoB(1)).InSequence(s1);
1071 EXPECT_CALL(b, DoB(2)).Times(AnyNumber()).InSequence(s1);
1072 EXPECT_CALL(b, DoB(3)).InSequence(s2);
1073 EXPECT_CALL(b, DoB(4)).InSequence(s1, s2);
1075 ::testing::TestPartResultArray failures;
1077 ::testing::ScopedFakeTestPartResultReporter reporter(&failures);
1084 ASSERT_EQ(1, failures.size());
1085 const ::testing::TestPartResult& r = failures.GetTestPartResult(0);
1086 EXPECT_EQ(::testing::TestPartResult::kNonFatalFailure, r.type());
1096 "(?s)the following immediate pre-requisites are not satisfied:\n"
1097 ".*: pre-requisite #0\n"
1098 ".*: pre-requisite #1"));
1099#elif GTEST_USES_POSIX_RE
1100 EXPECT_THAT(r.message(),
1104 "the following immediate pre-requisites are not satisfied:\n"
1105 "(.|\n)*: pre-requisite #0\n"
1106 "(.|\n)*: pre-requisite #1"));
1109 EXPECT_THAT(r.message(),
1111 "the following immediate pre-requisites are not satisfied:"));
1112 EXPECT_THAT(r.message(), ContainsRegex(
": pre-requisite #0"));
1113 EXPECT_THAT(r.message(), ContainsRegex(
": pre-requisite #1"));
1121TEST(UndefinedReturnValueTest,
1122 ReturnValueIsMandatoryWhenNotDefaultConstructible) {
1127#if GTEST_HAS_EXCEPTIONS
1128 EXPECT_ANY_THROW(a.ReturnNonDefaultConstructible());
1130 EXPECT_DEATH_IF_SUPPORTED(a.ReturnNonDefaultConstructible(),
"");
1136TEST(ExcessiveCallTest, DoesDefaultAction) {
1140 ON_CALL(a, Binary(_, _)).WillByDefault(Return(
true));
1141 EXPECT_CALL(a, Binary(0, 0));
1143 bool result =
false;
1144 EXPECT_NONFATAL_FAILURE(result = a.Binary(0, 0),
1145 "Mock function called more times than expected");
1146 EXPECT_TRUE(result);
1151 EXPECT_CALL(b, DoB(0)).Times(0);
1153 EXPECT_NONFATAL_FAILURE(n = b.DoB(0),
1154 "Mock function called more times than expected");
1160TEST(ExcessiveCallTest, GeneratesFailureForVoidFunction) {
1162 EXPECT_CALL(a, DoA(_)).Times(0);
1163 EXPECT_NONFATAL_FAILURE(
1165 "Mock function called more times than expected - returning directly.\n"
1166 " Function call: DoA(9)\n"
1167 " Expected: to be never called\n"
1168 " Actual: called once - over-saturated and active");
1173TEST(ExcessiveCallTest, GeneratesFailureForNonVoidFunction) {
1175 EXPECT_CALL(b, DoB(_));
1177 EXPECT_NONFATAL_FAILURE(
1179 "Mock function called more times than expected - "
1180 "returning default value.\n"
1181 " Function call: DoB(2)\n"
1183 " Expected: to be called once\n"
1184 " Actual: called twice - over-saturated and active");
1189TEST(InSequenceTest, AllExpectationInScopeAreInSequence) {
1194 EXPECT_CALL(a, DoA(1));
1195 EXPECT_CALL(a, DoA(2));
1198 EXPECT_NONFATAL_FAILURE(
1202 "Unexpected mock function call");
1208TEST(InSequenceTest, NestedInSequence) {
1213 EXPECT_CALL(a, DoA(1));
1217 EXPECT_CALL(a, DoA(2));
1218 EXPECT_CALL(a, DoA(3));
1222 EXPECT_NONFATAL_FAILURE(
1227 "Unexpected mock function call");
1233TEST(InSequenceTest, ExpectationsOutOfScopeAreNotAffected) {
1238 EXPECT_CALL(a, DoA(1));
1239 EXPECT_CALL(a, DoA(2));
1241 EXPECT_CALL(a, DoA(3));
1243 EXPECT_NONFATAL_FAILURE(
1247 "Unexpected mock function call");
1255TEST(SequenceTest, AnyOrderIsOkByDefault) {
1260 EXPECT_CALL(a, DoA(1));
1261 EXPECT_CALL(b, DoB()).Times(AnyNumber());
1271 EXPECT_CALL(a, DoA(1));
1272 EXPECT_CALL(b, DoB()).Times(AnyNumber());
1281TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo1) {
1283 ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
1286 EXPECT_CALL(a, ReturnResult(1)).InSequence(s);
1287 EXPECT_CALL(a, ReturnResult(2)).InSequence(s);
1288 EXPECT_CALL(a, ReturnResult(3)).InSequence(s);
1293 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1301TEST(SequenceTest, CallsMustBeInStrictOrderWhenSaidSo2) {
1303 ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
1306 EXPECT_CALL(a, ReturnResult(1)).InSequence(s);
1307 EXPECT_CALL(a, ReturnResult(2)).InSequence(s);
1310 EXPECT_NONFATAL_FAILURE(a.ReturnResult(2),
"Unexpected mock function call");
1319 PartialOrderTest() {
1320 ON_CALL(a_, ReturnResult(_)).WillByDefault(Return(Result()));
1328 EXPECT_CALL(a_, ReturnResult(1)).InSequence(x);
1329 EXPECT_CALL(b_, DoB()).Times(2).InSequence(y);
1330 EXPECT_CALL(a_, ReturnResult(2)).Times(AnyNumber()).InSequence(x, y);
1331 EXPECT_CALL(a_, ReturnResult(3)).InSequence(x);
1338TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag1) {
1343 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1349TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag2) {
1351 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1359TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag3) {
1361 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(3),
"Unexpected mock function call");
1369TEST_F(PartialOrderTest, CallsMustConformToSpecifiedDag4) {
1376 EXPECT_NONFATAL_FAILURE(a_.ReturnResult(2),
"Unexpected mock function call");
1379TEST(SequenceTest, Retirement) {
1383 EXPECT_CALL(a, DoA(1)).InSequence(s);
1384 EXPECT_CALL(a, DoA(_)).InSequence(s).RetiresOnSaturation();
1385 EXPECT_CALL(a, DoA(1)).InSequence(s);
1394TEST(ExpectationTest, ConstrutorsWork) {
1399 Expectation e2 = EXPECT_CALL(a, DoA(2));
1400 Expectation e3 = EXPECT_CALL(a, DoA(3)).With(_);
1403 Expectation e4 = EXPECT_CALL(a, DoA(4)).Times(1);
1404 Expectation e5 = EXPECT_CALL(a, DoA(5)).InSequence(s);
1406 Expectation e6 = EXPECT_CALL(a, DoA(6)).After(e2);
1407 Expectation e7 = EXPECT_CALL(a, DoA(7)).WillOnce(Return());
1408 Expectation e8 = EXPECT_CALL(a, DoA(8)).WillRepeatedly(Return());
1409 Expectation e9 = EXPECT_CALL(a, DoA(9)).RetiresOnSaturation();
1411 Expectation e10 = e2;
1413 EXPECT_THAT(e1, Ne(e2));
1414 EXPECT_THAT(e2, Eq(e10));
1426TEST(ExpectationTest, AssignmentWorks) {
1429 Expectation e2 = EXPECT_CALL(a, DoA(1));
1431 EXPECT_THAT(e1, Ne(e2));
1434 EXPECT_THAT(e1, Eq(e2));
1441TEST(ExpectationSetTest, MemberTypesAreCorrect) {
1442 ::testing::StaticAssertTypeEq<Expectation, ExpectationSet::value_type>();
1445TEST(ExpectationSetTest, ConstructorsWork) {
1449 const Expectation e2;
1451 ExpectationSet es2 = EXPECT_CALL(a, DoA(1));
1452 ExpectationSet es3 = e1;
1453 ExpectationSet es4(e1);
1454 ExpectationSet es5 = e2;
1455 ExpectationSet es6(e2);
1456 ExpectationSet es7 = es2;
1458 EXPECT_EQ(0, es1.size());
1459 EXPECT_EQ(1, es2.size());
1460 EXPECT_EQ(1, es3.size());
1461 EXPECT_EQ(1, es4.size());
1462 EXPECT_EQ(1, es5.size());
1463 EXPECT_EQ(1, es6.size());
1464 EXPECT_EQ(1, es7.size());
1466 EXPECT_THAT(es3, Ne(es2));
1467 EXPECT_THAT(es4, Eq(es3));
1468 EXPECT_THAT(es5, Eq(es4));
1469 EXPECT_THAT(es6, Eq(es5));
1470 EXPECT_THAT(es7, Eq(es2));
1474TEST(ExpectationSetTest, AssignmentWorks) {
1476 ExpectationSet es2 = Expectation();
1479 EXPECT_EQ(1, es1.size());
1480 EXPECT_THAT(*(es1.begin()), Eq(Expectation()));
1481 EXPECT_THAT(es1, Eq(es2));
1484TEST(ExpectationSetTest, InsertionWorks) {
1488 EXPECT_EQ(1, es1.size());
1489 EXPECT_THAT(*(es1.begin()), Eq(e1));
1492 Expectation e2 = EXPECT_CALL(a, DoA(1));
1494 EXPECT_EQ(2, es1.size());
1496 ExpectationSet::const_iterator it1 = es1.begin();
1497 ExpectationSet::const_iterator it2 = it1;
1499 EXPECT_TRUE(*it1 == e1 || *it2 == e1);
1500 EXPECT_TRUE(*it1 == e2 || *it2 == e2);
1504TEST(ExpectationSetTest, SizeWorks) {
1506 EXPECT_EQ(0, es.size());
1508 es += Expectation();
1509 EXPECT_EQ(1, es.size());
1512 es += EXPECT_CALL(a, DoA(1));
1513 EXPECT_EQ(2, es.size());
1518TEST(ExpectationSetTest, IsEnumerable) {
1520 EXPECT_TRUE(es.begin() == es.end());
1522 es += Expectation();
1523 ExpectationSet::const_iterator it = es.begin();
1524 EXPECT_TRUE(it != es.end());
1525 EXPECT_THAT(*it, Eq(Expectation()));
1527 EXPECT_TRUE(it == es.end());
1532TEST(AfterTest, SucceedsWhenPartialOrderIsSatisfied) {
1535 es += EXPECT_CALL(a, DoA(1));
1536 es += EXPECT_CALL(a, DoA(2));
1537 EXPECT_CALL(a, DoA(3)).After(es);
1544TEST(AfterTest, SucceedsWhenTotalOrderIsSatisfied) {
1549 const Expectation e1 = EXPECT_CALL(a, DoA(1));
1550 const Expectation e2 = EXPECT_CALL(b, DoB()).Times(2).After(e1);
1551 EXPECT_CALL(a, DoA(2)).After(e2);
1560TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo1) {
1566 Expectation e1 = EXPECT_CALL(a, DoA(1));
1567 Expectation e2 = EXPECT_CALL(b, DoB()).After(e1);
1568 EXPECT_CALL(a, DoA(2)).After(e2);
1573 EXPECT_NONFATAL_FAILURE(a.DoA(2),
"Unexpected mock function call");
1580TEST(AfterTest, CallsMustBeInStrictOrderWhenSpecifiedSo2) {
1586 Expectation e1 = EXPECT_CALL(a, DoA(1));
1587 Expectation e2 = EXPECT_CALL(b, DoB()).Times(2).After(e1);
1588 EXPECT_CALL(a, DoA(2)).After(e2);
1594 EXPECT_NONFATAL_FAILURE(a.DoA(2),
"Unexpected mock function call");
1601TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo) {
1603 ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
1608 Expectation e = EXPECT_CALL(a, DoA(1));
1609 const ExpectationSet es = EXPECT_CALL(a, DoA(2));
1610 EXPECT_CALL(a, ReturnResult(3)).After(e, es);
1613 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1621TEST(AfterTest, CallsMustSatisfyPartialOrderWhenSpecifiedSo2) {
1627 Expectation e = EXPECT_CALL(a, DoA(1));
1628 const ExpectationSet es = EXPECT_CALL(a, DoA(2));
1629 EXPECT_CALL(a, DoA(3)).After(e, es);
1634 EXPECT_NONFATAL_FAILURE(a.DoA(3),
"Unexpected mock function call");
1641TEST(AfterTest, CanBeUsedWithInSequence) {
1644 Expectation e = EXPECT_CALL(a, DoA(1));
1645 EXPECT_CALL(a, DoA(2)).InSequence(s);
1646 EXPECT_CALL(a, DoA(3)).InSequence(s).After(e);
1651 EXPECT_NONFATAL_FAILURE(a.DoA(3),
"Unexpected mock function call");
1658TEST(AfterTest, CanBeCalledManyTimes) {
1660 Expectation e1 = EXPECT_CALL(a, DoA(1));
1661 Expectation e2 = EXPECT_CALL(a, DoA(2));
1662 Expectation e3 = EXPECT_CALL(a, DoA(3));
1663 EXPECT_CALL(a, DoA(4)).After(e1).After(e2).After(e3);
1672TEST(AfterTest, AcceptsUpToFiveArguments) {
1674 Expectation e1 = EXPECT_CALL(a, DoA(1));
1675 Expectation e2 = EXPECT_CALL(a, DoA(2));
1676 Expectation e3 = EXPECT_CALL(a, DoA(3));
1677 ExpectationSet es1 = EXPECT_CALL(a, DoA(4));
1678 ExpectationSet es2 = EXPECT_CALL(a, DoA(5));
1679 EXPECT_CALL(a, DoA(6)).After(e1, e2, e3, es1, es2);
1690TEST(AfterTest, AcceptsDuplicatedInput) {
1692 ON_CALL(a, ReturnResult(_)).WillByDefault(Return(Result()));
1697 Expectation e1 = EXPECT_CALL(a, DoA(1));
1698 Expectation e2 = EXPECT_CALL(a, DoA(2));
1702 EXPECT_CALL(a, ReturnResult(3)).After(e1, e2, es, e1);
1707 EXPECT_NONFATAL_FAILURE(a.ReturnResult(3),
"Unexpected mock function call");
1715TEST(AfterTest, ChangesToExpectationSetHaveNoEffectAfterwards) {
1717 ExpectationSet es1 = EXPECT_CALL(a, DoA(1));
1718 Expectation e2 = EXPECT_CALL(a, DoA(2));
1719 EXPECT_CALL(a, DoA(3)).After(es1);
1731TEST(DeletingMockEarlyTest, Success1) {
1732 MockB*
const b1 =
new MockB;
1733 MockA*
const a =
new MockA;
1734 MockB*
const b2 =
new MockB;
1738 EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
1739 EXPECT_CALL(*a, Binary(_, _))
1741 .WillRepeatedly(Return(
true));
1742 EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
1745 EXPECT_EQ(1, b1->DoB(1));
1748 EXPECT_TRUE(a->Binary(0, 1));
1751 EXPECT_TRUE(a->Binary(1, 2));
1756TEST(DeletingMockEarlyTest, Success2) {
1757 MockB*
const b1 =
new MockB;
1758 MockA*
const a =
new MockA;
1759 MockB*
const b2 =
new MockB;
1763 EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
1764 EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
1765 EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
1769 EXPECT_EQ(1, b1->DoB(1));
1770 EXPECT_EQ(2, b2->DoB(2));
1780#pragma warning(push)
1781#pragma warning(disable : 4100)
1784ACTION_P(Delete, ptr) {
delete ptr; }
1790TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
1791 MockA*
const a =
new MockA;
1792 EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
1796TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningValue) {
1797 MockA*
const a =
new MockA;
1798 EXPECT_CALL(*a, ReturnResult(_)).WillOnce(DoAll(Delete(a), Return(Result())));
1799 a->ReturnResult(42);
1803TEST(DeletingMockEarlyTest, Failure1) {
1804 MockB*
const b1 =
new MockB;
1805 MockA*
const a =
new MockA;
1806 MockB*
const b2 =
new MockB;
1810 EXPECT_CALL(*b1, DoB(_)).WillOnce(Return(1));
1811 EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
1812 EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber()).WillRepeatedly(Return(2));
1816 EXPECT_NONFATAL_FAILURE({ b2->DoB(2); },
"Unexpected mock function call");
1817 EXPECT_EQ(1, b1->DoB(1));
1823TEST(DeletingMockEarlyTest, Failure2) {
1824 MockB*
const b1 =
new MockB;
1825 MockA*
const a =
new MockA;
1826 MockB*
const b2 =
new MockB;
1830 EXPECT_CALL(*b1, DoB(_));
1831 EXPECT_CALL(*a, Binary(_, _)).Times(AnyNumber());
1832 EXPECT_CALL(*b2, DoB(_)).Times(AnyNumber());
1835 EXPECT_NONFATAL_FAILURE(
delete b1,
"Actual: never called");
1836 EXPECT_NONFATAL_FAILURE(a->Binary(0, 1),
"Unexpected mock function call");
1837 EXPECT_NONFATAL_FAILURE(b2->DoB(1),
"Unexpected mock function call");
1842class EvenNumberCardinality :
public CardinalityInterface {
1846 bool IsSatisfiedByCallCount(
int call_count)
const override {
1847 return call_count % 2 == 0;
1852 bool IsSaturatedByCallCount(
int )
const override {
1857 void DescribeTo(::std::ostream* os)
const override {
1858 *os <<
"called even number of times";
1862Cardinality EvenNumber() {
return Cardinality(
new EvenNumberCardinality); }
1864TEST(ExpectationBaseTest,
1865 AllPrerequisitesAreSatisfiedWorksForNonMonotonicCardinality) {
1866 MockA* a =
new MockA;
1869 EXPECT_CALL(*a, DoA(1)).Times(EvenNumber()).InSequence(s);
1870 EXPECT_CALL(*a, DoA(2)).Times(AnyNumber()).InSequence(s);
1871 EXPECT_CALL(*a, DoA(3)).Times(AnyNumber());
1875 EXPECT_NONFATAL_FAILURE(a->DoA(2),
"Unexpected mock function call");
1876 EXPECT_NONFATAL_FAILURE(
delete a,
"to be called even number of times");
1884inline void operator<<(::std::ostream& os,
const Printable&) {
1889 Unprintable() : value(0) {}
1897 MOCK_METHOD6(VoidMethod,
void(
bool cond,
int n, std::string s,
void* p,
1898 const Printable& x, Unprintable y));
1899 MOCK_METHOD0(NonVoidMethod,
int());
1902 MockC(
const MockC&) =
delete;
1903 MockC& operator=(
const MockC&) =
delete;
1908 VerboseFlagPreservingFixture()
1909 : saved_verbose_flag_(GMOCK_FLAG_GET(verbose)) {}
1911 ~VerboseFlagPreservingFixture()
override {
1912 GMOCK_FLAG_SET(verbose, saved_verbose_flag_);
1916 const std::string saved_verbose_flag_;
1918 VerboseFlagPreservingFixture(
const VerboseFlagPreservingFixture&) =
delete;
1919 VerboseFlagPreservingFixture& operator=(
const VerboseFlagPreservingFixture&) =
1923#if GTEST_HAS_STREAM_REDIRECTION
1928TEST(FunctionCallMessageTest,
1929 UninterestingCallOnNaggyMockGeneratesNoStackTraceWhenVerboseWarning) {
1930 GMOCK_FLAG_SET(verbose, kWarningVerbosity);
1933 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
1934 const std::string output = GetCapturedStdout();
1935 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", output);
1936 EXPECT_PRED_FORMAT2(IsNotSubstring,
"Stack trace:", output);
1942TEST(FunctionCallMessageTest,
1943 UninterestingCallOnNaggyMockGeneratesFyiWithStackTraceWhenVerboseInfo) {
1944 GMOCK_FLAG_SET(verbose, kInfoVerbosity);
1947 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
1948 const std::string output = GetCapturedStdout();
1949 EXPECT_PRED_FORMAT2(IsSubstring,
"GMOCK WARNING", output);
1950 EXPECT_PRED_FORMAT2(IsSubstring,
"Stack trace:", output);
1959 EXPECT_PRED_FORMAT2(IsSubstring,
"VoidMethod(", output);
1965 const std::string output2 = GetCapturedStdout();
1966 EXPECT_PRED_FORMAT2(IsSubstring,
"NonVoidMethod(", output2);
1973TEST(FunctionCallMessageTest,
1974 UninterestingCallOnNaggyMockPrintsArgumentsAndReturnValue) {
1979 const std::string output1 = GetCapturedStdout();
1980 EXPECT_PRED_FORMAT2(
1982 "Uninteresting mock function call - returning default value.\n"
1983 " Function call: DoB()\n"
1991 c.VoidMethod(
false, 5,
"Hi",
nullptr, Printable(), Unprintable());
1992 const std::string output2 = GetCapturedStdout();
1995 ContainsRegex(
"Uninteresting mock function call - returning directly\\.\n"
1996 " Function call: VoidMethod"
1997 "\\(false, 5, \"Hi\", NULL, @.+ "
1998 "Printable, 4-byte object <00-00 00-00>\\)"));
2004class GMockVerboseFlagTest :
public VerboseFlagPreservingFixture {
2010 void VerifyOutput(
const std::string& output,
bool should_print,
2011 const std::string& expected_substring,
2012 const std::string& function_name) {
2014 EXPECT_THAT(output.c_str(), HasSubstr(expected_substring));
2018 EXPECT_THAT(output.c_str(), HasSubstr(function_name));
2021 static_cast<void>(function_name);
2024 EXPECT_STREQ(
"", output.c_str());
2029 void TestExpectedCall(
bool should_print) {
2031 EXPECT_CALL(a, DoA(5));
2032 EXPECT_CALL(a, Binary(_, 1)).WillOnce(Return(
true));
2037 VerifyOutput(GetCapturedStdout(), should_print,
2038 "Mock function call matches EXPECT_CALL(a, DoA(5))...\n"
2039 " Function call: DoA(5)\n"
2046 VerifyOutput(GetCapturedStdout(), should_print,
2047 "Mock function call matches EXPECT_CALL(a, Binary(_, 1))...\n"
2048 " Function call: Binary(2, 1)\n"
2055 void TestUninterestingCallOnNaggyMock(
bool should_print) {
2057 const std::string note =
2058 "NOTE: You can safely ignore the above warning unless this "
2059 "call should not happen. Do not suppress it by blindly adding "
2060 "an EXPECT_CALL() if you don't mean to enforce the call. "
2062 "https://github.com/google/googletest/blob/main/docs/"
2063 "gmock_cook_book.md#"
2064 "knowing-when-to-expect for details.";
2069 VerifyOutput(GetCapturedStdout(), should_print,
2070 "\nGMOCK WARNING:\n"
2071 "Uninteresting mock function call - returning directly.\n"
2072 " Function call: DoA(5)\n" +
2079 VerifyOutput(GetCapturedStdout(), should_print,
2080 "\nGMOCK WARNING:\n"
2081 "Uninteresting mock function call - returning default value.\n"
2082 " Function call: Binary(2, 1)\n"
2083 " Returns: false\n" +
2091TEST_F(GMockVerboseFlagTest, Info) {
2092 GMOCK_FLAG_SET(verbose, kInfoVerbosity);
2093 TestExpectedCall(
true);
2094 TestUninterestingCallOnNaggyMock(
true);
2099TEST_F(GMockVerboseFlagTest, Warning) {
2100 GMOCK_FLAG_SET(verbose, kWarningVerbosity);
2101 TestExpectedCall(
false);
2102 TestUninterestingCallOnNaggyMock(
true);
2107TEST_F(GMockVerboseFlagTest, Error) {
2108 GMOCK_FLAG_SET(verbose, kErrorVerbosity);
2109 TestExpectedCall(
false);
2110 TestUninterestingCallOnNaggyMock(
false);
2115TEST_F(GMockVerboseFlagTest, InvalidFlagIsTreatedAsWarning) {
2116 GMOCK_FLAG_SET(verbose,
"invalid");
2117 TestExpectedCall(
false);
2118 TestUninterestingCallOnNaggyMock(
true);
2128void PrintTo(PrintMeNot , ::std::ostream* ) {
2129 ADD_FAILURE() <<
"Google Mock is printing a value that shouldn't be "
2130 <<
"printed even to an internal buffer.";
2133class LogTestHelper {
2137 MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
2140 LogTestHelper(
const LogTestHelper&) =
delete;
2141 LogTestHelper& operator=(
const LogTestHelper&) =
delete;
2144class GMockLogTest :
public VerboseFlagPreservingFixture {
2146 LogTestHelper helper_;
2149TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsWarning) {
2150 GMOCK_FLAG_SET(verbose, kWarningVerbosity);
2151 EXPECT_CALL(helper_, Foo(_)).WillOnce(Return(PrintMeNot()));
2152 helper_.Foo(PrintMeNot());
2155TEST_F(GMockLogTest, DoesNotPrintGoodCallInternallyIfVerbosityIsError) {
2156 GMOCK_FLAG_SET(verbose, kErrorVerbosity);
2157 EXPECT_CALL(helper_, Foo(_)).WillOnce(Return(PrintMeNot()));
2158 helper_.Foo(PrintMeNot());
2161TEST_F(GMockLogTest, DoesNotPrintWarningInternallyIfVerbosityIsError) {
2162 GMOCK_FLAG_SET(verbose, kErrorVerbosity);
2163 ON_CALL(helper_, Foo(_)).WillByDefault(Return(PrintMeNot()));
2164 helper_.Foo(PrintMeNot());
2169TEST(AllowLeakTest, AllowsLeakingUnusedMockObject) {
2170 MockA* a =
new MockA;
2174TEST(AllowLeakTest, CanBeCalledBeforeOnCall) {
2175 MockA* a =
new MockA;
2177 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2181TEST(AllowLeakTest, CanBeCalledAfterOnCall) {
2182 MockA* a =
new MockA;
2183 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2187TEST(AllowLeakTest, CanBeCalledBeforeExpectCall) {
2188 MockA* a =
new MockA;
2190 EXPECT_CALL(*a, DoA(_));
2194TEST(AllowLeakTest, CanBeCalledAfterExpectCall) {
2195 MockA* a =
new MockA;
2196 EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
2200TEST(AllowLeakTest, WorksWhenBothOnCallAndExpectCallArePresent) {
2201 MockA* a =
new MockA;
2202 ON_CALL(*a, DoA(_)).WillByDefault(Return());
2203 EXPECT_CALL(*a, DoA(_)).Times(AnyNumber());
2209TEST(VerifyAndClearExpectationsTest, NoMethodHasExpectations) {
2211 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2215 EXPECT_EQ(0, b.DoB());
2216 EXPECT_EQ(0, b.DoB(1));
2222TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndSucceed) {
2224 EXPECT_CALL(b, DoB()).WillOnce(Return(1));
2226 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2230 EXPECT_EQ(0, b.DoB());
2231 EXPECT_EQ(0, b.DoB(1));
2237TEST(VerifyAndClearExpectationsTest, SomeMethodsHaveExpectationsAndFail) {
2239 EXPECT_CALL(b, DoB()).WillOnce(Return(1));
2241 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
2242 "Actual: never called");
2243 ASSERT_FALSE(result);
2247 EXPECT_EQ(0, b.DoB());
2248 EXPECT_EQ(0, b.DoB(1));
2253TEST(VerifyAndClearExpectationsTest, AllMethodsHaveExpectations) {
2255 EXPECT_CALL(b, DoB()).WillOnce(Return(1));
2256 EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
2259 ASSERT_TRUE(Mock::VerifyAndClearExpectations(&b));
2263 EXPECT_EQ(0, b.DoB());
2264 EXPECT_EQ(0, b.DoB(1));
2269TEST(VerifyAndClearExpectationsTest, AMethodHasManyExpectations) {
2271 EXPECT_CALL(b, DoB(0)).WillOnce(Return(1));
2272 EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
2275 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClearExpectations(&b),
2276 "Actual: never called");
2277 ASSERT_FALSE(result);
2281 EXPECT_EQ(0, b.DoB());
2282 EXPECT_EQ(0, b.DoB(1));
2287TEST(VerifyAndClearExpectationsTest, CanCallManyTimes) {
2289 EXPECT_CALL(b, DoB());
2291 Mock::VerifyAndClearExpectations(&b);
2293 EXPECT_CALL(b, DoB(_)).WillOnce(Return(1));
2295 Mock::VerifyAndClearExpectations(&b);
2296 Mock::VerifyAndClearExpectations(&b);
2300 EXPECT_EQ(0, b.DoB());
2301 EXPECT_EQ(0, b.DoB(1));
2306TEST(VerifyAndClearTest, NoMethodHasDefaultActions) {
2309 Mock::VerifyAndClear(&b);
2310 EXPECT_EQ(0, b.DoB());
2315TEST(VerifyAndClearTest, SomeMethodsHaveDefaultActions) {
2317 ON_CALL(b, DoB()).WillByDefault(Return(1));
2319 Mock::VerifyAndClear(&b);
2322 EXPECT_EQ(0, b.DoB());
2327TEST(VerifyAndClearTest, AllMethodsHaveDefaultActions) {
2329 ON_CALL(b, DoB()).WillByDefault(Return(1));
2330 ON_CALL(b, DoB(_)).WillByDefault(Return(2));
2332 Mock::VerifyAndClear(&b);
2335 EXPECT_EQ(0, b.DoB());
2338 EXPECT_EQ(0, b.DoB(0));
2343TEST(VerifyAndClearTest, AMethodHasManyDefaultActions) {
2345 ON_CALL(b, DoB(0)).WillByDefault(Return(1));
2346 ON_CALL(b, DoB(_)).WillByDefault(Return(2));
2348 Mock::VerifyAndClear(&b);
2352 EXPECT_EQ(0, b.DoB(0));
2353 EXPECT_EQ(0, b.DoB(1));
2358TEST(VerifyAndClearTest, CanCallManyTimes) {
2360 ON_CALL(b, DoB()).WillByDefault(Return(1));
2361 Mock::VerifyAndClear(&b);
2362 Mock::VerifyAndClear(&b);
2364 ON_CALL(b, DoB(_)).WillByDefault(Return(1));
2365 Mock::VerifyAndClear(&b);
2367 EXPECT_EQ(0, b.DoB());
2368 EXPECT_EQ(0, b.DoB(1));
2372TEST(VerifyAndClearTest, Success) {
2374 ON_CALL(b, DoB()).WillByDefault(Return(1));
2375 EXPECT_CALL(b, DoB(1)).WillOnce(Return(2));
2379 ASSERT_TRUE(Mock::VerifyAndClear(&b));
2383 EXPECT_EQ(0, b.DoB());
2384 EXPECT_EQ(0, b.DoB(1));
2388TEST(VerifyAndClearTest, Failure) {
2390 ON_CALL(b, DoB(_)).WillByDefault(Return(1));
2391 EXPECT_CALL(b, DoB()).WillOnce(Return(2));
2395 EXPECT_NONFATAL_FAILURE(result = Mock::VerifyAndClear(&b),
2396 "Actual: never called");
2397 ASSERT_FALSE(result);
2401 EXPECT_EQ(0, b.DoB());
2402 EXPECT_EQ(0, b.DoB(1));
2407TEST(VerifyAndClearTest, Const) {
2409 ON_CALL(Const(b), DoB()).WillByDefault(Return(1));
2411 EXPECT_CALL(Const(b), DoB()).WillOnce(DoDefault()).WillOnce(Return(2));
2415 ASSERT_TRUE(Mock::VerifyAndClear(&b));
2419 EXPECT_EQ(0, b.DoB());
2420 EXPECT_EQ(0, b.DoB(1));
2425TEST(VerifyAndClearTest, CanSetDefaultActionsAndExpectationsAfterwards) {
2427 ON_CALL(b, DoB()).WillByDefault(Return(1));
2428 EXPECT_CALL(b, DoB(_)).WillOnce(Return(2));
2431 Mock::VerifyAndClear(&b);
2433 EXPECT_CALL(b, DoB()).WillOnce(Return(3));
2434 ON_CALL(b, DoB(_)).WillByDefault(Return(4));
2436 EXPECT_EQ(3, b.DoB());
2437 EXPECT_EQ(4, b.DoB(1));
2442TEST(VerifyAndClearTest, DoesNotAffectOtherMockObjects) {
2447 ON_CALL(a, Binary(_, _)).WillByDefault(Return(
true));
2448 EXPECT_CALL(a, Binary(_, _)).WillOnce(DoDefault()).WillOnce(Return(
false));
2450 ON_CALL(b1, DoB()).WillByDefault(Return(1));
2451 EXPECT_CALL(b1, DoB(_)).WillOnce(Return(2));
2453 ON_CALL(b2, DoB()).WillByDefault(Return(3));
2454 EXPECT_CALL(b2, DoB(_));
2457 Mock::VerifyAndClear(&b2);
2461 EXPECT_TRUE(a.Binary(0, 0));
2462 EXPECT_FALSE(a.Binary(0, 0));
2464 EXPECT_EQ(1, b1.DoB());
2465 EXPECT_EQ(2, b1.DoB(0));
2468TEST(VerifyAndClearTest,
2469 DestroyingChainedMocksDoesNotDeadlockThroughExpectations) {
2470 std::shared_ptr<MockA> a(
new MockA);
2471 ReferenceHoldingMock test_mock;
2474 EXPECT_CALL(test_mock, AcceptReference(_))
2475 .WillRepeatedly(SetArgPointee<0>(a));
2488TEST(VerifyAndClearTest,
2489 DestroyingChainedMocksDoesNotDeadlockThroughDefaultAction) {
2490 std::shared_ptr<MockA> a(
new MockA);
2491 ReferenceHoldingMock test_mock;
2494 ON_CALL(test_mock, AcceptReference(_)).WillByDefault(SetArgPointee<0>(a));
2512TEST(SynchronizationTest, CanCallMockMethodInAction) {
2515 ON_CALL(a, DoA(_)).WillByDefault(
2516 IgnoreResult(InvokeWithoutArgs(&c, &MockC::NonVoidMethod)));
2517 EXPECT_CALL(a, DoA(1));
2518 EXPECT_CALL(a, DoA(1))
2519 .WillOnce(Invoke(&a, &MockA::DoA))
2520 .RetiresOnSaturation();
2521 EXPECT_CALL(c, NonVoidMethod());
2530TEST(ParameterlessExpectationsTest, CanSetExpectationsWithoutMatchers) {
2533 ON_CALL(a, DoA).WillByDefault(SaveArg<0>(&do_a_arg0));
2534 int do_a_47_arg0 = 0;
2535 ON_CALL(a, DoA(47)).WillByDefault(SaveArg<0>(&do_a_47_arg0));
2538 EXPECT_THAT(do_a_arg0, 17);
2539 EXPECT_THAT(do_a_47_arg0, 0);
2541 EXPECT_THAT(do_a_arg0, 17);
2542 EXPECT_THAT(do_a_47_arg0, 47);
2544 ON_CALL(a, Binary).WillByDefault(Return(
true));
2545 ON_CALL(a, Binary(_, 14)).WillByDefault(Return(
false));
2546 EXPECT_THAT(a.Binary(14, 17),
true);
2547 EXPECT_THAT(a.Binary(17, 14),
false);
2550TEST(ParameterlessExpectationsTest, CanSetExpectationsForOverloadedMethods) {
2552 ON_CALL(b, DoB()).WillByDefault(Return(9));
2553 ON_CALL(b, DoB(5)).WillByDefault(Return(11));
2555 EXPECT_THAT(b.DoB(), 9);
2556 EXPECT_THAT(b.DoB(1), 0);
2557 EXPECT_THAT(b.DoB(5), 11);
2560struct MockWithConstMethods {
2562 MOCK_CONST_METHOD1(Foo,
int(
int));
2563 MOCK_CONST_METHOD2(Bar,
int(
int,
const char*));
2566TEST(ParameterlessExpectationsTest, CanSetExpectationsForConstMethods) {
2567 MockWithConstMethods mock;
2568 ON_CALL(mock, Foo).WillByDefault(Return(7));
2569 ON_CALL(mock, Bar).WillByDefault(Return(33));
2571 EXPECT_THAT(mock.Foo(17), 7);
2572 EXPECT_THAT(mock.Bar(27,
"purple"), 33);
2575class MockConstOverload {
2577 MOCK_METHOD1(Overloaded,
int(
int));
2578 MOCK_CONST_METHOD1(Overloaded,
int(
int));
2581TEST(ParameterlessExpectationsTest,
2582 CanSetExpectationsForConstOverloadedMethods) {
2583 MockConstOverload mock;
2584 ON_CALL(mock, Overloaded(_)).WillByDefault(Return(7));
2585 ON_CALL(mock, Overloaded(5)).WillByDefault(Return(9));
2586 ON_CALL(Const(mock), Overloaded(5)).WillByDefault(Return(11));
2587 ON_CALL(Const(mock), Overloaded(7)).WillByDefault(Return(13));
2589 EXPECT_THAT(mock.Overloaded(1), 7);
2590 EXPECT_THAT(mock.Overloaded(5), 9);
2591 EXPECT_THAT(mock.Overloaded(7), 7);
2593 const MockConstOverload& const_mock = mock;
2594 EXPECT_THAT(const_mock.Overloaded(1), 0);
2595 EXPECT_THAT(const_mock.Overloaded(5), 11);
2596 EXPECT_THAT(const_mock.Overloaded(7), 13);
2605#if GMOCK_RENAME_MAIN
2606int gmock_main(
int argc,
char** argv) {
2608int main(
int argc,
char** argv) {
2610 testing::InitGoogleMock(&argc, argv);
2613 GMOCK_FLAG_SET(catch_leaked_mocks,
true);
2614 GMOCK_FLAG_SET(verbose, testing::internal::kWarningVerbosity);
2616 return RUN_ALL_TESTS();