1// Copyright 2008, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10//     * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14//     * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31// Tests Google Mock's output in various scenarios.  This ensures that
32// Google Mock's messages are readable and useful.
33
34#include "gmock/gmock.h"
35
36#include <stdio.h>
37#include <string>
38
39#include "gtest/gtest.h"
40
41// Silence C4100 (unreferenced formal parameter)
42#ifdef _MSC_VER
43# pragma warning(push)
44# pragma warning(disable:4100)
45#endif
46
47using testing::_;
48using testing::AnyNumber;
49using testing::Ge;
50using testing::InSequence;
51using testing::NaggyMock;
52using testing::Ref;
53using testing::Return;
54using testing::Sequence;
55using testing::Value;
56
57class MockFoo {
58 public:
59  MockFoo() {}
60
61  MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
62  MOCK_METHOD2(Bar2, bool(int x, int y));
63  MOCK_METHOD2(Bar3, void(int x, int y));
64
65 private:
66  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
67};
68
69class GMockOutputTest : public testing::Test {
70 protected:
71  NaggyMock<MockFoo> foo_;
72};
73
74TEST_F(GMockOutputTest, ExpectedCall) {
75  testing::GMOCK_FLAG(verbose) = "info";
76
77  EXPECT_CALL(foo_, Bar2(0, _));
78  foo_.Bar2(0, 0);  // Expected call
79
80  testing::GMOCK_FLAG(verbose) = "warning";
81}
82
83TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
84  testing::GMOCK_FLAG(verbose) = "info";
85
86  EXPECT_CALL(foo_, Bar3(0, _));
87  foo_.Bar3(0, 0);  // Expected call
88
89  testing::GMOCK_FLAG(verbose) = "warning";
90}
91
92TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
93  EXPECT_CALL(foo_, Bar2(_, _))
94      .Times(2)
95      .WillOnce(Return(false));
96  foo_.Bar2(2, 2);
97  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
98}
99
100TEST_F(GMockOutputTest, UnexpectedCall) {
101  EXPECT_CALL(foo_, Bar2(0, _));
102
103  foo_.Bar2(1, 0);  // Unexpected call
104  foo_.Bar2(0, 0);  // Expected call
105}
106
107TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
108  EXPECT_CALL(foo_, Bar3(0, _));
109
110  foo_.Bar3(1, 0);  // Unexpected call
111  foo_.Bar3(0, 0);  // Expected call
112}
113
114TEST_F(GMockOutputTest, ExcessiveCall) {
115  EXPECT_CALL(foo_, Bar2(0, _));
116
117  foo_.Bar2(0, 0);  // Expected call
118  foo_.Bar2(0, 1);  // Excessive call
119}
120
121TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
122  EXPECT_CALL(foo_, Bar3(0, _));
123
124  foo_.Bar3(0, 0);  // Expected call
125  foo_.Bar3(0, 1);  // Excessive call
126}
127
128TEST_F(GMockOutputTest, UninterestingCall) {
129  foo_.Bar2(0, 1);  // Uninteresting call
130}
131
132TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
133  foo_.Bar3(0, 1);  // Uninteresting call
134}
135
136TEST_F(GMockOutputTest, RetiredExpectation) {
137  EXPECT_CALL(foo_, Bar2(_, _))
138      .RetiresOnSaturation();
139  EXPECT_CALL(foo_, Bar2(0, 0));
140
141  foo_.Bar2(1, 1);
142  foo_.Bar2(1, 1);  // Matches a retired expectation
143  foo_.Bar2(0, 0);
144}
145
146TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
147  {
148    InSequence s;
149    EXPECT_CALL(foo_, Bar(_, 0, _));
150    EXPECT_CALL(foo_, Bar2(0, 0));
151    EXPECT_CALL(foo_, Bar2(1, _));
152  }
153
154  foo_.Bar2(1, 0);  // Has one immediate unsatisfied pre-requisite
155  foo_.Bar("Hi", 0, 0);
156  foo_.Bar2(0, 0);
157  foo_.Bar2(1, 0);
158}
159
160TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
161  Sequence s1, s2;
162
163  EXPECT_CALL(foo_, Bar(_, 0, _))
164      .InSequence(s1);
165  EXPECT_CALL(foo_, Bar2(0, 0))
166      .InSequence(s2);
167  EXPECT_CALL(foo_, Bar2(1, _))
168      .InSequence(s1, s2);
169
170  foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
171  foo_.Bar("Hi", 0, 0);
172  foo_.Bar2(0, 0);
173  foo_.Bar2(1, 0);
174}
175
176TEST_F(GMockOutputTest, UnsatisfiedWith) {
177  EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
178}
179
180TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
181  EXPECT_CALL(foo_, Bar(_, _, _));
182  EXPECT_CALL(foo_, Bar2(0, _))
183      .Times(2);
184
185  foo_.Bar2(0, 1);
186}
187
188TEST_F(GMockOutputTest, MismatchArguments) {
189  const std::string s = "Hi";
190  EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
191
192  foo_.Bar("Ho", 0, -0.1);  // Mismatch arguments
193  foo_.Bar(s, 0, 0);
194}
195
196TEST_F(GMockOutputTest, MismatchWith) {
197  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
198      .With(Ge());
199
200  foo_.Bar2(2, 3);  // Mismatch With()
201  foo_.Bar2(2, 1);
202}
203
204TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
205  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
206      .With(Ge());
207
208  foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
209  foo_.Bar2(2, 1);
210}
211
212TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
213  ON_CALL(foo_, Bar2(_, _))
214      .WillByDefault(Return(true));   // Default action #1
215  ON_CALL(foo_, Bar2(1, _))
216      .WillByDefault(Return(false));  // Default action #2
217
218  EXPECT_CALL(foo_, Bar2(2, 2));
219  foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
220  foo_.Bar2(0, 0);  // Unexpected call, takes default action #1.
221  foo_.Bar2(2, 2);  // Expected call.
222}
223
224TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
225  ON_CALL(foo_, Bar2(_, _))
226      .WillByDefault(Return(true));   // Default action #1
227  ON_CALL(foo_, Bar2(1, _))
228      .WillByDefault(Return(false));  // Default action #2
229
230  EXPECT_CALL(foo_, Bar2(2, 2));
231  EXPECT_CALL(foo_, Bar2(1, 1));
232
233  foo_.Bar2(2, 2);  // Expected call.
234  foo_.Bar2(2, 2);  // Excessive call, takes default action #1.
235  foo_.Bar2(1, 1);  // Expected call.
236  foo_.Bar2(1, 1);  // Excessive call, takes default action #2.
237}
238
239TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
240  ON_CALL(foo_, Bar2(_, _))
241      .WillByDefault(Return(true));   // Default action #1
242  ON_CALL(foo_, Bar2(1, _))
243      .WillByDefault(Return(false));  // Default action #2
244
245  foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
246  foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
247}
248
249TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
250  ON_CALL(foo_, Bar2(_, _))
251      .WillByDefault(Return(true));   // Default action #1
252
253  EXPECT_CALL(foo_, Bar2(_, _))
254      .Times(2)
255      .WillOnce(Return(false));
256  foo_.Bar2(2, 2);
257  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
258}
259
260TEST_F(GMockOutputTest, CatchesLeakedMocks) {
261  MockFoo* foo1 = new MockFoo;
262  MockFoo* foo2 = new MockFoo;
263
264  // Invokes ON_CALL on foo1.
265  ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
266
267  // Invokes EXPECT_CALL on foo2.
268  EXPECT_CALL(*foo2, Bar2(_, _));
269  EXPECT_CALL(*foo2, Bar2(1, _));
270  EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
271  foo2->Bar2(2, 1);
272  foo2->Bar2(1, 1);
273
274  // Both foo1 and foo2 are deliberately leaked.
275}
276
277MATCHER_P2(IsPair, first, second, "") {
278  return Value(arg.first, first) && Value(arg.second, second);
279}
280
281TEST_F(GMockOutputTest, PrintsMatcher) {
282  const testing::Matcher<int> m1 = Ge(48);
283  EXPECT_THAT((std::pair<int, bool>(42, true)), IsPair(m1, true));
284}
285
286void TestCatchesLeakedMocksInAdHocTests() {
287  MockFoo* foo = new MockFoo;
288
289  // Invokes EXPECT_CALL on foo.
290  EXPECT_CALL(*foo, Bar2(_, _));
291  foo->Bar2(2, 1);
292
293  // foo is deliberately leaked.
294}
295
296int main(int argc, char **argv) {
297  testing::InitGoogleMock(&argc, argv);
298  // Ensures that the tests pass no matter what value of
299  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
300  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
301  testing::GMOCK_FLAG(verbose) = "warning";
302
303  TestCatchesLeakedMocksInAdHocTests();
304  return RUN_ALL_TESTS();
305}
306
307#ifdef _MSC_VER
308# pragma warning(pop)
309#endif
310