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