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