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 // Google Mock - a framework for writing C++ mock classes. 31 // 32 // This file tests the function mocker classes. 33 #include "gmock/gmock-function-mocker.h" 34 35 // Silence C4503 (decorated name length exceeded) for MSVC. 36 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503) 37 38 #ifdef 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 <functional> 46 #include <map> 47 #include <string> 48 #include <type_traits> 49 50 #include "gmock/gmock.h" 51 #include "gtest/gtest.h" 52 53 namespace testing { 54 namespace gmock_function_mocker_test { 55 56 using testing::_; 57 using testing::A; 58 using testing::An; 59 using testing::AnyNumber; 60 using testing::Const; 61 using testing::DoDefault; 62 using testing::Eq; 63 using testing::Lt; 64 using testing::MockFunction; 65 using testing::Ref; 66 using testing::Return; 67 using testing::ReturnRef; 68 using testing::TypedEq; 69 70 template <typename T> 71 class TemplatedCopyable { 72 public: 73 TemplatedCopyable() = default; 74 75 template <typename U> 76 TemplatedCopyable(const U& other) {} // NOLINT 77 }; 78 79 class FooInterface { 80 public: 81 virtual ~FooInterface() = default; 82 83 virtual void VoidReturning(int x) = 0; 84 85 virtual int Nullary() = 0; 86 virtual bool Unary(int x) = 0; 87 virtual long Binary(short x, int y) = 0; // NOLINT 88 virtual int Decimal(bool b, char c, short d, int e, long f, // NOLINT 89 float g, double h, unsigned i, char* j, 90 const std::string& k) = 0; 91 92 virtual bool TakesNonConstReference(int& n) = 0; // NOLINT 93 virtual std::string TakesConstReference(const int& n) = 0; 94 virtual bool TakesConst(const int x) = 0; 95 96 virtual int OverloadedOnArgumentNumber() = 0; 97 virtual int OverloadedOnArgumentNumber(int n) = 0; 98 99 virtual int OverloadedOnArgumentType(int n) = 0; 100 virtual char OverloadedOnArgumentType(char c) = 0; 101 102 virtual int OverloadedOnConstness() = 0; 103 virtual char OverloadedOnConstness() const = 0; 104 105 virtual int TypeWithHole(int (*func)()) = 0; 106 virtual int TypeWithComma(const std::map<int, std::string>& a_map) = 0; 107 virtual int TypeWithTemplatedCopyCtor(const TemplatedCopyable<int>&) = 0; 108 109 virtual int (*ReturnsFunctionPointer1(int))(bool) = 0; 110 using fn_ptr = int (*)(bool); 111 virtual fn_ptr ReturnsFunctionPointer2(int) = 0; 112 113 virtual int RefQualifiedConstRef() const& = 0; 114 virtual int RefQualifiedConstRefRef() const&& = 0; 115 virtual int RefQualifiedRef() & = 0; 116 virtual int RefQualifiedRefRef() && = 0; 117 118 virtual int RefQualifiedOverloaded() const& = 0; 119 virtual int RefQualifiedOverloaded() const&& = 0; 120 virtual int RefQualifiedOverloaded() & = 0; 121 virtual int RefQualifiedOverloaded() && = 0; 122 123 #ifdef GTEST_OS_WINDOWS 124 STDMETHOD_(int, CTNullary)() = 0; 125 STDMETHOD_(bool, CTUnary)(int x) = 0; 126 STDMETHOD_(int, CTDecimal) 127 (bool b, char c, short d, int e, long f, // NOLINT 128 float g, double h, unsigned i, char* j, const std::string& k) = 0; 129 STDMETHOD_(char, CTConst)(int x) const = 0; 130 #endif // GTEST_OS_WINDOWS 131 }; 132 133 // Const qualifiers on arguments were once (incorrectly) considered 134 // significant in determining whether two virtual functions had the same 135 // signature. This was fixed in Visual Studio 2008. However, the compiler 136 // still emits a warning that alerts about this change in behavior. 137 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4373) 138 class MockFoo : public FooInterface { 139 public: 140 MockFoo() = default; 141 142 // Makes sure that a mock function parameter can be named. 143 MOCK_METHOD(void, VoidReturning, (int n)); // NOLINT 144 145 MOCK_METHOD(int, Nullary, ()); // NOLINT 146 147 // Makes sure that a mock function parameter can be unnamed. 148 MOCK_METHOD(bool, Unary, (int)); // NOLINT 149 MOCK_METHOD(long, Binary, (short, int)); // NOLINT 150 MOCK_METHOD(int, Decimal, 151 (bool, char, short, int, long, float, // NOLINT 152 double, unsigned, char*, const std::string& str), 153 (override)); 154 155 MOCK_METHOD(bool, TakesNonConstReference, (int&)); // NOLINT 156 MOCK_METHOD(std::string, TakesConstReference, (const int&)); 157 MOCK_METHOD(bool, TakesConst, (const int)); // NOLINT 158 159 // Tests that the function return type can contain unprotected comma. 160 MOCK_METHOD((std::map<int, std::string>), ReturnTypeWithComma, (), ()); 161 MOCK_METHOD((std::map<int, std::string>), ReturnTypeWithComma, (int), 162 (const)); // NOLINT 163 164 MOCK_METHOD(int, OverloadedOnArgumentNumber, ()); // NOLINT 165 MOCK_METHOD(int, OverloadedOnArgumentNumber, (int)); // NOLINT 166 167 MOCK_METHOD(int, OverloadedOnArgumentType, (int)); // NOLINT 168 MOCK_METHOD(char, OverloadedOnArgumentType, (char)); // NOLINT 169 170 MOCK_METHOD(int, OverloadedOnConstness, (), (override)); // NOLINT 171 MOCK_METHOD(char, OverloadedOnConstness, (), (override, const)); // NOLINT 172 173 MOCK_METHOD(int, TypeWithHole, (int (*)()), ()); // NOLINT 174 MOCK_METHOD(int, TypeWithComma, ((const std::map<int, std::string>&))); 175 MOCK_METHOD(int, TypeWithTemplatedCopyCtor, 176 (const TemplatedCopyable<int>&)); // NOLINT 177 178 MOCK_METHOD(int (*)(bool), ReturnsFunctionPointer1, (int), ()); 179 MOCK_METHOD(fn_ptr, ReturnsFunctionPointer2, (int), ()); 180 181 #ifdef GTEST_OS_WINDOWS 182 MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE))); 183 MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE))); 184 MOCK_METHOD(int, CTDecimal, 185 (bool b, char c, short d, int e, long f, float g, double h, 186 unsigned i, char* j, const std::string& k), 187 (Calltype(STDMETHODCALLTYPE))); 188 MOCK_METHOD(char, CTConst, (int), (const, Calltype(STDMETHODCALLTYPE))); 189 MOCK_METHOD((std::map<int, std::string>), CTReturnTypeWithComma, (), 190 (Calltype(STDMETHODCALLTYPE))); 191 #endif // GTEST_OS_WINDOWS 192 193 // Test reference qualified functions. 194 MOCK_METHOD(int, RefQualifiedConstRef, (), (const, ref(&), override)); 195 MOCK_METHOD(int, RefQualifiedConstRefRef, (), (const, ref(&&), override)); 196 MOCK_METHOD(int, RefQualifiedRef, (), (ref(&), override)); 197 MOCK_METHOD(int, RefQualifiedRefRef, (), (ref(&&), override)); 198 199 MOCK_METHOD(int, RefQualifiedOverloaded, (), (const, ref(&), override)); 200 MOCK_METHOD(int, RefQualifiedOverloaded, (), (const, ref(&&), override)); 201 MOCK_METHOD(int, RefQualifiedOverloaded, (), (ref(&), override)); 202 MOCK_METHOD(int, RefQualifiedOverloaded, (), (ref(&&), override)); 203 204 private: 205 MockFoo(const MockFoo&) = delete; 206 MockFoo& operator=(const MockFoo&) = delete; 207 }; 208 209 class LegacyMockFoo : public FooInterface { 210 public: 211 LegacyMockFoo() = default; 212 213 // Makes sure that a mock function parameter can be named. 214 MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT 215 216 MOCK_METHOD0(Nullary, int()); // NOLINT 217 218 // Makes sure that a mock function parameter can be unnamed. 219 MOCK_METHOD1(Unary, bool(int)); // NOLINT 220 MOCK_METHOD2(Binary, long(short, int)); // NOLINT 221 MOCK_METHOD10(Decimal, int(bool, char, short, int, long, float, // NOLINT 222 double, unsigned, char*, const std::string& str)); 223 224 MOCK_METHOD1(TakesNonConstReference, bool(int&)); // NOLINT 225 MOCK_METHOD1(TakesConstReference, std::string(const int&)); 226 MOCK_METHOD1(TakesConst, bool(const int)); // NOLINT 227 228 // Tests that the function return type can contain unprotected comma. 229 MOCK_METHOD0(ReturnTypeWithComma, std::map<int, std::string>()); 230 MOCK_CONST_METHOD1(ReturnTypeWithComma, 231 std::map<int, std::string>(int)); // NOLINT 232 233 MOCK_METHOD0(OverloadedOnArgumentNumber, int()); // NOLINT 234 MOCK_METHOD1(OverloadedOnArgumentNumber, int(int)); // NOLINT 235 236 MOCK_METHOD1(OverloadedOnArgumentType, int(int)); // NOLINT 237 MOCK_METHOD1(OverloadedOnArgumentType, char(char)); // NOLINT 238 239 MOCK_METHOD0(OverloadedOnConstness, int()); // NOLINT 240 MOCK_CONST_METHOD0(OverloadedOnConstness, char()); // NOLINT 241 242 MOCK_METHOD1(TypeWithHole, int(int (*)())); // NOLINT 243 MOCK_METHOD1(TypeWithComma, 244 int(const std::map<int, std::string>&)); // NOLINT 245 MOCK_METHOD1(TypeWithTemplatedCopyCtor, 246 int(const TemplatedCopyable<int>&)); // NOLINT 247 248 MOCK_METHOD1(ReturnsFunctionPointer1, int (*(int))(bool)); 249 MOCK_METHOD1(ReturnsFunctionPointer2, fn_ptr(int)); 250 251 #ifdef GTEST_OS_WINDOWS 252 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int()); 253 MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int)); // NOLINT 254 MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, 255 int(bool b, char c, short d, int e, // NOLINT 256 long f, float g, double h, // NOLINT 257 unsigned i, char* j, const std::string& k)); 258 MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, 259 char(int)); // NOLINT 260 261 // Tests that the function return type can contain unprotected comma. 262 MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTReturnTypeWithComma, 263 std::map<int, std::string>()); 264 #endif // GTEST_OS_WINDOWS 265 266 // We can't mock these with the old macros, but we need to define them to make 267 // it concrete. 268 int RefQualifiedConstRef() const& override { return 0; } 269 int RefQualifiedConstRefRef() const&& override { return 0; } 270 int RefQualifiedRef() & override { return 0; } 271 int RefQualifiedRefRef() && override { return 0; } 272 int RefQualifiedOverloaded() const& override { return 0; } 273 int RefQualifiedOverloaded() const&& override { return 0; } 274 int RefQualifiedOverloaded() & override { return 0; } 275 int RefQualifiedOverloaded() && override { return 0; } 276 277 private: 278 LegacyMockFoo(const LegacyMockFoo&) = delete; 279 LegacyMockFoo& operator=(const LegacyMockFoo&) = delete; 280 }; 281 282 GTEST_DISABLE_MSC_WARNINGS_POP_() // 4373 283 284 template <class T> 285 class FunctionMockerTest : public testing::Test { 286 protected: 287 FunctionMockerTest() : foo_(&mock_foo_) {} 288 289 FooInterface* const foo_; 290 T mock_foo_; 291 }; 292 using FunctionMockerTestTypes = ::testing::Types<MockFoo, LegacyMockFoo>; 293 TYPED_TEST_SUITE(FunctionMockerTest, FunctionMockerTestTypes); 294 295 // Tests mocking a void-returning function. 296 TYPED_TEST(FunctionMockerTest, MocksVoidFunction) { 297 EXPECT_CALL(this->mock_foo_, VoidReturning(Lt(100))); 298 this->foo_->VoidReturning(0); 299 } 300 301 // Tests mocking a nullary function. 302 TYPED_TEST(FunctionMockerTest, MocksNullaryFunction) { 303 EXPECT_CALL(this->mock_foo_, Nullary()) 304 .WillOnce(DoDefault()) 305 .WillOnce(Return(1)); 306 307 EXPECT_EQ(0, this->foo_->Nullary()); 308 EXPECT_EQ(1, this->foo_->Nullary()); 309 } 310 311 // Tests mocking a unary function. 312 TYPED_TEST(FunctionMockerTest, MocksUnaryFunction) { 313 EXPECT_CALL(this->mock_foo_, Unary(Eq(2))).Times(2).WillOnce(Return(true)); 314 315 EXPECT_TRUE(this->foo_->Unary(2)); 316 EXPECT_FALSE(this->foo_->Unary(2)); 317 } 318 319 // Tests mocking a binary function. 320 TYPED_TEST(FunctionMockerTest, MocksBinaryFunction) { 321 EXPECT_CALL(this->mock_foo_, Binary(2, _)).WillOnce(Return(3)); 322 323 EXPECT_EQ(3, this->foo_->Binary(2, 1)); 324 } 325 326 // Tests mocking a decimal function. 327 TYPED_TEST(FunctionMockerTest, MocksDecimalFunction) { 328 EXPECT_CALL(this->mock_foo_, 329 Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100), 5U, NULL, "hi")) 330 .WillOnce(Return(5)); 331 332 EXPECT_EQ(5, this->foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi")); 333 } 334 335 // Tests mocking a function that takes a non-const reference. 336 TYPED_TEST(FunctionMockerTest, MocksFunctionWithNonConstReferenceArgument) { 337 int a = 0; 338 EXPECT_CALL(this->mock_foo_, TakesNonConstReference(Ref(a))) 339 .WillOnce(Return(true)); 340 341 EXPECT_TRUE(this->foo_->TakesNonConstReference(a)); 342 } 343 344 // Tests mocking a function that takes a const reference. 345 TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstReferenceArgument) { 346 int a = 0; 347 EXPECT_CALL(this->mock_foo_, TakesConstReference(Ref(a))) 348 .WillOnce(Return("Hello")); 349 350 EXPECT_EQ("Hello", this->foo_->TakesConstReference(a)); 351 } 352 353 // Tests mocking a function that takes a const variable. 354 TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstArgument) { 355 EXPECT_CALL(this->mock_foo_, TakesConst(Lt(10))).WillOnce(DoDefault()); 356 357 EXPECT_FALSE(this->foo_->TakesConst(5)); 358 } 359 360 // Tests mocking functions overloaded on the number of arguments. 361 TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) { 362 EXPECT_CALL(this->mock_foo_, OverloadedOnArgumentNumber()) 363 .WillOnce(Return(1)); 364 EXPECT_CALL(this->mock_foo_, OverloadedOnArgumentNumber(_)) 365 .WillOnce(Return(2)); 366 367 EXPECT_EQ(2, this->foo_->OverloadedOnArgumentNumber(1)); 368 EXPECT_EQ(1, this->foo_->OverloadedOnArgumentNumber()); 369 } 370 371 // Tests mocking functions overloaded on the types of argument. 372 TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) { 373 EXPECT_CALL(this->mock_foo_, OverloadedOnArgumentType(An<int>())) 374 .WillOnce(Return(1)); 375 EXPECT_CALL(this->mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a'))) 376 .WillOnce(Return('b')); 377 378 EXPECT_EQ(1, this->foo_->OverloadedOnArgumentType(0)); 379 EXPECT_EQ('b', this->foo_->OverloadedOnArgumentType('a')); 380 } 381 382 // Tests mocking functions overloaded on the const-ness of this object. 383 TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOfThis) { 384 EXPECT_CALL(this->mock_foo_, OverloadedOnConstness()); 385 EXPECT_CALL(Const(this->mock_foo_), OverloadedOnConstness()) 386 .WillOnce(Return('a')); 387 388 EXPECT_EQ(0, this->foo_->OverloadedOnConstness()); 389 EXPECT_EQ('a', Const(*this->foo_).OverloadedOnConstness()); 390 } 391 392 TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithComma) { 393 const std::map<int, std::string> a_map; 394 EXPECT_CALL(this->mock_foo_, ReturnTypeWithComma()).WillOnce(Return(a_map)); 395 EXPECT_CALL(this->mock_foo_, ReturnTypeWithComma(42)).WillOnce(Return(a_map)); 396 397 EXPECT_EQ(a_map, this->mock_foo_.ReturnTypeWithComma()); 398 EXPECT_EQ(a_map, this->mock_foo_.ReturnTypeWithComma(42)); 399 } 400 401 TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) { 402 EXPECT_CALL(this->mock_foo_, TypeWithTemplatedCopyCtor(_)) 403 .WillOnce(Return(true)); 404 EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>())); 405 } 406 407 #ifdef GTEST_OS_WINDOWS 408 // Tests mocking a nullary function with calltype. 409 TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) { 410 EXPECT_CALL(this->mock_foo_, CTNullary()) 411 .WillOnce(Return(-1)) 412 .WillOnce(Return(0)); 413 414 EXPECT_EQ(-1, this->foo_->CTNullary()); 415 EXPECT_EQ(0, this->foo_->CTNullary()); 416 } 417 418 // Tests mocking a unary function with calltype. 419 TYPED_TEST(FunctionMockerTest, MocksUnaryFunctionWithCallType) { 420 EXPECT_CALL(this->mock_foo_, CTUnary(Eq(2))) 421 .Times(2) 422 .WillOnce(Return(true)) 423 .WillOnce(Return(false)); 424 425 EXPECT_TRUE(this->foo_->CTUnary(2)); 426 EXPECT_FALSE(this->foo_->CTUnary(2)); 427 } 428 429 // Tests mocking a decimal function with calltype. 430 TYPED_TEST(FunctionMockerTest, MocksDecimalFunctionWithCallType) { 431 EXPECT_CALL(this->mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(), 432 Lt(100), 5U, NULL, "hi")) 433 .WillOnce(Return(10)); 434 435 EXPECT_EQ(10, this->foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi")); 436 } 437 438 // Tests mocking functions overloaded on the const-ness of this object. 439 TYPED_TEST(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) { 440 EXPECT_CALL(Const(this->mock_foo_), CTConst(_)).WillOnce(Return('a')); 441 442 EXPECT_EQ('a', Const(*this->foo_).CTConst(0)); 443 } 444 445 TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) { 446 const std::map<int, std::string> a_map; 447 EXPECT_CALL(this->mock_foo_, CTReturnTypeWithComma()).WillOnce(Return(a_map)); 448 449 EXPECT_EQ(a_map, this->mock_foo_.CTReturnTypeWithComma()); 450 } 451 452 #endif // GTEST_OS_WINDOWS 453 454 TEST(FunctionMockerTest, RefQualified) { 455 MockFoo mock_foo; 456 457 EXPECT_CALL(mock_foo, RefQualifiedConstRef).WillOnce(Return(1)); 458 EXPECT_CALL(std::move(mock_foo), // NOLINT 459 RefQualifiedConstRefRef) 460 .WillOnce(Return(2)); 461 EXPECT_CALL(mock_foo, RefQualifiedRef).WillOnce(Return(3)); 462 EXPECT_CALL(std::move(mock_foo), // NOLINT 463 RefQualifiedRefRef) 464 .WillOnce(Return(4)); 465 466 EXPECT_CALL(static_cast<const MockFoo&>(mock_foo), RefQualifiedOverloaded()) 467 .WillOnce(Return(5)); 468 EXPECT_CALL(static_cast<const MockFoo&&>(mock_foo), RefQualifiedOverloaded()) 469 .WillOnce(Return(6)); 470 EXPECT_CALL(static_cast<MockFoo&>(mock_foo), RefQualifiedOverloaded()) 471 .WillOnce(Return(7)); 472 EXPECT_CALL(static_cast<MockFoo&&>(mock_foo), RefQualifiedOverloaded()) 473 .WillOnce(Return(8)); 474 475 EXPECT_EQ(mock_foo.RefQualifiedConstRef(), 1); 476 EXPECT_EQ(std::move(mock_foo).RefQualifiedConstRefRef(), 2); // NOLINT 477 EXPECT_EQ(mock_foo.RefQualifiedRef(), 3); 478 EXPECT_EQ(std::move(mock_foo).RefQualifiedRefRef(), 4); // NOLINT 479 480 EXPECT_EQ(std::cref(mock_foo).get().RefQualifiedOverloaded(), 5); 481 EXPECT_EQ(std::move(std::cref(mock_foo).get()) // NOLINT 482 .RefQualifiedOverloaded(), 483 6); 484 EXPECT_EQ(mock_foo.RefQualifiedOverloaded(), 7); 485 EXPECT_EQ(std::move(mock_foo).RefQualifiedOverloaded(), 8); // NOLINT 486 } 487 488 class MockB { 489 public: 490 MockB() = default; 491 492 MOCK_METHOD(void, DoB, ()); 493 494 private: 495 MockB(const MockB&) = delete; 496 MockB& operator=(const MockB&) = delete; 497 }; 498 499 class LegacyMockB { 500 public: 501 LegacyMockB() = default; 502 503 MOCK_METHOD0(DoB, void()); 504 505 private: 506 LegacyMockB(const LegacyMockB&) = delete; 507 LegacyMockB& operator=(const LegacyMockB&) = delete; 508 }; 509 510 template <typename T> 511 class ExpectCallTest : public ::testing::Test {}; 512 using ExpectCallTestTypes = ::testing::Types<MockB, LegacyMockB>; 513 TYPED_TEST_SUITE(ExpectCallTest, ExpectCallTestTypes); 514 515 // Tests that functions with no EXPECT_CALL() rules can be called any 516 // number of times. 517 TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) { 518 { TypeParam b; } 519 520 { 521 TypeParam b; 522 b.DoB(); 523 } 524 525 { 526 TypeParam b; 527 b.DoB(); 528 b.DoB(); 529 } 530 } 531 532 // Tests mocking template interfaces. 533 534 template <typename T> 535 class StackInterface { 536 public: 537 virtual ~StackInterface() = default; 538 539 // Template parameter appears in function parameter. 540 virtual void Push(const T& value) = 0; 541 virtual void Pop() = 0; 542 virtual int GetSize() const = 0; 543 // Template parameter appears in function return type. 544 virtual const T& GetTop() const = 0; 545 }; 546 547 template <typename T> 548 class MockStack : public StackInterface<T> { 549 public: 550 MockStack() = default; 551 552 MOCK_METHOD(void, Push, (const T& elem), ()); 553 MOCK_METHOD(void, Pop, (), (final)); 554 MOCK_METHOD(int, GetSize, (), (const, override)); 555 MOCK_METHOD(const T&, GetTop, (), (const)); 556 557 // Tests that the function return type can contain unprotected comma. 558 MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (), ()); 559 MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (int), (const)); 560 561 private: 562 MockStack(const MockStack&) = delete; 563 MockStack& operator=(const MockStack&) = delete; 564 }; 565 566 template <typename T> 567 class LegacyMockStack : public StackInterface<T> { 568 public: 569 LegacyMockStack() = default; 570 571 MOCK_METHOD1_T(Push, void(const T& elem)); 572 MOCK_METHOD0_T(Pop, void()); 573 MOCK_CONST_METHOD0_T(GetSize, int()); // NOLINT 574 MOCK_CONST_METHOD0_T(GetTop, const T&()); 575 576 // Tests that the function return type can contain unprotected comma. 577 MOCK_METHOD0_T(ReturnTypeWithComma, std::map<int, int>()); 578 MOCK_CONST_METHOD1_T(ReturnTypeWithComma, std::map<int, int>(int)); // NOLINT 579 580 private: 581 LegacyMockStack(const LegacyMockStack&) = delete; 582 LegacyMockStack& operator=(const LegacyMockStack&) = delete; 583 }; 584 585 template <typename T> 586 class TemplateMockTest : public ::testing::Test {}; 587 using TemplateMockTestTypes = 588 ::testing::Types<MockStack<int>, LegacyMockStack<int>>; 589 TYPED_TEST_SUITE(TemplateMockTest, TemplateMockTestTypes); 590 591 // Tests that template mock works. 592 TYPED_TEST(TemplateMockTest, Works) { 593 TypeParam mock; 594 595 EXPECT_CALL(mock, GetSize()) 596 .WillOnce(Return(0)) 597 .WillOnce(Return(1)) 598 .WillOnce(Return(0)); 599 EXPECT_CALL(mock, Push(_)); 600 int n = 5; 601 EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n)); 602 EXPECT_CALL(mock, Pop()).Times(AnyNumber()); 603 604 EXPECT_EQ(0, mock.GetSize()); 605 mock.Push(5); 606 EXPECT_EQ(1, mock.GetSize()); 607 EXPECT_EQ(5, mock.GetTop()); 608 mock.Pop(); 609 EXPECT_EQ(0, mock.GetSize()); 610 } 611 612 TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) { 613 TypeParam mock; 614 615 const std::map<int, int> a_map; 616 EXPECT_CALL(mock, ReturnTypeWithComma()).WillOnce(Return(a_map)); 617 EXPECT_CALL(mock, ReturnTypeWithComma(1)).WillOnce(Return(a_map)); 618 619 EXPECT_EQ(a_map, mock.ReturnTypeWithComma()); 620 EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1)); 621 } 622 623 #ifdef GTEST_OS_WINDOWS 624 // Tests mocking template interfaces with calltype. 625 626 template <typename T> 627 class StackInterfaceWithCallType { 628 public: 629 virtual ~StackInterfaceWithCallType() {} 630 631 // Template parameter appears in function parameter. 632 STDMETHOD_(void, Push)(const T& value) = 0; 633 STDMETHOD_(void, Pop)() = 0; 634 STDMETHOD_(int, GetSize)() const = 0; 635 // Template parameter appears in function return type. 636 STDMETHOD_(const T&, GetTop)() const = 0; 637 }; 638 639 template <typename T> 640 class MockStackWithCallType : public StackInterfaceWithCallType<T> { 641 public: 642 MockStackWithCallType() {} 643 644 MOCK_METHOD(void, Push, (const T& elem), 645 (Calltype(STDMETHODCALLTYPE), override)); 646 MOCK_METHOD(void, Pop, (), (Calltype(STDMETHODCALLTYPE), override)); 647 MOCK_METHOD(int, GetSize, (), (Calltype(STDMETHODCALLTYPE), override, const)); 648 MOCK_METHOD(const T&, GetTop, (), 649 (Calltype(STDMETHODCALLTYPE), override, const)); 650 651 private: 652 MockStackWithCallType(const MockStackWithCallType&) = delete; 653 MockStackWithCallType& operator=(const MockStackWithCallType&) = delete; 654 }; 655 656 template <typename T> 657 class LegacyMockStackWithCallType : public StackInterfaceWithCallType<T> { 658 public: 659 LegacyMockStackWithCallType() {} 660 661 MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem)); 662 MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void()); 663 MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int()); 664 MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&()); 665 666 private: 667 LegacyMockStackWithCallType(const LegacyMockStackWithCallType&) = delete; 668 LegacyMockStackWithCallType& operator=(const LegacyMockStackWithCallType&) = 669 delete; 670 }; 671 672 template <typename T> 673 class TemplateMockTestWithCallType : public ::testing::Test {}; 674 using TemplateMockTestWithCallTypeTypes = 675 ::testing::Types<MockStackWithCallType<int>, 676 LegacyMockStackWithCallType<int>>; 677 TYPED_TEST_SUITE(TemplateMockTestWithCallType, 678 TemplateMockTestWithCallTypeTypes); 679 680 // Tests that template mock with calltype works. 681 TYPED_TEST(TemplateMockTestWithCallType, Works) { 682 TypeParam mock; 683 684 EXPECT_CALL(mock, GetSize()) 685 .WillOnce(Return(0)) 686 .WillOnce(Return(1)) 687 .WillOnce(Return(0)); 688 EXPECT_CALL(mock, Push(_)); 689 int n = 5; 690 EXPECT_CALL(mock, GetTop()).WillOnce(ReturnRef(n)); 691 EXPECT_CALL(mock, Pop()).Times(AnyNumber()); 692 693 EXPECT_EQ(0, mock.GetSize()); 694 mock.Push(5); 695 EXPECT_EQ(1, mock.GetSize()); 696 EXPECT_EQ(5, mock.GetTop()); 697 mock.Pop(); 698 EXPECT_EQ(0, mock.GetSize()); 699 } 700 #endif // GTEST_OS_WINDOWS 701 702 #define MY_MOCK_METHODS1_ \ 703 MOCK_METHOD(void, Overloaded, ()); \ 704 MOCK_METHOD(int, Overloaded, (int), (const)); \ 705 MOCK_METHOD(bool, Overloaded, (bool f, int n)) 706 707 #define LEGACY_MY_MOCK_METHODS1_ \ 708 MOCK_METHOD0(Overloaded, void()); \ 709 MOCK_CONST_METHOD1(Overloaded, int(int n)); \ 710 MOCK_METHOD2(Overloaded, bool(bool f, int n)) 711 712 class MockOverloadedOnArgNumber { 713 public: 714 MockOverloadedOnArgNumber() = default; 715 716 MY_MOCK_METHODS1_; 717 718 private: 719 MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete; 720 MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumber&) = 721 delete; 722 }; 723 724 class LegacyMockOverloadedOnArgNumber { 725 public: 726 LegacyMockOverloadedOnArgNumber() = default; 727 728 LEGACY_MY_MOCK_METHODS1_; 729 730 private: 731 LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNumber&) = 732 delete; 733 LegacyMockOverloadedOnArgNumber& operator=( 734 const LegacyMockOverloadedOnArgNumber&) = delete; 735 }; 736 737 template <typename T> 738 class OverloadedMockMethodTest : public ::testing::Test {}; 739 using OverloadedMockMethodTestTypes = 740 ::testing::Types<MockOverloadedOnArgNumber, 741 LegacyMockOverloadedOnArgNumber>; 742 TYPED_TEST_SUITE(OverloadedMockMethodTest, OverloadedMockMethodTestTypes); 743 744 TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) { 745 TypeParam mock; 746 EXPECT_CALL(mock, Overloaded()); 747 EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); 748 EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true)); 749 750 mock.Overloaded(); 751 EXPECT_EQ(2, mock.Overloaded(1)); 752 EXPECT_TRUE(mock.Overloaded(true, 1)); 753 } 754 755 #define MY_MOCK_METHODS2_ \ 756 MOCK_CONST_METHOD1(Overloaded, int(int n)); \ 757 MOCK_METHOD1(Overloaded, int(int n)) 758 759 class MockOverloadedOnConstness { 760 public: 761 MockOverloadedOnConstness() = default; 762 763 MY_MOCK_METHODS2_; 764 765 private: 766 MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete; 767 MockOverloadedOnConstness& operator=(const MockOverloadedOnConstness&) = 768 delete; 769 }; 770 771 TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) { 772 MockOverloadedOnConstness mock; 773 const MockOverloadedOnConstness* const_mock = &mock; 774 EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); 775 EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3)); 776 777 EXPECT_EQ(2, mock.Overloaded(1)); 778 EXPECT_EQ(3, const_mock->Overloaded(1)); 779 } 780 781 TEST(MockMethodMockFunctionTest, WorksForVoidNullary) { 782 MockFunction<void()> foo; 783 EXPECT_CALL(foo, Call()); 784 foo.Call(); 785 } 786 787 TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) { 788 MockFunction<int()> foo; 789 EXPECT_CALL(foo, Call()).WillOnce(Return(1)).WillOnce(Return(2)); 790 EXPECT_EQ(1, foo.Call()); 791 EXPECT_EQ(2, foo.Call()); 792 } 793 794 TEST(MockMethodMockFunctionTest, WorksForVoidUnary) { 795 MockFunction<void(int)> foo; 796 EXPECT_CALL(foo, Call(1)); 797 foo.Call(1); 798 } 799 800 TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) { 801 MockFunction<int(bool, int)> foo; 802 EXPECT_CALL(foo, Call(false, 42)).WillOnce(Return(1)).WillOnce(Return(2)); 803 EXPECT_CALL(foo, Call(true, Ge(100))).WillOnce(Return(3)); 804 EXPECT_EQ(1, foo.Call(false, 42)); 805 EXPECT_EQ(2, foo.Call(false, 42)); 806 EXPECT_EQ(3, foo.Call(true, 120)); 807 } 808 809 TEST(MockMethodMockFunctionTest, WorksFor10Arguments) { 810 MockFunction<int(bool a0, char a1, int a2, int a3, int a4, int a5, int a6, 811 char a7, int a8, bool a9)> 812 foo; 813 EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _)) 814 .WillOnce(Return(1)) 815 .WillOnce(Return(2)); 816 EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true)); 817 EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false)); 818 } 819 820 TEST(MockMethodMockFunctionTest, AsStdFunction) { 821 MockFunction<int(int)> foo; 822 auto call = [](const std::function<int(int)>& f, int i) { return f(i); }; 823 EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1)); 824 EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2)); 825 EXPECT_EQ(-1, call(foo.AsStdFunction(), 1)); 826 EXPECT_EQ(-2, call(foo.AsStdFunction(), 2)); 827 } 828 829 TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) { 830 MockFunction<int&()> foo; 831 int value = 1; 832 EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value)); 833 int& ref = foo.AsStdFunction()(); 834 EXPECT_EQ(1, ref); 835 value = 2; 836 EXPECT_EQ(2, ref); 837 } 838 839 TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) { 840 MockFunction<int(int&)> foo; 841 auto call = [](const std::function<int(int&)>& f, int& i) { return f(i); }; 842 int i = 42; 843 EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1)); 844 EXPECT_EQ(-1, call(foo.AsStdFunction(), i)); 845 } 846 847 namespace { 848 849 template <typename Expected, typename F> 850 static constexpr bool IsMockFunctionTemplateArgumentDeducedTo( 851 const internal::MockFunction<F>&) { 852 return std::is_same<F, Expected>::value; 853 } 854 855 } // namespace 856 857 template <typename F> 858 class MockMethodMockFunctionSignatureTest : public Test {}; 859 860 using MockMethodMockFunctionSignatureTypes = 861 Types<void(), int(), void(int), int(int), int(bool, int), 862 int(bool, char, int, int, int, int, int, char, int, bool)>; 863 TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest, 864 MockMethodMockFunctionSignatureTypes); 865 866 TYPED_TEST(MockMethodMockFunctionSignatureTest, 867 IsMockFunctionTemplateArgumentDeducedForRawSignature) { 868 using Argument = TypeParam; 869 MockFunction<Argument> foo; 870 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo)); 871 } 872 873 TYPED_TEST(MockMethodMockFunctionSignatureTest, 874 IsMockFunctionTemplateArgumentDeducedForStdFunction) { 875 using Argument = std::function<TypeParam>; 876 MockFunction<Argument> foo; 877 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo)); 878 } 879 880 TYPED_TEST( 881 MockMethodMockFunctionSignatureTest, 882 IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) { 883 using ForRawSignature = decltype(&MockFunction<TypeParam>::Call); 884 using ForStdFunction = 885 decltype(&MockFunction<std::function<TypeParam>>::Call); 886 EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value)); 887 } 888 889 template <typename F> 890 struct AlternateCallable {}; 891 892 TYPED_TEST(MockMethodMockFunctionSignatureTest, 893 IsMockFunctionTemplateArgumentDeducedForAlternateCallable) { 894 using Argument = AlternateCallable<TypeParam>; 895 MockFunction<Argument> foo; 896 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo)); 897 } 898 899 TYPED_TEST(MockMethodMockFunctionSignatureTest, 900 IsMockFunctionCallMethodSignatureTheSameForAlternateCallable) { 901 using ForRawSignature = decltype(&MockFunction<TypeParam>::Call); 902 using ForStdFunction = 903 decltype(&MockFunction<std::function<TypeParam>>::Call); 904 EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value)); 905 } 906 907 struct MockMethodSizes0 { 908 MOCK_METHOD(void, func, ()); 909 }; 910 struct MockMethodSizes1 { 911 MOCK_METHOD(void, func, (int)); 912 }; 913 struct MockMethodSizes2 { 914 MOCK_METHOD(void, func, (int, int)); 915 }; 916 struct MockMethodSizes3 { 917 MOCK_METHOD(void, func, (int, int, int)); 918 }; 919 struct MockMethodSizes4 { 920 MOCK_METHOD(void, func, (int, int, int, int)); 921 }; 922 923 struct LegacyMockMethodSizes0 { 924 MOCK_METHOD0(func, void()); 925 }; 926 struct LegacyMockMethodSizes1 { 927 MOCK_METHOD1(func, void(int)); 928 }; 929 struct LegacyMockMethodSizes2 { 930 MOCK_METHOD2(func, void(int, int)); 931 }; 932 struct LegacyMockMethodSizes3 { 933 MOCK_METHOD3(func, void(int, int, int)); 934 }; 935 struct LegacyMockMethodSizes4 { 936 MOCK_METHOD4(func, void(int, int, int, int)); 937 }; 938 939 TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) { 940 EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1)); 941 EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2)); 942 EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes3)); 943 EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes4)); 944 945 EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes1)); 946 EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes2)); 947 EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes3)); 948 EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(LegacyMockMethodSizes4)); 949 950 EXPECT_EQ(sizeof(LegacyMockMethodSizes0), sizeof(MockMethodSizes0)); 951 } 952 953 TEST(MockMethodMockFunctionTest, EnsureNoUnusedMemberFunction) { 954 #ifdef __clang__ 955 #pragma clang diagnostic push 956 #pragma clang diagnostic error "-Wunused-member-function" 957 #endif 958 // https://github.com/google/googletest/issues/4052 959 struct Foo { 960 MOCK_METHOD(void, foo, ()); 961 }; 962 EXPECT_CALL(Foo(), foo()).Times(0); 963 #ifdef __clang__ 964 #pragma clang diagnostic pop 965 #endif 966 } 967 968 void hasTwoParams(int, int); 969 void MaybeThrows(); 970 void DoesntThrow() noexcept; 971 struct MockMethodNoexceptSpecifier { 972 MOCK_METHOD(void, func1, (), (noexcept)); 973 MOCK_METHOD(void, func2, (), (noexcept(true))); 974 MOCK_METHOD(void, func3, (), (noexcept(false))); 975 MOCK_METHOD(void, func4, (), (noexcept(noexcept(MaybeThrows())))); 976 MOCK_METHOD(void, func5, (), (noexcept(noexcept(DoesntThrow())))); 977 MOCK_METHOD(void, func6, (), (noexcept(noexcept(DoesntThrow())), const)); 978 MOCK_METHOD(void, func7, (), (const, noexcept(noexcept(DoesntThrow())))); 979 // Put commas in the noexcept expression 980 MOCK_METHOD(void, func8, (), (noexcept(noexcept(hasTwoParams(1, 2))), const)); 981 }; 982 983 TEST(MockMethodMockFunctionTest, NoexceptSpecifierPreserved) { 984 EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func1())); 985 EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func2())); 986 EXPECT_FALSE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func3())); 987 EXPECT_FALSE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func4())); 988 EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func5())); 989 EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func6())); 990 EXPECT_TRUE(noexcept(std::declval<MockMethodNoexceptSpecifier>().func7())); 991 EXPECT_EQ(noexcept(std::declval<MockMethodNoexceptSpecifier>().func8()), 992 noexcept(hasTwoParams(1, 2))); 993 } 994 995 } // namespace gmock_function_mocker_test 996 } // namespace testing 997 998 GTEST_DISABLE_MSC_WARNINGS_POP_() // 4503 999