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>
TemplatedCopyable(const U & other)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.
RefQualifiedConstRef() const268 int RefQualifiedConstRef() const& override { return 0; }
RefQualifiedConstRefRef() const269 int RefQualifiedConstRefRef() const&& override { return 0; }
RefQualifiedRef()270 int RefQualifiedRef() & override { return 0; }
RefQualifiedRefRef()271 int RefQualifiedRefRef() && override { return 0; }
RefQualifiedOverloaded() const272 int RefQualifiedOverloaded() const& override { return 0; }
RefQualifiedOverloaded() const273 int RefQualifiedOverloaded() const&& override { return 0; }
RefQualifiedOverloaded()274 int RefQualifiedOverloaded() & override { return 0; }
RefQualifiedOverloaded()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:
FunctionMockerTest()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.
TYPED_TEST(FunctionMockerTest,MocksVoidFunction)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.
TYPED_TEST(FunctionMockerTest,MocksNullaryFunction)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.
TYPED_TEST(FunctionMockerTest,MocksUnaryFunction)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.
TYPED_TEST(FunctionMockerTest,MocksBinaryFunction)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.
TYPED_TEST(FunctionMockerTest,MocksDecimalFunction)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionWithNonConstReferenceArgument)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionWithConstReferenceArgument)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionWithConstArgument)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionsOverloadedOnArgumentNumber)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionsOverloadedOnArgumentType)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionsOverloadedOnConstnessOfThis)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
TYPED_TEST(FunctionMockerTest,MocksReturnTypeWithComma)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
TYPED_TEST(FunctionMockerTest,MocksTypeWithTemplatedCopyCtor)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.
TYPED_TEST(FunctionMockerTest,MocksNullaryFunctionWithCallType)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.
TYPED_TEST(FunctionMockerTest,MocksUnaryFunctionWithCallType)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.
TYPED_TEST(FunctionMockerTest,MocksDecimalFunctionWithCallType)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.
TYPED_TEST(FunctionMockerTest,MocksFunctionsConstFunctionWithCallType)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
TYPED_TEST(FunctionMockerTest,MocksReturnTypeWithCommaAndCallType)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
TEST(FunctionMockerTest,RefQualified)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.
TYPED_TEST(ExpectCallTest,UnmentionedFunctionCanBeCalledAnyNumberOfTimes)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.
TYPED_TEST(TemplateMockTest,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
TYPED_TEST(TemplateMockTest,MethodWithCommaInReturnTypeWorks)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:
~StackInterfaceWithCallType()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:
MockStackWithCallType()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:
LegacyMockStackWithCallType()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.
TYPED_TEST(TemplateMockTestWithCallType,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
TYPED_TEST(OverloadedMockMethodTest,CanOverloadOnArgNumberInMacroBody)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
TEST(MockMethodOverloadedMockMethodTest,CanOverloadOnConstnessInMacroBody)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
TEST(MockMethodMockFunctionTest,WorksForVoidNullary)781 TEST(MockMethodMockFunctionTest, WorksForVoidNullary) {
782 MockFunction<void()> foo;
783 EXPECT_CALL(foo, Call());
784 foo.Call();
785 }
786
TEST(MockMethodMockFunctionTest,WorksForNonVoidNullary)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
TEST(MockMethodMockFunctionTest,WorksForVoidUnary)794 TEST(MockMethodMockFunctionTest, WorksForVoidUnary) {
795 MockFunction<void(int)> foo;
796 EXPECT_CALL(foo, Call(1));
797 foo.Call(1);
798 }
799
TEST(MockMethodMockFunctionTest,WorksForNonVoidBinary)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
TEST(MockMethodMockFunctionTest,WorksFor10Arguments)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
TEST(MockMethodMockFunctionTest,AsStdFunction)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
TEST(MockMethodMockFunctionTest,AsStdFunctionReturnsReference)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
TEST(MockMethodMockFunctionTest,AsStdFunctionWithReferenceParameter)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>
IsMockFunctionTemplateArgumentDeducedTo(const internal::MockFunction<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
TYPED_TEST(MockMethodMockFunctionSignatureTest,IsMockFunctionTemplateArgumentDeducedForRawSignature)866 TYPED_TEST(MockMethodMockFunctionSignatureTest,
867 IsMockFunctionTemplateArgumentDeducedForRawSignature) {
868 using Argument = TypeParam;
869 MockFunction<Argument> foo;
870 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
871 }
872
TYPED_TEST(MockMethodMockFunctionSignatureTest,IsMockFunctionTemplateArgumentDeducedForStdFunction)873 TYPED_TEST(MockMethodMockFunctionSignatureTest,
874 IsMockFunctionTemplateArgumentDeducedForStdFunction) {
875 using Argument = std::function<TypeParam>;
876 MockFunction<Argument> foo;
877 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
878 }
879
TYPED_TEST(MockMethodMockFunctionSignatureTest,IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction)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
TYPED_TEST(MockMethodMockFunctionSignatureTest,IsMockFunctionTemplateArgumentDeducedForAlternateCallable)892 TYPED_TEST(MockMethodMockFunctionSignatureTest,
893 IsMockFunctionTemplateArgumentDeducedForAlternateCallable) {
894 using Argument = AlternateCallable<TypeParam>;
895 MockFunction<Argument> foo;
896 EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
897 }
898
TYPED_TEST(MockMethodMockFunctionSignatureTest,IsMockFunctionCallMethodSignatureTheSameForAlternateCallable)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
TEST(MockMethodMockFunctionTest,MockMethodSizeOverhead)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
TEST(MockMethodMockFunctionTest,EnsureNoUnusedMemberFunction)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
TEST(MockMethodMockFunctionTest,NoexceptSpecifierPreserved)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