]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright 2007, 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. | |
9f95a23c | 29 | |
7c673cae FG |
30 | |
31 | // Google Mock - a framework for writing C++ mock classes. | |
32 | // | |
33 | // This file tests the function mocker classes. | |
34 | ||
35 | #include "gmock/gmock-generated-function-mockers.h" | |
36 | ||
37 | #if GTEST_OS_WINDOWS | |
38 | // MSDN says the header file to be included for STDMETHOD is BaseTyps.h but | |
39 | // we are getting compiler errors if we use basetyps.h, hence including | |
40 | // objbase.h for definition of STDMETHOD. | |
41 | # include <objbase.h> | |
42 | #endif // GTEST_OS_WINDOWS | |
43 | ||
44 | #include <map> | |
45 | #include <string> | |
46 | #include "gmock/gmock.h" | |
47 | #include "gtest/gtest.h" | |
48 | ||
7c673cae FG |
49 | namespace testing { |
50 | namespace gmock_generated_function_mockers_test { | |
51 | ||
7c673cae FG |
52 | using testing::_; |
53 | using testing::A; | |
54 | using testing::An; | |
55 | using testing::AnyNumber; | |
56 | using testing::Const; | |
57 | using testing::DoDefault; | |
58 | using testing::Eq; | |
59 | using testing::Lt; | |
60 | using testing::MockFunction; | |
61 | using testing::Ref; | |
62 | using testing::Return; | |
63 | using testing::ReturnRef; | |
64 | using testing::TypedEq; | |
65 | ||
9f95a23c TL |
66 | template<typename T> |
67 | class TemplatedCopyable { | |
68 | public: | |
69 | TemplatedCopyable() {} | |
70 | ||
71 | template <typename U> | |
72 | TemplatedCopyable(const U& other) {} // NOLINT | |
73 | }; | |
74 | ||
7c673cae FG |
75 | class FooInterface { |
76 | public: | |
77 | virtual ~FooInterface() {} | |
78 | ||
79 | virtual void VoidReturning(int x) = 0; | |
80 | ||
81 | virtual int Nullary() = 0; | |
82 | virtual bool Unary(int x) = 0; | |
83 | virtual long Binary(short x, int y) = 0; // NOLINT | |
84 | virtual int Decimal(bool b, char c, short d, int e, long f, // NOLINT | |
9f95a23c TL |
85 | float g, double h, unsigned i, char* j, |
86 | const std::string& k) = 0; | |
7c673cae FG |
87 | |
88 | virtual bool TakesNonConstReference(int& n) = 0; // NOLINT | |
9f95a23c | 89 | virtual std::string TakesConstReference(const int& n) = 0; |
7c673cae | 90 | virtual bool TakesConst(const int x) = 0; |
7c673cae FG |
91 | |
92 | virtual int OverloadedOnArgumentNumber() = 0; | |
93 | virtual int OverloadedOnArgumentNumber(int n) = 0; | |
94 | ||
95 | virtual int OverloadedOnArgumentType(int n) = 0; | |
96 | virtual char OverloadedOnArgumentType(char c) = 0; | |
97 | ||
98 | virtual int OverloadedOnConstness() = 0; | |
99 | virtual char OverloadedOnConstness() const = 0; | |
100 | ||
101 | virtual int TypeWithHole(int (*func)()) = 0; | |
9f95a23c TL |
102 | virtual int TypeWithComma(const std::map<int, std::string>& a_map) = 0; |
103 | virtual int TypeWithTemplatedCopyCtor( | |
104 | const TemplatedCopyable<int>& a_vector) = 0; | |
7c673cae FG |
105 | |
106 | #if GTEST_OS_WINDOWS | |
107 | STDMETHOD_(int, CTNullary)() = 0; | |
108 | STDMETHOD_(bool, CTUnary)(int x) = 0; | |
9f95a23c TL |
109 | STDMETHOD_(int, CTDecimal) |
110 | (bool b, char c, short d, int e, long f, // NOLINT | |
111 | float g, double h, unsigned i, char* j, const std::string& k) = 0; | |
7c673cae FG |
112 | STDMETHOD_(char, CTConst)(int x) const = 0; |
113 | #endif // GTEST_OS_WINDOWS | |
114 | }; | |
115 | ||
116 | // Const qualifiers on arguments were once (incorrectly) considered | |
117 | // significant in determining whether two virtual functions had the same | |
118 | // signature. This was fixed in Visual Studio 2008. However, the compiler | |
119 | // still emits a warning that alerts about this change in behavior. | |
120 | #ifdef _MSC_VER | |
121 | # pragma warning(push) | |
122 | # pragma warning(disable : 4373) | |
123 | #endif | |
124 | class MockFoo : public FooInterface { | |
125 | public: | |
126 | MockFoo() {} | |
127 | ||
128 | // Makes sure that a mock function parameter can be named. | |
129 | MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT | |
130 | ||
131 | MOCK_METHOD0(Nullary, int()); // NOLINT | |
132 | ||
133 | // Makes sure that a mock function parameter can be unnamed. | |
134 | MOCK_METHOD1(Unary, bool(int)); // NOLINT | |
135 | MOCK_METHOD2(Binary, long(short, int)); // NOLINT | |
136 | MOCK_METHOD10(Decimal, int(bool, char, short, int, long, float, // NOLINT | |
9f95a23c | 137 | double, unsigned, char*, const std::string& str)); |
7c673cae FG |
138 | |
139 | MOCK_METHOD1(TakesNonConstReference, bool(int&)); // NOLINT | |
9f95a23c | 140 | MOCK_METHOD1(TakesConstReference, std::string(const int&)); |
7c673cae | 141 | MOCK_METHOD1(TakesConst, bool(const int)); // NOLINT |
7c673cae FG |
142 | |
143 | // Tests that the function return type can contain unprotected comma. | |
9f95a23c | 144 | MOCK_METHOD0(ReturnTypeWithComma, std::map<int, std::string>()); |
7c673cae | 145 | MOCK_CONST_METHOD1(ReturnTypeWithComma, |
9f95a23c | 146 | std::map<int, std::string>(int)); // NOLINT |
7c673cae FG |
147 | |
148 | MOCK_METHOD0(OverloadedOnArgumentNumber, int()); // NOLINT | |
149 | MOCK_METHOD1(OverloadedOnArgumentNumber, int(int)); // NOLINT | |
150 | ||
151 | MOCK_METHOD1(OverloadedOnArgumentType, int(int)); // NOLINT | |
152 | MOCK_METHOD1(OverloadedOnArgumentType, char(char)); // NOLINT | |
153 | ||
154 | MOCK_METHOD0(OverloadedOnConstness, int()); // NOLINT | |
155 | MOCK_CONST_METHOD0(OverloadedOnConstness, char()); // NOLINT | |
156 | ||
157 | MOCK_METHOD1(TypeWithHole, int(int (*)())); // NOLINT | |
9f95a23c TL |
158 | MOCK_METHOD1(TypeWithComma, |
159 | int(const std::map<int, std::string>&)); // NOLINT | |
160 | MOCK_METHOD1(TypeWithTemplatedCopyCtor, | |
161 | int(const TemplatedCopyable<int>&)); // NOLINT | |
7c673cae FG |
162 | |
163 | #if GTEST_OS_WINDOWS | |
164 | MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int()); | |
165 | MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int)); | |
9f95a23c TL |
166 | MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, |
167 | int(bool b, char c, short d, int e, long f, | |
168 | float g, double h, unsigned i, char* j, | |
169 | const std::string& k)); | |
7c673cae FG |
170 | MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int)); |
171 | ||
172 | // Tests that the function return type can contain unprotected comma. | |
173 | MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTReturnTypeWithComma, | |
9f95a23c | 174 | std::map<int, std::string>()); |
7c673cae FG |
175 | #endif // GTEST_OS_WINDOWS |
176 | ||
177 | private: | |
178 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo); | |
179 | }; | |
180 | #ifdef _MSC_VER | |
181 | # pragma warning(pop) | |
182 | #endif | |
183 | ||
184 | class FunctionMockerTest : public testing::Test { | |
185 | protected: | |
186 | FunctionMockerTest() : foo_(&mock_foo_) {} | |
187 | ||
188 | FooInterface* const foo_; | |
189 | MockFoo mock_foo_; | |
190 | }; | |
191 | ||
192 | // Tests mocking a void-returning function. | |
193 | TEST_F(FunctionMockerTest, MocksVoidFunction) { | |
194 | EXPECT_CALL(mock_foo_, VoidReturning(Lt(100))); | |
195 | foo_->VoidReturning(0); | |
196 | } | |
197 | ||
198 | // Tests mocking a nullary function. | |
199 | TEST_F(FunctionMockerTest, MocksNullaryFunction) { | |
200 | EXPECT_CALL(mock_foo_, Nullary()) | |
201 | .WillOnce(DoDefault()) | |
202 | .WillOnce(Return(1)); | |
203 | ||
204 | EXPECT_EQ(0, foo_->Nullary()); | |
205 | EXPECT_EQ(1, foo_->Nullary()); | |
206 | } | |
207 | ||
208 | // Tests mocking a unary function. | |
209 | TEST_F(FunctionMockerTest, MocksUnaryFunction) { | |
210 | EXPECT_CALL(mock_foo_, Unary(Eq(2))) | |
211 | .Times(2) | |
212 | .WillOnce(Return(true)); | |
213 | ||
214 | EXPECT_TRUE(foo_->Unary(2)); | |
215 | EXPECT_FALSE(foo_->Unary(2)); | |
216 | } | |
217 | ||
218 | // Tests mocking a binary function. | |
219 | TEST_F(FunctionMockerTest, MocksBinaryFunction) { | |
220 | EXPECT_CALL(mock_foo_, Binary(2, _)) | |
221 | .WillOnce(Return(3)); | |
222 | ||
223 | EXPECT_EQ(3, foo_->Binary(2, 1)); | |
224 | } | |
225 | ||
226 | // Tests mocking a decimal function. | |
227 | TEST_F(FunctionMockerTest, MocksDecimalFunction) { | |
9f95a23c TL |
228 | EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100), 5U, |
229 | nullptr, "hi")) | |
7c673cae FG |
230 | .WillOnce(Return(5)); |
231 | ||
9f95a23c | 232 | EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi")); |
7c673cae FG |
233 | } |
234 | ||
235 | // Tests mocking a function that takes a non-const reference. | |
236 | TEST_F(FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument) { | |
237 | int a = 0; | |
238 | EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a))) | |
239 | .WillOnce(Return(true)); | |
240 | ||
241 | EXPECT_TRUE(foo_->TakesNonConstReference(a)); | |
242 | } | |
243 | ||
244 | // Tests mocking a function that takes a const reference. | |
245 | TEST_F(FunctionMockerTest, MocksFunctionWithConstReferenceArgument) { | |
246 | int a = 0; | |
247 | EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a))) | |
248 | .WillOnce(Return("Hello")); | |
249 | ||
250 | EXPECT_EQ("Hello", foo_->TakesConstReference(a)); | |
251 | } | |
252 | ||
7c673cae FG |
253 | // Tests mocking a function that takes a const variable. |
254 | TEST_F(FunctionMockerTest, MocksFunctionWithConstArgument) { | |
255 | EXPECT_CALL(mock_foo_, TakesConst(Lt(10))) | |
256 | .WillOnce(DoDefault()); | |
257 | ||
258 | EXPECT_FALSE(foo_->TakesConst(5)); | |
259 | } | |
7c673cae FG |
260 | |
261 | // Tests mocking functions overloaded on the number of arguments. | |
262 | TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) { | |
263 | EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber()) | |
264 | .WillOnce(Return(1)); | |
265 | EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_)) | |
266 | .WillOnce(Return(2)); | |
267 | ||
268 | EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1)); | |
269 | EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber()); | |
270 | } | |
271 | ||
272 | // Tests mocking functions overloaded on the types of argument. | |
273 | TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) { | |
274 | EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>())) | |
275 | .WillOnce(Return(1)); | |
276 | EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a'))) | |
277 | .WillOnce(Return('b')); | |
278 | ||
279 | EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0)); | |
280 | EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a')); | |
281 | } | |
282 | ||
283 | // Tests mocking functions overloaded on the const-ness of this object. | |
284 | TEST_F(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis) { | |
285 | EXPECT_CALL(mock_foo_, OverloadedOnConstness()); | |
286 | EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness()) | |
287 | .WillOnce(Return('a')); | |
288 | ||
289 | EXPECT_EQ(0, foo_->OverloadedOnConstness()); | |
290 | EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness()); | |
291 | } | |
292 | ||
293 | TEST_F(FunctionMockerTest, MocksReturnTypeWithComma) { | |
9f95a23c | 294 | const std::map<int, std::string> a_map; |
7c673cae FG |
295 | EXPECT_CALL(mock_foo_, ReturnTypeWithComma()) |
296 | .WillOnce(Return(a_map)); | |
297 | EXPECT_CALL(mock_foo_, ReturnTypeWithComma(42)) | |
298 | .WillOnce(Return(a_map)); | |
299 | ||
300 | EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma()); | |
301 | EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma(42)); | |
302 | } | |
303 | ||
9f95a23c TL |
304 | TEST_F(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) { |
305 | EXPECT_CALL(mock_foo_, TypeWithTemplatedCopyCtor(_)).WillOnce(Return(true)); | |
306 | EXPECT_TRUE(foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>())); | |
307 | } | |
308 | ||
7c673cae FG |
309 | #if GTEST_OS_WINDOWS |
310 | // Tests mocking a nullary function with calltype. | |
311 | TEST_F(FunctionMockerTest, MocksNullaryFunctionWithCallType) { | |
312 | EXPECT_CALL(mock_foo_, CTNullary()) | |
313 | .WillOnce(Return(-1)) | |
314 | .WillOnce(Return(0)); | |
315 | ||
316 | EXPECT_EQ(-1, foo_->CTNullary()); | |
317 | EXPECT_EQ(0, foo_->CTNullary()); | |
318 | } | |
319 | ||
320 | // Tests mocking a unary function with calltype. | |
321 | TEST_F(FunctionMockerTest, MocksUnaryFunctionWithCallType) { | |
322 | EXPECT_CALL(mock_foo_, CTUnary(Eq(2))) | |
323 | .Times(2) | |
324 | .WillOnce(Return(true)) | |
325 | .WillOnce(Return(false)); | |
326 | ||
327 | EXPECT_TRUE(foo_->CTUnary(2)); | |
328 | EXPECT_FALSE(foo_->CTUnary(2)); | |
329 | } | |
330 | ||
331 | // Tests mocking a decimal function with calltype. | |
332 | TEST_F(FunctionMockerTest, MocksDecimalFunctionWithCallType) { | |
9f95a23c TL |
333 | EXPECT_CALL(mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100), 5U, |
334 | nullptr, "hi")) | |
7c673cae FG |
335 | .WillOnce(Return(10)); |
336 | ||
9f95a23c | 337 | EXPECT_EQ(10, foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi")); |
7c673cae FG |
338 | } |
339 | ||
340 | // Tests mocking functions overloaded on the const-ness of this object. | |
341 | TEST_F(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) { | |
342 | EXPECT_CALL(Const(mock_foo_), CTConst(_)) | |
343 | .WillOnce(Return('a')); | |
344 | ||
345 | EXPECT_EQ('a', Const(*foo_).CTConst(0)); | |
346 | } | |
347 | ||
348 | TEST_F(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) { | |
9f95a23c | 349 | const std::map<int, std::string> a_map; |
7c673cae FG |
350 | EXPECT_CALL(mock_foo_, CTReturnTypeWithComma()) |
351 | .WillOnce(Return(a_map)); | |
352 | ||
353 | EXPECT_EQ(a_map, mock_foo_.CTReturnTypeWithComma()); | |
354 | } | |
355 | ||
356 | #endif // GTEST_OS_WINDOWS | |
357 | ||
358 | class MockB { | |
359 | public: | |
360 | MockB() {} | |
361 | ||
362 | MOCK_METHOD0(DoB, void()); | |
363 | ||
364 | private: | |
365 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB); | |
366 | }; | |
367 | ||
368 | // Tests that functions with no EXPECT_CALL() ruls can be called any | |
369 | // number of times. | |
370 | TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) { | |
371 | { | |
372 | MockB b; | |
373 | } | |
374 | ||
375 | { | |
376 | MockB b; | |
377 | b.DoB(); | |
378 | } | |
379 | ||
380 | { | |
381 | MockB b; | |
382 | b.DoB(); | |
383 | b.DoB(); | |
384 | } | |
385 | } | |
386 | ||
387 | // Tests mocking template interfaces. | |
388 | ||
389 | template <typename T> | |
390 | class StackInterface { | |
391 | public: | |
392 | virtual ~StackInterface() {} | |
393 | ||
394 | // Template parameter appears in function parameter. | |
395 | virtual void Push(const T& value) = 0; | |
396 | virtual void Pop() = 0; | |
397 | virtual int GetSize() const = 0; | |
398 | // Template parameter appears in function return type. | |
399 | virtual const T& GetTop() const = 0; | |
400 | }; | |
401 | ||
402 | template <typename T> | |
403 | class MockStack : public StackInterface<T> { | |
404 | public: | |
405 | MockStack() {} | |
406 | ||
407 | MOCK_METHOD1_T(Push, void(const T& elem)); | |
408 | MOCK_METHOD0_T(Pop, void()); | |
409 | MOCK_CONST_METHOD0_T(GetSize, int()); // NOLINT | |
410 | MOCK_CONST_METHOD0_T(GetTop, const T&()); | |
411 | ||
412 | // Tests that the function return type can contain unprotected comma. | |
413 | MOCK_METHOD0_T(ReturnTypeWithComma, std::map<int, int>()); | |
414 | MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int)); // NOLINT | |
415 | ||
416 | private: | |
417 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack); | |
418 | }; | |
419 | ||
420 | // Tests that template mock works. | |
421 | TEST(TemplateMockTest, Works) { | |
422 | MockStack<int> mock; | |
423 | ||
424 | EXPECT_CALL(mock, GetSize()) | |
425 | .WillOnce(Return(0)) | |
426 | .WillOnce(Return(1)) | |
427 | .WillOnce(Return(0)); | |
428 | EXPECT_CALL(mock, Push(_)); | |
429 | int n = 5; | |
430 | EXPECT_CALL(mock, GetTop()) | |
431 | .WillOnce(ReturnRef(n)); | |
432 | EXPECT_CALL(mock, Pop()) | |
433 | .Times(AnyNumber()); | |
434 | ||
435 | EXPECT_EQ(0, mock.GetSize()); | |
436 | mock.Push(5); | |
437 | EXPECT_EQ(1, mock.GetSize()); | |
438 | EXPECT_EQ(5, mock.GetTop()); | |
439 | mock.Pop(); | |
440 | EXPECT_EQ(0, mock.GetSize()); | |
441 | } | |
442 | ||
443 | TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) { | |
444 | MockStack<int> mock; | |
445 | ||
446 | const std::map<int, int> a_map; | |
447 | EXPECT_CALL(mock, ReturnTypeWithComma()) | |
448 | .WillOnce(Return(a_map)); | |
449 | EXPECT_CALL(mock, ReturnTypeWithComma(1)) | |
450 | .WillOnce(Return(a_map)); | |
451 | ||
452 | EXPECT_EQ(a_map, mock.ReturnTypeWithComma()); | |
453 | EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1)); | |
454 | } | |
455 | ||
456 | #if GTEST_OS_WINDOWS | |
457 | // Tests mocking template interfaces with calltype. | |
458 | ||
459 | template <typename T> | |
460 | class StackInterfaceWithCallType { | |
461 | public: | |
462 | virtual ~StackInterfaceWithCallType() {} | |
463 | ||
464 | // Template parameter appears in function parameter. | |
465 | STDMETHOD_(void, Push)(const T& value) = 0; | |
466 | STDMETHOD_(void, Pop)() = 0; | |
467 | STDMETHOD_(int, GetSize)() const = 0; | |
468 | // Template parameter appears in function return type. | |
469 | STDMETHOD_(const T&, GetTop)() const = 0; | |
470 | }; | |
471 | ||
472 | template <typename T> | |
473 | class MockStackWithCallType : public StackInterfaceWithCallType<T> { | |
474 | public: | |
475 | MockStackWithCallType() {} | |
476 | ||
477 | MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem)); | |
478 | MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void()); | |
479 | MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int()); | |
480 | MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&()); | |
481 | ||
482 | private: | |
483 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType); | |
484 | }; | |
485 | ||
486 | // Tests that template mock with calltype works. | |
487 | TEST(TemplateMockTestWithCallType, Works) { | |
488 | MockStackWithCallType<int> mock; | |
489 | ||
490 | EXPECT_CALL(mock, GetSize()) | |
491 | .WillOnce(Return(0)) | |
492 | .WillOnce(Return(1)) | |
493 | .WillOnce(Return(0)); | |
494 | EXPECT_CALL(mock, Push(_)); | |
495 | int n = 5; | |
496 | EXPECT_CALL(mock, GetTop()) | |
497 | .WillOnce(ReturnRef(n)); | |
498 | EXPECT_CALL(mock, Pop()) | |
499 | .Times(AnyNumber()); | |
500 | ||
501 | EXPECT_EQ(0, mock.GetSize()); | |
502 | mock.Push(5); | |
503 | EXPECT_EQ(1, mock.GetSize()); | |
504 | EXPECT_EQ(5, mock.GetTop()); | |
505 | mock.Pop(); | |
506 | EXPECT_EQ(0, mock.GetSize()); | |
507 | } | |
508 | #endif // GTEST_OS_WINDOWS | |
509 | ||
510 | #define MY_MOCK_METHODS1_ \ | |
511 | MOCK_METHOD0(Overloaded, void()); \ | |
512 | MOCK_CONST_METHOD1(Overloaded, int(int n)); \ | |
513 | MOCK_METHOD2(Overloaded, bool(bool f, int n)) | |
514 | ||
515 | class MockOverloadedOnArgNumber { | |
516 | public: | |
517 | MockOverloadedOnArgNumber() {} | |
518 | ||
519 | MY_MOCK_METHODS1_; | |
520 | ||
521 | private: | |
522 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber); | |
523 | }; | |
524 | ||
525 | TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) { | |
526 | MockOverloadedOnArgNumber mock; | |
527 | EXPECT_CALL(mock, Overloaded()); | |
528 | EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); | |
529 | EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true)); | |
530 | ||
531 | mock.Overloaded(); | |
532 | EXPECT_EQ(2, mock.Overloaded(1)); | |
533 | EXPECT_TRUE(mock.Overloaded(true, 1)); | |
534 | } | |
535 | ||
536 | #define MY_MOCK_METHODS2_ \ | |
537 | MOCK_CONST_METHOD1(Overloaded, int(int n)); \ | |
9f95a23c | 538 | MOCK_METHOD1(Overloaded, int(int n)) |
7c673cae FG |
539 | |
540 | class MockOverloadedOnConstness { | |
541 | public: | |
542 | MockOverloadedOnConstness() {} | |
543 | ||
544 | MY_MOCK_METHODS2_; | |
545 | ||
546 | private: | |
547 | GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness); | |
548 | }; | |
549 | ||
550 | TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) { | |
551 | MockOverloadedOnConstness mock; | |
552 | const MockOverloadedOnConstness* const_mock = &mock; | |
553 | EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); | |
554 | EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3)); | |
555 | ||
556 | EXPECT_EQ(2, mock.Overloaded(1)); | |
557 | EXPECT_EQ(3, const_mock->Overloaded(1)); | |
558 | } | |
559 | ||
560 | TEST(MockFunctionTest, WorksForVoidNullary) { | |
561 | MockFunction<void()> foo; | |
562 | EXPECT_CALL(foo, Call()); | |
563 | foo.Call(); | |
564 | } | |
565 | ||
566 | TEST(MockFunctionTest, WorksForNonVoidNullary) { | |
567 | MockFunction<int()> foo; | |
568 | EXPECT_CALL(foo, Call()) | |
569 | .WillOnce(Return(1)) | |
570 | .WillOnce(Return(2)); | |
571 | EXPECT_EQ(1, foo.Call()); | |
572 | EXPECT_EQ(2, foo.Call()); | |
573 | } | |
574 | ||
575 | TEST(MockFunctionTest, WorksForVoidUnary) { | |
576 | MockFunction<void(int)> foo; | |
577 | EXPECT_CALL(foo, Call(1)); | |
578 | foo.Call(1); | |
579 | } | |
580 | ||
581 | TEST(MockFunctionTest, WorksForNonVoidBinary) { | |
582 | MockFunction<int(bool, int)> foo; | |
583 | EXPECT_CALL(foo, Call(false, 42)) | |
584 | .WillOnce(Return(1)) | |
585 | .WillOnce(Return(2)); | |
586 | EXPECT_CALL(foo, Call(true, Ge(100))) | |
587 | .WillOnce(Return(3)); | |
588 | EXPECT_EQ(1, foo.Call(false, 42)); | |
589 | EXPECT_EQ(2, foo.Call(false, 42)); | |
590 | EXPECT_EQ(3, foo.Call(true, 120)); | |
591 | } | |
592 | ||
593 | TEST(MockFunctionTest, WorksFor10Arguments) { | |
594 | MockFunction<int(bool a0, char a1, int a2, int a3, int a4, | |
595 | int a5, int a6, char a7, int a8, bool a9)> foo; | |
596 | EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _)) | |
597 | .WillOnce(Return(1)) | |
598 | .WillOnce(Return(2)); | |
599 | EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true)); | |
600 | EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false)); | |
601 | } | |
602 | ||
7c673cae FG |
603 | TEST(MockFunctionTest, AsStdFunction) { |
604 | MockFunction<int(int)> foo; | |
605 | auto call = [](const std::function<int(int)> &f, int i) { | |
606 | return f(i); | |
607 | }; | |
608 | EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1)); | |
609 | EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2)); | |
610 | EXPECT_EQ(-1, call(foo.AsStdFunction(), 1)); | |
611 | EXPECT_EQ(-2, call(foo.AsStdFunction(), 2)); | |
612 | } | |
613 | ||
614 | TEST(MockFunctionTest, AsStdFunctionReturnsReference) { | |
615 | MockFunction<int&()> foo; | |
616 | int value = 1; | |
617 | EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value)); | |
618 | int& ref = foo.AsStdFunction()(); | |
619 | EXPECT_EQ(1, ref); | |
620 | value = 2; | |
621 | EXPECT_EQ(2, ref); | |
622 | } | |
9f95a23c TL |
623 | |
624 | TEST(MockFunctionTest, AsStdFunctionWithReferenceParameter) { | |
625 | MockFunction<int(int &)> foo; | |
626 | auto call = [](const std::function<int(int& )> &f, int &i) { | |
627 | return f(i); | |
628 | }; | |
629 | int i = 42; | |
630 | EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1)); | |
631 | EXPECT_EQ(-1, call(foo.AsStdFunction(), i)); | |
632 | } | |
633 | ||
634 | ||
635 | struct MockMethodSizes0 { | |
636 | MOCK_METHOD0(func, void()); | |
637 | }; | |
638 | struct MockMethodSizes1 { | |
639 | MOCK_METHOD1(func, void(int)); | |
640 | }; | |
641 | struct MockMethodSizes2 { | |
642 | MOCK_METHOD2(func, void(int, int)); | |
643 | }; | |
644 | struct MockMethodSizes3 { | |
645 | MOCK_METHOD3(func, void(int, int, int)); | |
646 | }; | |
647 | struct MockMethodSizes4 { | |
648 | MOCK_METHOD4(func, void(int, int, int, int)); | |
649 | }; | |
650 | ||
651 | TEST(MockFunctionTest, MockMethodSizeOverhead) { | |
652 | EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1)); | |
653 | EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2)); | |
654 | EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes3)); | |
655 | EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes4)); | |
656 | } | |
7c673cae FG |
657 | |
658 | } // namespace gmock_generated_function_mockers_test | |
659 | } // namespace testing |