ut/gtest/googlemock/test/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
  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
  57 namespace testing {
  58 namespace gmock_generated_function_mockers_test {
  59
  60 using testing::internal::string;
  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:
 176   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 177 };
 178 #ifdef _MSC_VER
 179 # pragma warning(pop)
 180 #endif
 181
 182 class 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.
 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:
 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.
 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>
 385 class 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
 397 template <typename T>
 398 class 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.
 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
 510 class MockOverloadedOnArgNumber {
 511  public:
 512   MockOverloadedOnArgNumber() {}
 513
 514   MY_MOCK_METHODS1_;
 515
 516  private:
 517   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
 518 };
 519
 520 TEST(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
 535 class MockOverloadedOnConstness {
 536  public:
 537   MockOverloadedOnConstness() {}
 538
 539   MY_MOCK_METHODS2_;
 540
 541  private:
 542   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
 543 };
 544
 545 TEST(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
 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) {
 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
 610 TEST(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