1 // This file was GENERATED by command: 2 // pump.py gmock-generated-function-mockers.h.pump 3 // DO NOT EDIT BY HAND!!! 4 5 // Copyright 2007, Google Inc. 6 // All rights reserved. 7 // 8 // Redistribution and use in source and binary forms, with or without 9 // modification, are permitted provided that the following conditions are 10 // met: 11 // 12 // * Redistributions of source code must retain the above copyright 13 // notice, this list of conditions and the following disclaimer. 14 // * Redistributions in binary form must reproduce the above 15 // copyright notice, this list of conditions and the following disclaimer 16 // in the documentation and/or other materials provided with the 17 // distribution. 18 // * Neither the name of Google Inc. nor the names of its 19 // contributors may be used to endorse or promote products derived from 20 // this software without specific prior written permission. 21 // 22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 34 35 // Google Mock - a framework for writing C++ mock classes. 36 // 37 // This file implements function mockers of various arities. 38 39 // GOOGLETEST_CM0002 DO NOT DELETE 40 41 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ 42 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ 43 44 #include "gmock/gmock-spec-builders.h" 45 #include "gmock/internal/gmock-internal-utils.h" 46 47 #if GTEST_HAS_STD_FUNCTION_ 48 # include <functional> 49 #endif 50 51 namespace testing { 52 namespace internal { 53 54 template <typename F> 55 class FunctionMockerBase; 56 57 // Note: class FunctionMocker really belongs to the ::testing 58 // namespace. However if we define it in ::testing, MSVC will 59 // complain when classes in ::testing::internal declare it as a 60 // friend class template. To workaround this compiler bug, we define 61 // FunctionMocker in ::testing::internal and import it into ::testing. 62 template <typename F> 63 class FunctionMocker; 64 65 template <typename R> 66 class FunctionMocker<R()> : public 67 internal::FunctionMockerBase<R()> { 68 public: 69 typedef R F(); 70 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 71 72 MockSpec<F> With() { 73 return MockSpec<F>(this, ::testing::make_tuple()); 74 } 75 76 R Invoke() { 77 // Even though gcc and MSVC don't enforce it, 'this->' is required 78 // by the C++ standard [14.6.4] here, as the base class type is 79 // dependent on the template argument (and thus shouldn't be 80 // looked into when resolving InvokeWith). 81 return this->InvokeWith(ArgumentTuple()); 82 } 83 }; 84 85 template <typename R, typename A1> 86 class FunctionMocker<R(A1)> : public 87 internal::FunctionMockerBase<R(A1)> { 88 public: 89 typedef R F(A1); 90 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 91 92 MockSpec<F> With(const Matcher<A1>& m1) { 93 return MockSpec<F>(this, ::testing::make_tuple(m1)); 94 } 95 96 R Invoke(A1 a1) { 97 // Even though gcc and MSVC don't enforce it, 'this->' is required 98 // by the C++ standard [14.6.4] here, as the base class type is 99 // dependent on the template argument (and thus shouldn't be 100 // looked into when resolving InvokeWith). 101 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1))); 102 } 103 }; 104 105 template <typename R, typename A1, typename A2> 106 class FunctionMocker<R(A1, A2)> : public 107 internal::FunctionMockerBase<R(A1, A2)> { 108 public: 109 typedef R F(A1, A2); 110 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 111 112 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2) { 113 return MockSpec<F>(this, ::testing::make_tuple(m1, m2)); 114 } 115 116 R Invoke(A1 a1, A2 a2) { 117 // Even though gcc and MSVC don't enforce it, 'this->' is required 118 // by the C++ standard [14.6.4] here, as the base class type is 119 // dependent on the template argument (and thus shouldn't be 120 // looked into when resolving InvokeWith). 121 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 122 internal::forward<A2>(a2))); 123 } 124 }; 125 126 template <typename R, typename A1, typename A2, typename A3> 127 class FunctionMocker<R(A1, A2, A3)> : public 128 internal::FunctionMockerBase<R(A1, A2, A3)> { 129 public: 130 typedef R F(A1, A2, A3); 131 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 132 133 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 134 const Matcher<A3>& m3) { 135 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3)); 136 } 137 138 R Invoke(A1 a1, A2 a2, A3 a3) { 139 // Even though gcc and MSVC don't enforce it, 'this->' is required 140 // by the C++ standard [14.6.4] here, as the base class type is 141 // dependent on the template argument (and thus shouldn't be 142 // looked into when resolving InvokeWith). 143 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 144 internal::forward<A2>(a2), internal::forward<A3>(a3))); 145 } 146 }; 147 148 template <typename R, typename A1, typename A2, typename A3, typename A4> 149 class FunctionMocker<R(A1, A2, A3, A4)> : public 150 internal::FunctionMockerBase<R(A1, A2, A3, A4)> { 151 public: 152 typedef R F(A1, A2, A3, A4); 153 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 154 155 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 156 const Matcher<A3>& m3, const Matcher<A4>& m4) { 157 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4)); 158 } 159 160 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) { 161 // Even though gcc and MSVC don't enforce it, 'this->' is required 162 // by the C++ standard [14.6.4] here, as the base class type is 163 // dependent on the template argument (and thus shouldn't be 164 // looked into when resolving InvokeWith). 165 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 166 internal::forward<A2>(a2), internal::forward<A3>(a3), 167 internal::forward<A4>(a4))); 168 } 169 }; 170 171 template <typename R, typename A1, typename A2, typename A3, typename A4, 172 typename A5> 173 class FunctionMocker<R(A1, A2, A3, A4, A5)> : public 174 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> { 175 public: 176 typedef R F(A1, A2, A3, A4, A5); 177 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 178 179 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 180 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) { 181 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5)); 182 } 183 184 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { 185 // Even though gcc and MSVC don't enforce it, 'this->' is required 186 // by the C++ standard [14.6.4] here, as the base class type is 187 // dependent on the template argument (and thus shouldn't be 188 // looked into when resolving InvokeWith). 189 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 190 internal::forward<A2>(a2), internal::forward<A3>(a3), 191 internal::forward<A4>(a4), internal::forward<A5>(a5))); 192 } 193 }; 194 195 template <typename R, typename A1, typename A2, typename A3, typename A4, 196 typename A5, typename A6> 197 class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public 198 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> { 199 public: 200 typedef R F(A1, A2, A3, A4, A5, A6); 201 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 202 203 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 204 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 205 const Matcher<A6>& m6) { 206 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6)); 207 } 208 209 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { 210 // Even though gcc and MSVC don't enforce it, 'this->' is required 211 // by the C++ standard [14.6.4] here, as the base class type is 212 // dependent on the template argument (and thus shouldn't be 213 // looked into when resolving InvokeWith). 214 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 215 internal::forward<A2>(a2), internal::forward<A3>(a3), 216 internal::forward<A4>(a4), internal::forward<A5>(a5), 217 internal::forward<A6>(a6))); 218 } 219 }; 220 221 template <typename R, typename A1, typename A2, typename A3, typename A4, 222 typename A5, typename A6, typename A7> 223 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public 224 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> { 225 public: 226 typedef R F(A1, A2, A3, A4, A5, A6, A7); 227 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 228 229 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 230 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 231 const Matcher<A6>& m6, const Matcher<A7>& m7) { 232 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7)); 233 } 234 235 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { 236 // Even though gcc and MSVC don't enforce it, 'this->' is required 237 // by the C++ standard [14.6.4] here, as the base class type is 238 // dependent on the template argument (and thus shouldn't be 239 // looked into when resolving InvokeWith). 240 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 241 internal::forward<A2>(a2), internal::forward<A3>(a3), 242 internal::forward<A4>(a4), internal::forward<A5>(a5), 243 internal::forward<A6>(a6), internal::forward<A7>(a7))); 244 } 245 }; 246 247 template <typename R, typename A1, typename A2, typename A3, typename A4, 248 typename A5, typename A6, typename A7, typename A8> 249 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public 250 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> { 251 public: 252 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8); 253 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 254 255 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 256 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 257 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) { 258 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7, 259 m8)); 260 } 261 262 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { 263 // Even though gcc and MSVC don't enforce it, 'this->' is required 264 // by the C++ standard [14.6.4] here, as the base class type is 265 // dependent on the template argument (and thus shouldn't be 266 // looked into when resolving InvokeWith). 267 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 268 internal::forward<A2>(a2), internal::forward<A3>(a3), 269 internal::forward<A4>(a4), internal::forward<A5>(a5), 270 internal::forward<A6>(a6), internal::forward<A7>(a7), 271 internal::forward<A8>(a8))); 272 } 273 }; 274 275 template <typename R, typename A1, typename A2, typename A3, typename A4, 276 typename A5, typename A6, typename A7, typename A8, typename A9> 277 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public 278 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> { 279 public: 280 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9); 281 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 282 283 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 284 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 285 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8, 286 const Matcher<A9>& m9) { 287 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7, 288 m8, m9)); 289 } 290 291 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { 292 // Even though gcc and MSVC don't enforce it, 'this->' is required 293 // by the C++ standard [14.6.4] here, as the base class type is 294 // dependent on the template argument (and thus shouldn't be 295 // looked into when resolving InvokeWith). 296 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 297 internal::forward<A2>(a2), internal::forward<A3>(a3), 298 internal::forward<A4>(a4), internal::forward<A5>(a5), 299 internal::forward<A6>(a6), internal::forward<A7>(a7), 300 internal::forward<A8>(a8), internal::forward<A9>(a9))); 301 } 302 }; 303 304 template <typename R, typename A1, typename A2, typename A3, typename A4, 305 typename A5, typename A6, typename A7, typename A8, typename A9, 306 typename A10> 307 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public 308 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> { 309 public: 310 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 311 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 312 313 MockSpec<F> With(const Matcher<A1>& m1, const Matcher<A2>& m2, 314 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 315 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8, 316 const Matcher<A9>& m9, const Matcher<A10>& m10) { 317 return MockSpec<F>(this, ::testing::make_tuple(m1, m2, m3, m4, m5, m6, m7, 318 m8, m9, m10)); 319 } 320 321 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, 322 A10 a10) { 323 // Even though gcc and MSVC don't enforce it, 'this->' is required 324 // by the C++ standard [14.6.4] here, as the base class type is 325 // dependent on the template argument (and thus shouldn't be 326 // looked into when resolving InvokeWith). 327 return this->InvokeWith(ArgumentTuple(internal::forward<A1>(a1), 328 internal::forward<A2>(a2), internal::forward<A3>(a3), 329 internal::forward<A4>(a4), internal::forward<A5>(a5), 330 internal::forward<A6>(a6), internal::forward<A7>(a7), 331 internal::forward<A8>(a8), internal::forward<A9>(a9), 332 internal::forward<A10>(a10))); 333 } 334 }; 335 336 // Removes the given pointer; this is a helper for the expectation setter method 337 // for parameterless matchers. 338 // 339 // We want to make sure that the user cannot set a parameterless expectation on 340 // overloaded methods, including methods which are overloaded on const. Example: 341 // 342 // class MockClass { 343 // MOCK_METHOD0(GetName, string&()); 344 // MOCK_CONST_METHOD0(GetName, const string&()); 345 // }; 346 // 347 // TEST() { 348 // // This should be an error, as it's not clear which overload is expected. 349 // EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value)); 350 // } 351 // 352 // Here are the generated expectation-setter methods: 353 // 354 // class MockClass { 355 // // Overload 1 356 // MockSpec<string&()> gmock_GetName() { ... } 357 // // Overload 2. Declared const so that the compiler will generate an 358 // // error when trying to resolve between this and overload 4 in 359 // // 'gmock_GetName(WithoutMatchers(), nullptr)'. 360 // MockSpec<string&()> gmock_GetName( 361 // const WithoutMatchers&, const Function<string&()>*) const { 362 // // Removes const from this, calls overload 1 363 // return AdjustConstness_(this)->gmock_GetName(); 364 // } 365 // 366 // // Overload 3 367 // const string& gmock_GetName() const { ... } 368 // // Overload 4 369 // MockSpec<const string&()> gmock_GetName( 370 // const WithoutMatchers&, const Function<const string&()>*) const { 371 // // Does not remove const, calls overload 3 372 // return AdjustConstness_const(this)->gmock_GetName(); 373 // } 374 // } 375 // 376 template <typename MockType> 377 const MockType* AdjustConstness_const(const MockType* mock) { 378 return mock; 379 } 380 381 // Removes const from and returns the given pointer; this is a helper for the 382 // expectation setter method for parameterless matchers. 383 template <typename MockType> 384 MockType* AdjustConstness_(const MockType* mock) { 385 return const_cast<MockType*>(mock); 386 } 387 388 } // namespace internal 389 390 // The style guide prohibits "using" statements in a namespace scope 391 // inside a header file. However, the FunctionMocker class template 392 // is meant to be defined in the ::testing namespace. The following 393 // line is just a trick for working around a bug in MSVC 8.0, which 394 // cannot handle it if we define FunctionMocker in ::testing. 395 using internal::FunctionMocker; 396 397 // GMOCK_RESULT_(tn, F) expands to the result type of function type F. 398 // We define this as a variadic macro in case F contains unprotected 399 // commas (the same reason that we use variadic macros in other places 400 // in this file). 401 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 402 #define GMOCK_RESULT_(tn, ...) \ 403 tn ::testing::internal::Function<__VA_ARGS__>::Result 404 405 // The type of argument N of the given function type. 406 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 407 #define GMOCK_ARG_(tn, N, ...) \ 408 tn ::testing::internal::Function<__VA_ARGS__>::Argument##N 409 410 // The matcher type for argument N of the given function type. 411 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 412 #define GMOCK_MATCHER_(tn, N, ...) \ 413 const ::testing::Matcher<GMOCK_ARG_(tn, N, __VA_ARGS__)>& 414 415 // The variable for mocking the given method. 416 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 417 #define GMOCK_MOCKER_(arity, constness, Method) \ 418 GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) 419 420 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 421 #define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \ 422 GMOCK_RESULT_(tn, __VA_ARGS__) ct Method() constness { \ 423 GTEST_COMPILE_ASSERT_( \ 424 (::testing::tuple_size<tn ::testing::internal::Function< \ 425 __VA_ARGS__>::ArgumentTuple>::value == 0), \ 426 this_method_does_not_take_0_arguments); \ 427 GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \ 428 return GMOCK_MOCKER_(0, constness, Method).Invoke(); \ 429 } \ 430 ::testing::MockSpec<__VA_ARGS__> gmock_##Method() constness { \ 431 GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \ 432 return GMOCK_MOCKER_(0, constness, Method).With(); \ 433 } \ 434 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 435 const ::testing::internal::WithoutMatchers&, \ 436 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 437 return ::testing::internal::AdjustConstness_##constness(this) \ 438 ->gmock_##Method(); \ 439 } \ 440 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \ 441 Method) 442 443 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 444 #define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \ 445 GMOCK_RESULT_(tn, __VA_ARGS__) \ 446 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ 447 GTEST_COMPILE_ASSERT_( \ 448 (::testing::tuple_size<tn ::testing::internal::Function< \ 449 __VA_ARGS__>::ArgumentTuple>::value == 1), \ 450 this_method_does_not_take_1_argument); \ 451 GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \ 452 return GMOCK_MOCKER_(1, constness, Method) \ 453 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 454 gmock_a1)); \ 455 } \ 456 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 457 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ 458 GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \ 459 return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \ 460 } \ 461 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 462 const ::testing::internal::WithoutMatchers&, \ 463 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 464 return ::testing::internal::AdjustConstness_##constness(this) \ 465 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>()); \ 466 } \ 467 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \ 468 Method) 469 470 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 471 #define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \ 472 GMOCK_RESULT_(tn, __VA_ARGS__) \ 473 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 474 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2) constness { \ 475 GTEST_COMPILE_ASSERT_( \ 476 (::testing::tuple_size<tn ::testing::internal::Function< \ 477 __VA_ARGS__>::ArgumentTuple>::value == 2), \ 478 this_method_does_not_take_2_arguments); \ 479 GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \ 480 return GMOCK_MOCKER_(2, constness, Method) \ 481 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 482 gmock_a1), \ 483 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 484 gmock_a2)); \ 485 } \ 486 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 487 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 488 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \ 489 GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \ 490 return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \ 491 } \ 492 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 493 const ::testing::internal::WithoutMatchers&, \ 494 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 495 return ::testing::internal::AdjustConstness_##constness(this) \ 496 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 497 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>()); \ 498 } \ 499 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \ 500 Method) 501 502 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 503 #define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \ 504 GMOCK_RESULT_(tn, __VA_ARGS__) \ 505 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 506 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 507 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3) constness { \ 508 GTEST_COMPILE_ASSERT_( \ 509 (::testing::tuple_size<tn ::testing::internal::Function< \ 510 __VA_ARGS__>::ArgumentTuple>::value == 3), \ 511 this_method_does_not_take_3_arguments); \ 512 GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \ 513 return GMOCK_MOCKER_(3, constness, Method) \ 514 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 515 gmock_a1), \ 516 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 517 gmock_a2), \ 518 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 519 gmock_a3)); \ 520 } \ 521 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 522 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 523 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 524 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \ 525 GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \ 526 return GMOCK_MOCKER_(3, constness, Method) \ 527 .With(gmock_a1, gmock_a2, gmock_a3); \ 528 } \ 529 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 530 const ::testing::internal::WithoutMatchers&, \ 531 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 532 return ::testing::internal::AdjustConstness_##constness(this) \ 533 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 534 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 535 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>()); \ 536 } \ 537 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \ 538 Method) 539 540 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 541 #define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \ 542 GMOCK_RESULT_(tn, __VA_ARGS__) \ 543 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 544 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 545 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 546 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \ 547 GTEST_COMPILE_ASSERT_( \ 548 (::testing::tuple_size<tn ::testing::internal::Function< \ 549 __VA_ARGS__>::ArgumentTuple>::value == 4), \ 550 this_method_does_not_take_4_arguments); \ 551 GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \ 552 return GMOCK_MOCKER_(4, constness, Method) \ 553 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 554 gmock_a1), \ 555 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 556 gmock_a2), \ 557 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 558 gmock_a3), \ 559 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 560 gmock_a4)); \ 561 } \ 562 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 563 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 564 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 565 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 566 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \ 567 GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \ 568 return GMOCK_MOCKER_(4, constness, Method) \ 569 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4); \ 570 } \ 571 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 572 const ::testing::internal::WithoutMatchers&, \ 573 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 574 return ::testing::internal::AdjustConstness_##constness(this) \ 575 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 576 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 577 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 578 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>()); \ 579 } \ 580 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \ 581 Method) 582 583 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 584 #define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \ 585 GMOCK_RESULT_(tn, __VA_ARGS__) \ 586 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 587 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 588 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 589 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 590 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5) constness { \ 591 GTEST_COMPILE_ASSERT_( \ 592 (::testing::tuple_size<tn ::testing::internal::Function< \ 593 __VA_ARGS__>::ArgumentTuple>::value == 5), \ 594 this_method_does_not_take_5_arguments); \ 595 GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \ 596 return GMOCK_MOCKER_(5, constness, Method) \ 597 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 598 gmock_a1), \ 599 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 600 gmock_a2), \ 601 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 602 gmock_a3), \ 603 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 604 gmock_a4), \ 605 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 606 gmock_a5)); \ 607 } \ 608 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 609 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 610 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 611 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 612 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 613 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \ 614 GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \ 615 return GMOCK_MOCKER_(5, constness, Method) \ 616 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5); \ 617 } \ 618 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 619 const ::testing::internal::WithoutMatchers&, \ 620 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 621 return ::testing::internal::AdjustConstness_##constness(this) \ 622 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 623 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 624 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 625 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 626 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>()); \ 627 } \ 628 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \ 629 Method) 630 631 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 632 #define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \ 633 GMOCK_RESULT_(tn, __VA_ARGS__) \ 634 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 635 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 636 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 637 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 638 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ 639 GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6) constness { \ 640 GTEST_COMPILE_ASSERT_( \ 641 (::testing::tuple_size<tn ::testing::internal::Function< \ 642 __VA_ARGS__>::ArgumentTuple>::value == 6), \ 643 this_method_does_not_take_6_arguments); \ 644 GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \ 645 return GMOCK_MOCKER_(6, constness, Method) \ 646 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 647 gmock_a1), \ 648 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 649 gmock_a2), \ 650 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 651 gmock_a3), \ 652 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 653 gmock_a4), \ 654 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 655 gmock_a5), \ 656 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \ 657 gmock_a6)); \ 658 } \ 659 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 660 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 661 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 662 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 663 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 664 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ 665 GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \ 666 GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \ 667 return GMOCK_MOCKER_(6, constness, Method) \ 668 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6); \ 669 } \ 670 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 671 const ::testing::internal::WithoutMatchers&, \ 672 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 673 return ::testing::internal::AdjustConstness_##constness(this) \ 674 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 675 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 676 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 677 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 678 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \ 679 ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>()); \ 680 } \ 681 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \ 682 Method) 683 684 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 685 #define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \ 686 GMOCK_RESULT_(tn, __VA_ARGS__) \ 687 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 688 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 689 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 690 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 691 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ 692 GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ 693 GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \ 694 GTEST_COMPILE_ASSERT_( \ 695 (::testing::tuple_size<tn ::testing::internal::Function< \ 696 __VA_ARGS__>::ArgumentTuple>::value == 7), \ 697 this_method_does_not_take_7_arguments); \ 698 GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \ 699 return GMOCK_MOCKER_(7, constness, Method) \ 700 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 701 gmock_a1), \ 702 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 703 gmock_a2), \ 704 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 705 gmock_a3), \ 706 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 707 gmock_a4), \ 708 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 709 gmock_a5), \ 710 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \ 711 gmock_a6), \ 712 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \ 713 gmock_a7)); \ 714 } \ 715 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 716 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 717 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 718 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 719 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 720 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ 721 GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ 722 GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \ 723 GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \ 724 return GMOCK_MOCKER_(7, constness, Method) \ 725 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6, \ 726 gmock_a7); \ 727 } \ 728 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 729 const ::testing::internal::WithoutMatchers&, \ 730 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 731 return ::testing::internal::AdjustConstness_##constness(this) \ 732 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 733 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 734 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 735 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 736 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \ 737 ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \ 738 ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>()); \ 739 } \ 740 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \ 741 Method) 742 743 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 744 #define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \ 745 GMOCK_RESULT_(tn, __VA_ARGS__) \ 746 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 747 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 748 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 749 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 750 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ 751 GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ 752 GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ 753 GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8) constness { \ 754 GTEST_COMPILE_ASSERT_( \ 755 (::testing::tuple_size<tn ::testing::internal::Function< \ 756 __VA_ARGS__>::ArgumentTuple>::value == 8), \ 757 this_method_does_not_take_8_arguments); \ 758 GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \ 759 return GMOCK_MOCKER_(8, constness, Method) \ 760 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 761 gmock_a1), \ 762 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 763 gmock_a2), \ 764 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 765 gmock_a3), \ 766 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 767 gmock_a4), \ 768 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 769 gmock_a5), \ 770 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \ 771 gmock_a6), \ 772 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \ 773 gmock_a7), \ 774 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>( \ 775 gmock_a8)); \ 776 } \ 777 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 778 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 779 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 780 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 781 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 782 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ 783 GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ 784 GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ 785 GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \ 786 GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \ 787 return GMOCK_MOCKER_(8, constness, Method) \ 788 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6, \ 789 gmock_a7, gmock_a8); \ 790 } \ 791 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 792 const ::testing::internal::WithoutMatchers&, \ 793 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 794 return ::testing::internal::AdjustConstness_##constness(this) \ 795 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 796 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 797 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 798 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 799 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \ 800 ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \ 801 ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \ 802 ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>()); \ 803 } \ 804 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \ 805 Method) 806 807 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 808 #define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \ 809 GMOCK_RESULT_(tn, __VA_ARGS__) \ 810 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 811 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 812 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 813 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 814 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ 815 GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ 816 GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ 817 GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \ 818 GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9) constness { \ 819 GTEST_COMPILE_ASSERT_( \ 820 (::testing::tuple_size<tn ::testing::internal::Function< \ 821 __VA_ARGS__>::ArgumentTuple>::value == 9), \ 822 this_method_does_not_take_9_arguments); \ 823 GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \ 824 return GMOCK_MOCKER_(9, constness, Method) \ 825 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 826 gmock_a1), \ 827 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 828 gmock_a2), \ 829 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 830 gmock_a3), \ 831 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 832 gmock_a4), \ 833 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 834 gmock_a5), \ 835 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \ 836 gmock_a6), \ 837 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \ 838 gmock_a7), \ 839 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>( \ 840 gmock_a8), \ 841 ::testing::internal::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>( \ 842 gmock_a9)); \ 843 } \ 844 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 845 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 846 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 847 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 848 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 849 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ 850 GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ 851 GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ 852 GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ 853 GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \ 854 GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \ 855 return GMOCK_MOCKER_(9, constness, Method) \ 856 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6, \ 857 gmock_a7, gmock_a8, gmock_a9); \ 858 } \ 859 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 860 const ::testing::internal::WithoutMatchers&, \ 861 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 862 return ::testing::internal::AdjustConstness_##constness(this) \ 863 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 864 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 865 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 866 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 867 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \ 868 ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \ 869 ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \ 870 ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(), \ 871 ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>()); \ 872 } \ 873 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \ 874 Method) 875 876 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 877 #define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \ 878 GMOCK_RESULT_(tn, __VA_ARGS__) \ 879 ct Method(GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, \ 880 GMOCK_ARG_(tn, 2, __VA_ARGS__) gmock_a2, \ 881 GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ 882 GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, \ 883 GMOCK_ARG_(tn, 5, __VA_ARGS__) gmock_a5, \ 884 GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ 885 GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, \ 886 GMOCK_ARG_(tn, 8, __VA_ARGS__) gmock_a8, \ 887 GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \ 888 GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \ 889 GTEST_COMPILE_ASSERT_( \ 890 (::testing::tuple_size<tn ::testing::internal::Function< \ 891 __VA_ARGS__>::ArgumentTuple>::value == 10), \ 892 this_method_does_not_take_10_arguments); \ 893 GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \ 894 return GMOCK_MOCKER_(10, constness, Method) \ 895 .Invoke(::testing::internal::forward<GMOCK_ARG_(tn, 1, __VA_ARGS__)>( \ 896 gmock_a1), \ 897 ::testing::internal::forward<GMOCK_ARG_(tn, 2, __VA_ARGS__)>( \ 898 gmock_a2), \ 899 ::testing::internal::forward<GMOCK_ARG_(tn, 3, __VA_ARGS__)>( \ 900 gmock_a3), \ 901 ::testing::internal::forward<GMOCK_ARG_(tn, 4, __VA_ARGS__)>( \ 902 gmock_a4), \ 903 ::testing::internal::forward<GMOCK_ARG_(tn, 5, __VA_ARGS__)>( \ 904 gmock_a5), \ 905 ::testing::internal::forward<GMOCK_ARG_(tn, 6, __VA_ARGS__)>( \ 906 gmock_a6), \ 907 ::testing::internal::forward<GMOCK_ARG_(tn, 7, __VA_ARGS__)>( \ 908 gmock_a7), \ 909 ::testing::internal::forward<GMOCK_ARG_(tn, 8, __VA_ARGS__)>( \ 910 gmock_a8), \ 911 ::testing::internal::forward<GMOCK_ARG_(tn, 9, __VA_ARGS__)>( \ 912 gmock_a9), \ 913 ::testing::internal::forward<GMOCK_ARG_(tn, 10, __VA_ARGS__)>( \ 914 gmock_a10)); \ 915 } \ 916 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 917 GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ 918 GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ 919 GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ 920 GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ 921 GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ 922 GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ 923 GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ 924 GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ 925 GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \ 926 GMOCK_MATCHER_(tn, 10, __VA_ARGS__) gmock_a10) constness { \ 927 GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \ 928 return GMOCK_MOCKER_(10, constness, Method) \ 929 .With(gmock_a1, gmock_a2, gmock_a3, gmock_a4, gmock_a5, gmock_a6, \ 930 gmock_a7, gmock_a8, gmock_a9, gmock_a10); \ 931 } \ 932 ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ 933 const ::testing::internal::WithoutMatchers&, \ 934 constness ::testing::internal::Function<__VA_ARGS__>*) const { \ 935 return ::testing::internal::AdjustConstness_##constness(this) \ 936 ->gmock_##Method(::testing::A<GMOCK_ARG_(tn, 1, __VA_ARGS__)>(), \ 937 ::testing::A<GMOCK_ARG_(tn, 2, __VA_ARGS__)>(), \ 938 ::testing::A<GMOCK_ARG_(tn, 3, __VA_ARGS__)>(), \ 939 ::testing::A<GMOCK_ARG_(tn, 4, __VA_ARGS__)>(), \ 940 ::testing::A<GMOCK_ARG_(tn, 5, __VA_ARGS__)>(), \ 941 ::testing::A<GMOCK_ARG_(tn, 6, __VA_ARGS__)>(), \ 942 ::testing::A<GMOCK_ARG_(tn, 7, __VA_ARGS__)>(), \ 943 ::testing::A<GMOCK_ARG_(tn, 8, __VA_ARGS__)>(), \ 944 ::testing::A<GMOCK_ARG_(tn, 9, __VA_ARGS__)>(), \ 945 ::testing::A<GMOCK_ARG_(tn, 10, __VA_ARGS__)>()); \ 946 } \ 947 mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \ 948 Method) 949 950 #define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__) 951 #define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__) 952 #define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__) 953 #define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__) 954 #define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__) 955 #define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__) 956 #define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__) 957 #define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__) 958 #define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__) 959 #define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__) 960 #define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__) 961 962 #define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__) 963 #define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__) 964 #define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__) 965 #define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__) 966 #define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__) 967 #define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__) 968 #define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__) 969 #define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__) 970 #define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__) 971 #define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__) 972 #define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__) 973 974 #define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__) 975 #define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__) 976 #define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__) 977 #define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__) 978 #define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__) 979 #define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__) 980 #define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__) 981 #define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__) 982 #define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__) 983 #define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__) 984 #define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__) 985 986 #define MOCK_CONST_METHOD0_T(m, ...) \ 987 GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__) 988 #define MOCK_CONST_METHOD1_T(m, ...) \ 989 GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__) 990 #define MOCK_CONST_METHOD2_T(m, ...) \ 991 GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__) 992 #define MOCK_CONST_METHOD3_T(m, ...) \ 993 GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__) 994 #define MOCK_CONST_METHOD4_T(m, ...) \ 995 GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__) 996 #define MOCK_CONST_METHOD5_T(m, ...) \ 997 GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__) 998 #define MOCK_CONST_METHOD6_T(m, ...) \ 999 GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__) 1000 #define MOCK_CONST_METHOD7_T(m, ...) \ 1001 GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__) 1002 #define MOCK_CONST_METHOD8_T(m, ...) \ 1003 GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__) 1004 #define MOCK_CONST_METHOD9_T(m, ...) \ 1005 GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__) 1006 #define MOCK_CONST_METHOD10_T(m, ...) \ 1007 GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__) 1008 1009 #define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 1010 GMOCK_METHOD0_(, , ct, m, __VA_ARGS__) 1011 #define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 1012 GMOCK_METHOD1_(, , ct, m, __VA_ARGS__) 1013 #define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 1014 GMOCK_METHOD2_(, , ct, m, __VA_ARGS__) 1015 #define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 1016 GMOCK_METHOD3_(, , ct, m, __VA_ARGS__) 1017 #define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 1018 GMOCK_METHOD4_(, , ct, m, __VA_ARGS__) 1019 #define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 1020 GMOCK_METHOD5_(, , ct, m, __VA_ARGS__) 1021 #define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 1022 GMOCK_METHOD6_(, , ct, m, __VA_ARGS__) 1023 #define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 1024 GMOCK_METHOD7_(, , ct, m, __VA_ARGS__) 1025 #define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 1026 GMOCK_METHOD8_(, , ct, m, __VA_ARGS__) 1027 #define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 1028 GMOCK_METHOD9_(, , ct, m, __VA_ARGS__) 1029 #define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 1030 GMOCK_METHOD10_(, , ct, m, __VA_ARGS__) 1031 1032 #define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 1033 GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__) 1034 #define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 1035 GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__) 1036 #define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 1037 GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__) 1038 #define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 1039 GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__) 1040 #define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 1041 GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__) 1042 #define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 1043 GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__) 1044 #define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 1045 GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__) 1046 #define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 1047 GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__) 1048 #define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 1049 GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__) 1050 #define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 1051 GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__) 1052 #define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 1053 GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__) 1054 1055 #define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 1056 GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__) 1057 #define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 1058 GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__) 1059 #define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 1060 GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__) 1061 #define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 1062 GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__) 1063 #define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 1064 GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__) 1065 #define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 1066 GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__) 1067 #define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 1068 GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__) 1069 #define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 1070 GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__) 1071 #define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 1072 GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__) 1073 #define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 1074 GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__) 1075 #define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 1076 GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__) 1077 1078 #define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 1079 GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__) 1080 #define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 1081 GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__) 1082 #define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 1083 GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__) 1084 #define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 1085 GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__) 1086 #define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 1087 GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__) 1088 #define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 1089 GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__) 1090 #define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 1091 GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__) 1092 #define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 1093 GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__) 1094 #define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 1095 GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__) 1096 #define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 1097 GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__) 1098 #define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 1099 GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__) 1100 1101 // A MockFunction<F> class has one mock method whose type is F. It is 1102 // useful when you just want your test code to emit some messages and 1103 // have Google Mock verify the right messages are sent (and perhaps at 1104 // the right times). For example, if you are exercising code: 1105 // 1106 // Foo(1); 1107 // Foo(2); 1108 // Foo(3); 1109 // 1110 // and want to verify that Foo(1) and Foo(3) both invoke 1111 // mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: 1112 // 1113 // TEST(FooTest, InvokesBarCorrectly) { 1114 // MyMock mock; 1115 // MockFunction<void(string check_point_name)> check; 1116 // { 1117 // InSequence s; 1118 // 1119 // EXPECT_CALL(mock, Bar("a")); 1120 // EXPECT_CALL(check, Call("1")); 1121 // EXPECT_CALL(check, Call("2")); 1122 // EXPECT_CALL(mock, Bar("a")); 1123 // } 1124 // Foo(1); 1125 // check.Call("1"); 1126 // Foo(2); 1127 // check.Call("2"); 1128 // Foo(3); 1129 // } 1130 // 1131 // The expectation spec says that the first Bar("a") must happen 1132 // before check point "1", the second Bar("a") must happen after check 1133 // point "2", and nothing should happen between the two check 1134 // points. The explicit check points make it easy to tell which 1135 // Bar("a") is called by which call to Foo(). 1136 // 1137 // MockFunction<F> can also be used to exercise code that accepts 1138 // std::function<F> callbacks. To do so, use AsStdFunction() method 1139 // to create std::function proxy forwarding to original object's Call. 1140 // Example: 1141 // 1142 // TEST(FooTest, RunsCallbackWithBarArgument) { 1143 // MockFunction<int(string)> callback; 1144 // EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); 1145 // Foo(callback.AsStdFunction()); 1146 // } 1147 template <typename F> 1148 class MockFunction; 1149 1150 template <typename R> 1151 class MockFunction<R()> { 1152 public: 1153 MockFunction() {} 1154 1155 MOCK_METHOD0_T(Call, R()); 1156 1157 #if GTEST_HAS_STD_FUNCTION_ 1158 ::std::function<R()> AsStdFunction() { 1159 return [this]() -> R { 1160 return this->Call(); 1161 }; 1162 } 1163 #endif // GTEST_HAS_STD_FUNCTION_ 1164 1165 private: 1166 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1167 }; 1168 1169 template <typename R, typename A0> 1170 class MockFunction<R(A0)> { 1171 public: 1172 MockFunction() {} 1173 1174 MOCK_METHOD1_T(Call, R(A0)); 1175 1176 #if GTEST_HAS_STD_FUNCTION_ 1177 ::std::function<R(A0)> AsStdFunction() { 1178 return [this](A0 a0) -> R { 1179 return this->Call(::std::move(a0)); 1180 }; 1181 } 1182 #endif // GTEST_HAS_STD_FUNCTION_ 1183 1184 private: 1185 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1186 }; 1187 1188 template <typename R, typename A0, typename A1> 1189 class MockFunction<R(A0, A1)> { 1190 public: 1191 MockFunction() {} 1192 1193 MOCK_METHOD2_T(Call, R(A0, A1)); 1194 1195 #if GTEST_HAS_STD_FUNCTION_ 1196 ::std::function<R(A0, A1)> AsStdFunction() { 1197 return [this](A0 a0, A1 a1) -> R { 1198 return this->Call(::std::move(a0), ::std::move(a1)); 1199 }; 1200 } 1201 #endif // GTEST_HAS_STD_FUNCTION_ 1202 1203 private: 1204 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1205 }; 1206 1207 template <typename R, typename A0, typename A1, typename A2> 1208 class MockFunction<R(A0, A1, A2)> { 1209 public: 1210 MockFunction() {} 1211 1212 MOCK_METHOD3_T(Call, R(A0, A1, A2)); 1213 1214 #if GTEST_HAS_STD_FUNCTION_ 1215 ::std::function<R(A0, A1, A2)> AsStdFunction() { 1216 return [this](A0 a0, A1 a1, A2 a2) -> R { 1217 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2)); 1218 }; 1219 } 1220 #endif // GTEST_HAS_STD_FUNCTION_ 1221 1222 private: 1223 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1224 }; 1225 1226 template <typename R, typename A0, typename A1, typename A2, typename A3> 1227 class MockFunction<R(A0, A1, A2, A3)> { 1228 public: 1229 MockFunction() {} 1230 1231 MOCK_METHOD4_T(Call, R(A0, A1, A2, A3)); 1232 1233 #if GTEST_HAS_STD_FUNCTION_ 1234 ::std::function<R(A0, A1, A2, A3)> AsStdFunction() { 1235 return [this](A0 a0, A1 a1, A2 a2, A3 a3) -> R { 1236 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1237 ::std::move(a3)); 1238 }; 1239 } 1240 #endif // GTEST_HAS_STD_FUNCTION_ 1241 1242 private: 1243 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1244 }; 1245 1246 template <typename R, typename A0, typename A1, typename A2, typename A3, 1247 typename A4> 1248 class MockFunction<R(A0, A1, A2, A3, A4)> { 1249 public: 1250 MockFunction() {} 1251 1252 MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4)); 1253 1254 #if GTEST_HAS_STD_FUNCTION_ 1255 ::std::function<R(A0, A1, A2, A3, A4)> AsStdFunction() { 1256 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) -> R { 1257 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1258 ::std::move(a3), ::std::move(a4)); 1259 }; 1260 } 1261 #endif // GTEST_HAS_STD_FUNCTION_ 1262 1263 private: 1264 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1265 }; 1266 1267 template <typename R, typename A0, typename A1, typename A2, typename A3, 1268 typename A4, typename A5> 1269 class MockFunction<R(A0, A1, A2, A3, A4, A5)> { 1270 public: 1271 MockFunction() {} 1272 1273 MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5)); 1274 1275 #if GTEST_HAS_STD_FUNCTION_ 1276 ::std::function<R(A0, A1, A2, A3, A4, A5)> AsStdFunction() { 1277 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> R { 1278 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1279 ::std::move(a3), ::std::move(a4), ::std::move(a5)); 1280 }; 1281 } 1282 #endif // GTEST_HAS_STD_FUNCTION_ 1283 1284 private: 1285 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1286 }; 1287 1288 template <typename R, typename A0, typename A1, typename A2, typename A3, 1289 typename A4, typename A5, typename A6> 1290 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> { 1291 public: 1292 MockFunction() {} 1293 1294 MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6)); 1295 1296 #if GTEST_HAS_STD_FUNCTION_ 1297 ::std::function<R(A0, A1, A2, A3, A4, A5, A6)> AsStdFunction() { 1298 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -> R { 1299 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1300 ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6)); 1301 }; 1302 } 1303 #endif // GTEST_HAS_STD_FUNCTION_ 1304 1305 private: 1306 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1307 }; 1308 1309 template <typename R, typename A0, typename A1, typename A2, typename A3, 1310 typename A4, typename A5, typename A6, typename A7> 1311 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> { 1312 public: 1313 MockFunction() {} 1314 1315 MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7)); 1316 1317 #if GTEST_HAS_STD_FUNCTION_ 1318 ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7)> AsStdFunction() { 1319 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -> R { 1320 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1321 ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6), 1322 ::std::move(a7)); 1323 }; 1324 } 1325 #endif // GTEST_HAS_STD_FUNCTION_ 1326 1327 private: 1328 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1329 }; 1330 1331 template <typename R, typename A0, typename A1, typename A2, typename A3, 1332 typename A4, typename A5, typename A6, typename A7, typename A8> 1333 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> { 1334 public: 1335 MockFunction() {} 1336 1337 MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8)); 1338 1339 #if GTEST_HAS_STD_FUNCTION_ 1340 ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> AsStdFunction() { 1341 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, 1342 A8 a8) -> R { 1343 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1344 ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6), 1345 ::std::move(a7), ::std::move(a8)); 1346 }; 1347 } 1348 #endif // GTEST_HAS_STD_FUNCTION_ 1349 1350 private: 1351 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1352 }; 1353 1354 template <typename R, typename A0, typename A1, typename A2, typename A3, 1355 typename A4, typename A5, typename A6, typename A7, typename A8, 1356 typename A9> 1357 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> { 1358 public: 1359 MockFunction() {} 1360 1361 MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); 1362 1363 #if GTEST_HAS_STD_FUNCTION_ 1364 ::std::function<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> AsStdFunction() { 1365 return [this](A0 a0, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, 1366 A8 a8, A9 a9) -> R { 1367 return this->Call(::std::move(a0), ::std::move(a1), ::std::move(a2), 1368 ::std::move(a3), ::std::move(a4), ::std::move(a5), ::std::move(a6), 1369 ::std::move(a7), ::std::move(a8), ::std::move(a9)); 1370 }; 1371 } 1372 #endif // GTEST_HAS_STD_FUNCTION_ 1373 1374 private: 1375 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 1376 }; 1377 1378 } // namespace testing 1379 1380 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_