Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gmock-generated-function-mockers_test.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file gmock-generated-function-mockers_test.cc
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 
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 
57 namespace testing {
58 namespace gmock_generated_function_mockers_test {
59 
61 using testing::_;
62 using testing::A;
63 using testing::An;
64 using testing::AnyNumber;
65 using testing::Const;
66 using testing::DoDefault;
67 using testing::Eq;
68 using testing::Lt;
69 using testing::MockFunction;
70 using testing::Ref;
71 using testing::Return;
72 using testing::ReturnRef;
73 using testing::TypedEq;
74 
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
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
123 class 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:
177 };
178 #ifdef _MSC_VER
179 # pragma warning(pop)
180 #endif
181 
183  protected:
185 
188 };
189 
190 // Tests mocking a void-returning function.
191 TEST_F(FunctionMockerTest, MocksVoidFunction) {
192  EXPECT_CALL(mock_foo_, VoidReturning(Lt(100)));
193  foo_->VoidReturning(0);
194 }
195 
196 // Tests mocking a nullary function.
197 TEST_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.
207 TEST_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.
217 TEST_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.
225 TEST_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.
234 TEST_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.
243 TEST_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.
253 TEST_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.
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) {
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.
306 TEST_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.
316 TEST_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.
327 TEST_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.
336 TEST_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 
343 TEST_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 
353 class MockB {
354  public:
355  MockB() {}
356 
357  MOCK_METHOD0(DoB, void());
358 
359  private:
361 };
362 
363 // Tests that functions with no EXPECT_CALL() ruls can be called any
364 // number of times.
365 TEST(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 
384 template <typename T>
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 
397 template <typename T>
398 class MockStack : public StackInterface<T> {
399  public:
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:
413 };
414 
415 // Tests that template mock works.
416 TEST(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 
438 TEST(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 
454 template <typename T>
455 class 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 
467 template <typename T>
468 class 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.
482 TEST(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 
511  public:
513 
515 
516  private:
518 };
519 
520 TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
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 
536  public:
538 
540 
541  private:
543 };
544 
545 TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
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 
555 TEST(MockFunctionTest, WorksForVoidNullary) {
556  MockFunction<void()> foo;
557  EXPECT_CALL(foo, Call());
558  foo.Call();
559 }
560 
561 TEST(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 
570 TEST(MockFunctionTest, WorksForVoidUnary) {
571  MockFunction<void(int)> foo;
572  EXPECT_CALL(foo, Call(1));
573  foo.Call(1);
574 }
575 
576 TEST(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 
588 TEST(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_
599 TEST(MockFunctionTest, AsStdFunction) {
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 
610 TEST(MockFunctionTest, AsStdFunctionReturnsReference) {
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