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// Author: wan@google.com (Zhanyong Wan)
31
32// Tests Google Mock's output in various scenarios.  This ensures that
33// Google Mock's messages are readable and useful.
34
35#include "gmock/gmock.h"
36
37#include <stdio.h>
38#include <string>
39
40#include "gtest/gtest.h"
41
42using testing::_;
43using testing::AnyNumber;
44using testing::Ge;
45using testing::InSequence;
46using testing::Ref;
47using testing::Return;
48using testing::Sequence;
49
50class MockFoo {
51 public:
52  MockFoo() {}
53
54  MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
55  MOCK_METHOD2(Bar2, bool(int x, int y));
56  MOCK_METHOD2(Bar3, void(int x, int y));
57
58 private:
59  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
60};
61
62class GMockOutputTest : public testing::Test {
63 protected:
64  MockFoo foo_;
65};
66
67TEST_F(GMockOutputTest, ExpectedCall) {
68  testing::GMOCK_FLAG(verbose) = "info";
69
70  EXPECT_CALL(foo_, Bar2(0, _));
71  foo_.Bar2(0, 0);  // Expected call
72
73  testing::GMOCK_FLAG(verbose) = "warning";
74}
75
76TEST_F(GMockOutputTest, ExpectedCallToVoidFunction) {
77  testing::GMOCK_FLAG(verbose) = "info";
78
79  EXPECT_CALL(foo_, Bar3(0, _));
80  foo_.Bar3(0, 0);  // Expected call
81
82  testing::GMOCK_FLAG(verbose) = "warning";
83}
84
85TEST_F(GMockOutputTest, ExplicitActionsRunOut) {
86  EXPECT_CALL(foo_, Bar2(_, _))
87      .Times(2)
88      .WillOnce(Return(false));
89  foo_.Bar2(2, 2);
90  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
91}
92
93TEST_F(GMockOutputTest, UnexpectedCall) {
94  EXPECT_CALL(foo_, Bar2(0, _));
95
96  foo_.Bar2(1, 0);  // Unexpected call
97  foo_.Bar2(0, 0);  // Expected call
98}
99
100TEST_F(GMockOutputTest, UnexpectedCallToVoidFunction) {
101  EXPECT_CALL(foo_, Bar3(0, _));
102
103  foo_.Bar3(1, 0);  // Unexpected call
104  foo_.Bar3(0, 0);  // Expected call
105}
106
107TEST_F(GMockOutputTest, ExcessiveCall) {
108  EXPECT_CALL(foo_, Bar2(0, _));
109
110  foo_.Bar2(0, 0);  // Expected call
111  foo_.Bar2(0, 1);  // Excessive call
112}
113
114TEST_F(GMockOutputTest, ExcessiveCallToVoidFunction) {
115  EXPECT_CALL(foo_, Bar3(0, _));
116
117  foo_.Bar3(0, 0);  // Expected call
118  foo_.Bar3(0, 1);  // Excessive call
119}
120
121TEST_F(GMockOutputTest, UninterestingCall) {
122  foo_.Bar2(0, 1);  // Uninteresting call
123}
124
125TEST_F(GMockOutputTest, UninterestingCallToVoidFunction) {
126  foo_.Bar3(0, 1);  // Uninteresting call
127}
128
129TEST_F(GMockOutputTest, RetiredExpectation) {
130  EXPECT_CALL(foo_, Bar2(_, _))
131      .RetiresOnSaturation();
132  EXPECT_CALL(foo_, Bar2(0, 0));
133
134  foo_.Bar2(1, 1);
135  foo_.Bar2(1, 1);  // Matches a retired expectation
136  foo_.Bar2(0, 0);
137}
138
139TEST_F(GMockOutputTest, UnsatisfiedPrerequisite) {
140  {
141    InSequence s;
142    EXPECT_CALL(foo_, Bar(_, 0, _));
143    EXPECT_CALL(foo_, Bar2(0, 0));
144    EXPECT_CALL(foo_, Bar2(1, _));
145  }
146
147  foo_.Bar2(1, 0);  // Has one immediate unsatisfied pre-requisite
148  foo_.Bar("Hi", 0, 0);
149  foo_.Bar2(0, 0);
150  foo_.Bar2(1, 0);
151}
152
153TEST_F(GMockOutputTest, UnsatisfiedPrerequisites) {
154  Sequence s1, s2;
155
156  EXPECT_CALL(foo_, Bar(_, 0, _))
157      .InSequence(s1);
158  EXPECT_CALL(foo_, Bar2(0, 0))
159      .InSequence(s2);
160  EXPECT_CALL(foo_, Bar2(1, _))
161      .InSequence(s1, s2);
162
163  foo_.Bar2(1, 0);  // Has two immediate unsatisfied pre-requisites
164  foo_.Bar("Hi", 0, 0);
165  foo_.Bar2(0, 0);
166  foo_.Bar2(1, 0);
167}
168
169TEST_F(GMockOutputTest, UnsatisfiedWith) {
170  EXPECT_CALL(foo_, Bar2(_, _)).With(Ge());
171}
172
173TEST_F(GMockOutputTest, UnsatisfiedExpectation) {
174  EXPECT_CALL(foo_, Bar(_, _, _));
175  EXPECT_CALL(foo_, Bar2(0, _))
176      .Times(2);
177
178  foo_.Bar2(0, 1);
179}
180
181TEST_F(GMockOutputTest, MismatchArguments) {
182  const std::string s = "Hi";
183  EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)));
184
185  foo_.Bar("Ho", 0, -0.1);  // Mismatch arguments
186  foo_.Bar(s, 0, 0);
187}
188
189TEST_F(GMockOutputTest, MismatchWith) {
190  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
191      .With(Ge());
192
193  foo_.Bar2(2, 3);  // Mismatch With()
194  foo_.Bar2(2, 1);
195}
196
197TEST_F(GMockOutputTest, MismatchArgumentsAndWith) {
198  EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))
199      .With(Ge());
200
201  foo_.Bar2(1, 3);  // Mismatch arguments and mismatch With()
202  foo_.Bar2(2, 1);
203}
204
205TEST_F(GMockOutputTest, UnexpectedCallWithDefaultAction) {
206  ON_CALL(foo_, Bar2(_, _))
207      .WillByDefault(Return(true));   // Default action #1
208  ON_CALL(foo_, Bar2(1, _))
209      .WillByDefault(Return(false));  // Default action #2
210
211  EXPECT_CALL(foo_, Bar2(2, 2));
212  foo_.Bar2(1, 0);  // Unexpected call, takes default action #2.
213  foo_.Bar2(0, 0);  // Unexpected call, takes default action #1.
214  foo_.Bar2(2, 2);  // Expected call.
215}
216
217TEST_F(GMockOutputTest, ExcessiveCallWithDefaultAction) {
218  ON_CALL(foo_, Bar2(_, _))
219      .WillByDefault(Return(true));   // Default action #1
220  ON_CALL(foo_, Bar2(1, _))
221      .WillByDefault(Return(false));  // Default action #2
222
223  EXPECT_CALL(foo_, Bar2(2, 2));
224  EXPECT_CALL(foo_, Bar2(1, 1));
225
226  foo_.Bar2(2, 2);  // Expected call.
227  foo_.Bar2(2, 2);  // Excessive call, takes default action #1.
228  foo_.Bar2(1, 1);  // Expected call.
229  foo_.Bar2(1, 1);  // Excessive call, takes default action #2.
230}
231
232TEST_F(GMockOutputTest, UninterestingCallWithDefaultAction) {
233  ON_CALL(foo_, Bar2(_, _))
234      .WillByDefault(Return(true));   // Default action #1
235  ON_CALL(foo_, Bar2(1, _))
236      .WillByDefault(Return(false));  // Default action #2
237
238  foo_.Bar2(2, 2);  // Uninteresting call, takes default action #1.
239  foo_.Bar2(1, 1);  // Uninteresting call, takes default action #2.
240}
241
242TEST_F(GMockOutputTest, ExplicitActionsRunOutWithDefaultAction) {
243  ON_CALL(foo_, Bar2(_, _))
244      .WillByDefault(Return(true));   // Default action #1
245
246  EXPECT_CALL(foo_, Bar2(_, _))
247      .Times(2)
248      .WillOnce(Return(false));
249  foo_.Bar2(2, 2);
250  foo_.Bar2(1, 1);  // Explicit actions in EXPECT_CALL run out.
251}
252
253TEST_F(GMockOutputTest, CatchesLeakedMocks) {
254  MockFoo* foo1 = new MockFoo;
255  MockFoo* foo2 = new MockFoo;
256
257  // Invokes ON_CALL on foo1.
258  ON_CALL(*foo1, Bar(_, _, _)).WillByDefault(Return('a'));
259
260  // Invokes EXPECT_CALL on foo2.
261  EXPECT_CALL(*foo2, Bar2(_, _));
262  EXPECT_CALL(*foo2, Bar2(1, _));
263  EXPECT_CALL(*foo2, Bar3(_, _)).Times(AnyNumber());
264  foo2->Bar2(2, 1);
265  foo2->Bar2(1, 1);
266
267  // Both foo1 and foo2 are deliberately leaked.
268}
269
270void TestCatchesLeakedMocksInAdHocTests() {
271  MockFoo* foo = new MockFoo;
272
273  // Invokes EXPECT_CALL on foo.
274  EXPECT_CALL(*foo, Bar2(_, _));
275  foo->Bar2(2, 1);
276
277  // foo is deliberately leaked.
278}
279
280int main(int argc, char **argv) {
281  testing::InitGoogleMock(&argc, argv);
282
283  // Ensures that the tests pass no matter what value of
284  // --gmock_catch_leaked_mocks and --gmock_verbose the user specifies.
285  testing::GMOCK_FLAG(catch_leaked_mocks) = true;
286  testing::GMOCK_FLAG(verbose) = "warning";
287
288  TestCatchesLeakedMocksInAdHocTests();
289  return RUN_ALL_TESTS();
290}
291