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 // Author: wan (at) google.com (Zhanyong Wan) 35 36 // Google Mock - a framework for writing C++ mock classes. 37 // 38 // This file implements function mockers of various arities. 39 40 #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ 41 #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ 42 43 #include "gmock/gmock-spec-builders.h" 44 #include "gmock/internal/gmock-internal-utils.h" 45 46 namespace testing { 47 namespace internal { 48 49 template <typename F> 50 class FunctionMockerBase; 51 52 // Note: class FunctionMocker really belongs to the ::testing 53 // namespace. However if we define it in ::testing, MSVC will 54 // complain when classes in ::testing::internal declare it as a 55 // friend class template. To workaround this compiler bug, we define 56 // FunctionMocker in ::testing::internal and import it into ::testing. 57 template <typename F> 58 class FunctionMocker; 59 60 template <typename R> 61 class FunctionMocker<R()> : public 62 internal::FunctionMockerBase<R()> { 63 public: 64 typedef R F(); 65 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 66 67 MockSpec<F>& With() { 68 return this->current_spec(); 69 } 70 71 R Invoke() { 72 // Even though gcc and MSVC don't enforce it, 'this->' is required 73 // by the C++ standard [14.6.4] here, as the base class type is 74 // dependent on the template argument (and thus shouldn't be 75 // looked into when resolving InvokeWith). 76 return this->InvokeWith(ArgumentTuple()); 77 } 78 }; 79 80 template <typename R, typename A1> 81 class FunctionMocker<R(A1)> : public 82 internal::FunctionMockerBase<R(A1)> { 83 public: 84 typedef R F(A1); 85 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 86 87 MockSpec<F>& With(const Matcher<A1>& m1) { 88 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1)); 89 return this->current_spec(); 90 } 91 92 R Invoke(A1 a1) { 93 // Even though gcc and MSVC don't enforce it, 'this->' is required 94 // by the C++ standard [14.6.4] here, as the base class type is 95 // dependent on the template argument (and thus shouldn't be 96 // looked into when resolving InvokeWith). 97 return this->InvokeWith(ArgumentTuple(a1)); 98 } 99 }; 100 101 template <typename R, typename A1, typename A2> 102 class FunctionMocker<R(A1, A2)> : public 103 internal::FunctionMockerBase<R(A1, A2)> { 104 public: 105 typedef R F(A1, A2); 106 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 107 108 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2) { 109 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2)); 110 return this->current_spec(); 111 } 112 113 R Invoke(A1 a1, A2 a2) { 114 // Even though gcc and MSVC don't enforce it, 'this->' is required 115 // by the C++ standard [14.6.4] here, as the base class type is 116 // dependent on the template argument (and thus shouldn't be 117 // looked into when resolving InvokeWith). 118 return this->InvokeWith(ArgumentTuple(a1, a2)); 119 } 120 }; 121 122 template <typename R, typename A1, typename A2, typename A3> 123 class FunctionMocker<R(A1, A2, A3)> : public 124 internal::FunctionMockerBase<R(A1, A2, A3)> { 125 public: 126 typedef R F(A1, A2, A3); 127 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 128 129 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 130 const Matcher<A3>& m3) { 131 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3)); 132 return this->current_spec(); 133 } 134 135 R Invoke(A1 a1, A2 a2, A3 a3) { 136 // Even though gcc and MSVC don't enforce it, 'this->' is required 137 // by the C++ standard [14.6.4] here, as the base class type is 138 // dependent on the template argument (and thus shouldn't be 139 // looked into when resolving InvokeWith). 140 return this->InvokeWith(ArgumentTuple(a1, a2, a3)); 141 } 142 }; 143 144 template <typename R, typename A1, typename A2, typename A3, typename A4> 145 class FunctionMocker<R(A1, A2, A3, A4)> : public 146 internal::FunctionMockerBase<R(A1, A2, A3, A4)> { 147 public: 148 typedef R F(A1, A2, A3, A4); 149 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 150 151 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 152 const Matcher<A3>& m3, const Matcher<A4>& m4) { 153 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4)); 154 return this->current_spec(); 155 } 156 157 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4) { 158 // Even though gcc and MSVC don't enforce it, 'this->' is required 159 // by the C++ standard [14.6.4] here, as the base class type is 160 // dependent on the template argument (and thus shouldn't be 161 // looked into when resolving InvokeWith). 162 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4)); 163 } 164 }; 165 166 template <typename R, typename A1, typename A2, typename A3, typename A4, 167 typename A5> 168 class FunctionMocker<R(A1, A2, A3, A4, A5)> : public 169 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5)> { 170 public: 171 typedef R F(A1, A2, A3, A4, A5); 172 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 173 174 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 175 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5) { 176 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, 177 m5)); 178 return this->current_spec(); 179 } 180 181 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { 182 // Even though gcc and MSVC don't enforce it, 'this->' is required 183 // by the C++ standard [14.6.4] here, as the base class type is 184 // dependent on the template argument (and thus shouldn't be 185 // looked into when resolving InvokeWith). 186 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5)); 187 } 188 }; 189 190 template <typename R, typename A1, typename A2, typename A3, typename A4, 191 typename A5, typename A6> 192 class FunctionMocker<R(A1, A2, A3, A4, A5, A6)> : public 193 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6)> { 194 public: 195 typedef R F(A1, A2, A3, A4, A5, A6); 196 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 197 198 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 199 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 200 const Matcher<A6>& m6) { 201 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5, 202 m6)); 203 return this->current_spec(); 204 } 205 206 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { 207 // Even though gcc and MSVC don't enforce it, 'this->' is required 208 // by the C++ standard [14.6.4] here, as the base class type is 209 // dependent on the template argument (and thus shouldn't be 210 // looked into when resolving InvokeWith). 211 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6)); 212 } 213 }; 214 215 template <typename R, typename A1, typename A2, typename A3, typename A4, 216 typename A5, typename A6, typename A7> 217 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7)> : public 218 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7)> { 219 public: 220 typedef R F(A1, A2, A3, A4, A5, A6, A7); 221 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 222 223 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 224 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 225 const Matcher<A6>& m6, const Matcher<A7>& m7) { 226 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5, 227 m6, m7)); 228 return this->current_spec(); 229 } 230 231 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { 232 // Even though gcc and MSVC don't enforce it, 'this->' is required 233 // by the C++ standard [14.6.4] here, as the base class type is 234 // dependent on the template argument (and thus shouldn't be 235 // looked into when resolving InvokeWith). 236 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7)); 237 } 238 }; 239 240 template <typename R, typename A1, typename A2, typename A3, typename A4, 241 typename A5, typename A6, typename A7, typename A8> 242 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8)> : public 243 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8)> { 244 public: 245 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8); 246 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 247 248 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 249 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 250 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8) { 251 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5, 252 m6, m7, m8)); 253 return this->current_spec(); 254 } 255 256 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { 257 // Even though gcc and MSVC don't enforce it, 'this->' is required 258 // by the C++ standard [14.6.4] here, as the base class type is 259 // dependent on the template argument (and thus shouldn't be 260 // looked into when resolving InvokeWith). 261 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8)); 262 } 263 }; 264 265 template <typename R, typename A1, typename A2, typename A3, typename A4, 266 typename A5, typename A6, typename A7, typename A8, typename A9> 267 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> : public 268 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> { 269 public: 270 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9); 271 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 272 273 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 274 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 275 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8, 276 const Matcher<A9>& m9) { 277 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5, 278 m6, m7, m8, m9)); 279 return this->current_spec(); 280 } 281 282 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { 283 // Even though gcc and MSVC don't enforce it, 'this->' is required 284 // by the C++ standard [14.6.4] here, as the base class type is 285 // dependent on the template argument (and thus shouldn't be 286 // looked into when resolving InvokeWith). 287 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9)); 288 } 289 }; 290 291 template <typename R, typename A1, typename A2, typename A3, typename A4, 292 typename A5, typename A6, typename A7, typename A8, typename A9, 293 typename A10> 294 class FunctionMocker<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : public 295 internal::FunctionMockerBase<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> { 296 public: 297 typedef R F(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); 298 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; 299 300 MockSpec<F>& With(const Matcher<A1>& m1, const Matcher<A2>& m2, 301 const Matcher<A3>& m3, const Matcher<A4>& m4, const Matcher<A5>& m5, 302 const Matcher<A6>& m6, const Matcher<A7>& m7, const Matcher<A8>& m8, 303 const Matcher<A9>& m9, const Matcher<A10>& m10) { 304 this->current_spec().SetMatchers(::std::tr1::make_tuple(m1, m2, m3, m4, m5, 305 m6, m7, m8, m9, m10)); 306 return this->current_spec(); 307 } 308 309 R Invoke(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, 310 A10 a10) { 311 // Even though gcc and MSVC don't enforce it, 'this->' is required 312 // by the C++ standard [14.6.4] here, as the base class type is 313 // dependent on the template argument (and thus shouldn't be 314 // looked into when resolving InvokeWith). 315 return this->InvokeWith(ArgumentTuple(a1, a2, a3, a4, a5, a6, a7, a8, a9, 316 a10)); 317 } 318 }; 319 320 } // namespace internal 321 322 // The style guide prohibits "using" statements in a namespace scope 323 // inside a header file. However, the FunctionMocker class template 324 // is meant to be defined in the ::testing namespace. The following 325 // line is just a trick for working around a bug in MSVC 8.0, which 326 // cannot handle it if we define FunctionMocker in ::testing. 327 using internal::FunctionMocker; 328 329 // The result type of function type F. 330 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 331 #define GMOCK_RESULT_(tn, F) tn ::testing::internal::Function<F>::Result 332 333 // The type of argument N of function type F. 334 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 335 #define GMOCK_ARG_(tn, F, N) tn ::testing::internal::Function<F>::Argument##N 336 337 // The matcher type for argument N of function type F. 338 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 339 #define GMOCK_MATCHER_(tn, F, N) const ::testing::Matcher<GMOCK_ARG_(tn, F, N)>& 340 341 // The variable for mocking the given method. 342 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 343 #define GMOCK_MOCKER_(arity, constness, Method) \ 344 GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) 345 346 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 347 #define GMOCK_METHOD0_(tn, constness, ct, Method, F) \ 348 GMOCK_RESULT_(tn, F) ct Method() constness { \ 349 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 350 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \ 351 this_method_does_not_take_0_arguments); \ 352 GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \ 353 return GMOCK_MOCKER_(0, constness, Method).Invoke(); \ 354 } \ 355 ::testing::MockSpec<F>& \ 356 gmock_##Method() constness { \ 357 GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \ 358 return GMOCK_MOCKER_(0, constness, Method).With(); \ 359 } \ 360 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(0, constness, Method) 361 362 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 363 #define GMOCK_METHOD1_(tn, constness, ct, Method, F) \ 364 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1) constness { \ 365 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 366 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \ 367 this_method_does_not_take_1_argument); \ 368 GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \ 369 return GMOCK_MOCKER_(1, constness, Method).Invoke(gmock_a1); \ 370 } \ 371 ::testing::MockSpec<F>& \ 372 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1) constness { \ 373 GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \ 374 return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \ 375 } \ 376 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(1, constness, Method) 377 378 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 379 #define GMOCK_METHOD2_(tn, constness, ct, Method, F) \ 380 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 381 GMOCK_ARG_(tn, F, 2) gmock_a2) constness { \ 382 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 383 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \ 384 this_method_does_not_take_2_arguments); \ 385 GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \ 386 return GMOCK_MOCKER_(2, constness, Method).Invoke(gmock_a1, gmock_a2); \ 387 } \ 388 ::testing::MockSpec<F>& \ 389 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 390 GMOCK_MATCHER_(tn, F, 2) gmock_a2) constness { \ 391 GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \ 392 return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \ 393 } \ 394 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(2, constness, Method) 395 396 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 397 #define GMOCK_METHOD3_(tn, constness, ct, Method, F) \ 398 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 399 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 400 GMOCK_ARG_(tn, F, 3) gmock_a3) constness { \ 401 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 402 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \ 403 this_method_does_not_take_3_arguments); \ 404 GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \ 405 return GMOCK_MOCKER_(3, constness, Method).Invoke(gmock_a1, gmock_a2, \ 406 gmock_a3); \ 407 } \ 408 ::testing::MockSpec<F>& \ 409 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 410 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 411 GMOCK_MATCHER_(tn, F, 3) gmock_a3) constness { \ 412 GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \ 413 return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \ 414 gmock_a3); \ 415 } \ 416 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(3, constness, Method) 417 418 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 419 #define GMOCK_METHOD4_(tn, constness, ct, Method, F) \ 420 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 421 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 422 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 423 GMOCK_ARG_(tn, F, 4) gmock_a4) constness { \ 424 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 425 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \ 426 this_method_does_not_take_4_arguments); \ 427 GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \ 428 return GMOCK_MOCKER_(4, constness, Method).Invoke(gmock_a1, gmock_a2, \ 429 gmock_a3, gmock_a4); \ 430 } \ 431 ::testing::MockSpec<F>& \ 432 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 433 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 434 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 435 GMOCK_MATCHER_(tn, F, 4) gmock_a4) constness { \ 436 GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \ 437 return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \ 438 gmock_a3, gmock_a4); \ 439 } \ 440 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(4, constness, Method) 441 442 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 443 #define GMOCK_METHOD5_(tn, constness, ct, Method, F) \ 444 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 445 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 446 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 447 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 448 GMOCK_ARG_(tn, F, 5) gmock_a5) constness { \ 449 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 450 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \ 451 this_method_does_not_take_5_arguments); \ 452 GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \ 453 return GMOCK_MOCKER_(5, constness, Method).Invoke(gmock_a1, gmock_a2, \ 454 gmock_a3, gmock_a4, gmock_a5); \ 455 } \ 456 ::testing::MockSpec<F>& \ 457 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 458 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 459 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 460 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 461 GMOCK_MATCHER_(tn, F, 5) gmock_a5) constness { \ 462 GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \ 463 return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \ 464 gmock_a3, gmock_a4, gmock_a5); \ 465 } \ 466 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(5, constness, Method) 467 468 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 469 #define GMOCK_METHOD6_(tn, constness, ct, Method, F) \ 470 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 471 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 472 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 473 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 474 GMOCK_ARG_(tn, F, 5) gmock_a5, \ 475 GMOCK_ARG_(tn, F, 6) gmock_a6) constness { \ 476 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 477 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \ 478 this_method_does_not_take_6_arguments); \ 479 GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \ 480 return GMOCK_MOCKER_(6, constness, Method).Invoke(gmock_a1, gmock_a2, \ 481 gmock_a3, gmock_a4, gmock_a5, gmock_a6); \ 482 } \ 483 ::testing::MockSpec<F>& \ 484 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 485 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 486 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 487 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 488 GMOCK_MATCHER_(tn, F, 5) gmock_a5, \ 489 GMOCK_MATCHER_(tn, F, 6) gmock_a6) constness { \ 490 GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \ 491 return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \ 492 gmock_a3, gmock_a4, gmock_a5, gmock_a6); \ 493 } \ 494 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(6, constness, Method) 495 496 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 497 #define GMOCK_METHOD7_(tn, constness, ct, Method, F) \ 498 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 499 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 500 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 501 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 502 GMOCK_ARG_(tn, F, 5) gmock_a5, \ 503 GMOCK_ARG_(tn, F, 6) gmock_a6, \ 504 GMOCK_ARG_(tn, F, 7) gmock_a7) constness { \ 505 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 506 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \ 507 this_method_does_not_take_7_arguments); \ 508 GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \ 509 return GMOCK_MOCKER_(7, constness, Method).Invoke(gmock_a1, gmock_a2, \ 510 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \ 511 } \ 512 ::testing::MockSpec<F>& \ 513 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 514 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 515 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 516 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 517 GMOCK_MATCHER_(tn, F, 5) gmock_a5, \ 518 GMOCK_MATCHER_(tn, F, 6) gmock_a6, \ 519 GMOCK_MATCHER_(tn, F, 7) gmock_a7) constness { \ 520 GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \ 521 return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \ 522 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \ 523 } \ 524 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(7, constness, Method) 525 526 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 527 #define GMOCK_METHOD8_(tn, constness, ct, Method, F) \ 528 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 529 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 530 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 531 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 532 GMOCK_ARG_(tn, F, 5) gmock_a5, \ 533 GMOCK_ARG_(tn, F, 6) gmock_a6, \ 534 GMOCK_ARG_(tn, F, 7) gmock_a7, \ 535 GMOCK_ARG_(tn, F, 8) gmock_a8) constness { \ 536 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 537 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \ 538 this_method_does_not_take_8_arguments); \ 539 GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \ 540 return GMOCK_MOCKER_(8, constness, Method).Invoke(gmock_a1, gmock_a2, \ 541 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \ 542 } \ 543 ::testing::MockSpec<F>& \ 544 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 545 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 546 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 547 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 548 GMOCK_MATCHER_(tn, F, 5) gmock_a5, \ 549 GMOCK_MATCHER_(tn, F, 6) gmock_a6, \ 550 GMOCK_MATCHER_(tn, F, 7) gmock_a7, \ 551 GMOCK_MATCHER_(tn, F, 8) gmock_a8) constness { \ 552 GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \ 553 return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \ 554 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \ 555 } \ 556 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(8, constness, Method) 557 558 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 559 #define GMOCK_METHOD9_(tn, constness, ct, Method, F) \ 560 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 561 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 562 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 563 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 564 GMOCK_ARG_(tn, F, 5) gmock_a5, \ 565 GMOCK_ARG_(tn, F, 6) gmock_a6, \ 566 GMOCK_ARG_(tn, F, 7) gmock_a7, \ 567 GMOCK_ARG_(tn, F, 8) gmock_a8, \ 568 GMOCK_ARG_(tn, F, 9) gmock_a9) constness { \ 569 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 570 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \ 571 this_method_does_not_take_9_arguments); \ 572 GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \ 573 return GMOCK_MOCKER_(9, constness, Method).Invoke(gmock_a1, gmock_a2, \ 574 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \ 575 gmock_a9); \ 576 } \ 577 ::testing::MockSpec<F>& \ 578 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 579 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 580 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 581 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 582 GMOCK_MATCHER_(tn, F, 5) gmock_a5, \ 583 GMOCK_MATCHER_(tn, F, 6) gmock_a6, \ 584 GMOCK_MATCHER_(tn, F, 7) gmock_a7, \ 585 GMOCK_MATCHER_(tn, F, 8) gmock_a8, \ 586 GMOCK_MATCHER_(tn, F, 9) gmock_a9) constness { \ 587 GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \ 588 return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \ 589 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \ 590 gmock_a9); \ 591 } \ 592 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(9, constness, Method) 593 594 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! 595 #define GMOCK_METHOD10_(tn, constness, ct, Method, F) \ 596 GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \ 597 GMOCK_ARG_(tn, F, 2) gmock_a2, \ 598 GMOCK_ARG_(tn, F, 3) gmock_a3, \ 599 GMOCK_ARG_(tn, F, 4) gmock_a4, \ 600 GMOCK_ARG_(tn, F, 5) gmock_a5, \ 601 GMOCK_ARG_(tn, F, 6) gmock_a6, \ 602 GMOCK_ARG_(tn, F, 7) gmock_a7, \ 603 GMOCK_ARG_(tn, F, 8) gmock_a8, \ 604 GMOCK_ARG_(tn, F, 9) gmock_a9, \ 605 GMOCK_ARG_(tn, F, 10) gmock_a10) constness { \ 606 GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \ 607 tn ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \ 608 this_method_does_not_take_10_arguments); \ 609 GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \ 610 return GMOCK_MOCKER_(10, constness, Method).Invoke(gmock_a1, gmock_a2, \ 611 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \ 612 gmock_a10); \ 613 } \ 614 ::testing::MockSpec<F>& \ 615 gmock_##Method(GMOCK_MATCHER_(tn, F, 1) gmock_a1, \ 616 GMOCK_MATCHER_(tn, F, 2) gmock_a2, \ 617 GMOCK_MATCHER_(tn, F, 3) gmock_a3, \ 618 GMOCK_MATCHER_(tn, F, 4) gmock_a4, \ 619 GMOCK_MATCHER_(tn, F, 5) gmock_a5, \ 620 GMOCK_MATCHER_(tn, F, 6) gmock_a6, \ 621 GMOCK_MATCHER_(tn, F, 7) gmock_a7, \ 622 GMOCK_MATCHER_(tn, F, 8) gmock_a8, \ 623 GMOCK_MATCHER_(tn, F, 9) gmock_a9, \ 624 GMOCK_MATCHER_(tn, F, 10) gmock_a10) constness { \ 625 GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \ 626 return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \ 627 gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \ 628 gmock_a10); \ 629 } \ 630 mutable ::testing::FunctionMocker<F> GMOCK_MOCKER_(10, constness, Method) 631 632 #define MOCK_METHOD0(m, F) GMOCK_METHOD0_(, , , m, F) 633 #define MOCK_METHOD1(m, F) GMOCK_METHOD1_(, , , m, F) 634 #define MOCK_METHOD2(m, F) GMOCK_METHOD2_(, , , m, F) 635 #define MOCK_METHOD3(m, F) GMOCK_METHOD3_(, , , m, F) 636 #define MOCK_METHOD4(m, F) GMOCK_METHOD4_(, , , m, F) 637 #define MOCK_METHOD5(m, F) GMOCK_METHOD5_(, , , m, F) 638 #define MOCK_METHOD6(m, F) GMOCK_METHOD6_(, , , m, F) 639 #define MOCK_METHOD7(m, F) GMOCK_METHOD7_(, , , m, F) 640 #define MOCK_METHOD8(m, F) GMOCK_METHOD8_(, , , m, F) 641 #define MOCK_METHOD9(m, F) GMOCK_METHOD9_(, , , m, F) 642 #define MOCK_METHOD10(m, F) GMOCK_METHOD10_(, , , m, F) 643 644 #define MOCK_CONST_METHOD0(m, F) GMOCK_METHOD0_(, const, , m, F) 645 #define MOCK_CONST_METHOD1(m, F) GMOCK_METHOD1_(, const, , m, F) 646 #define MOCK_CONST_METHOD2(m, F) GMOCK_METHOD2_(, const, , m, F) 647 #define MOCK_CONST_METHOD3(m, F) GMOCK_METHOD3_(, const, , m, F) 648 #define MOCK_CONST_METHOD4(m, F) GMOCK_METHOD4_(, const, , m, F) 649 #define MOCK_CONST_METHOD5(m, F) GMOCK_METHOD5_(, const, , m, F) 650 #define MOCK_CONST_METHOD6(m, F) GMOCK_METHOD6_(, const, , m, F) 651 #define MOCK_CONST_METHOD7(m, F) GMOCK_METHOD7_(, const, , m, F) 652 #define MOCK_CONST_METHOD8(m, F) GMOCK_METHOD8_(, const, , m, F) 653 #define MOCK_CONST_METHOD9(m, F) GMOCK_METHOD9_(, const, , m, F) 654 #define MOCK_CONST_METHOD10(m, F) GMOCK_METHOD10_(, const, , m, F) 655 656 #define MOCK_METHOD0_T(m, F) GMOCK_METHOD0_(typename, , , m, F) 657 #define MOCK_METHOD1_T(m, F) GMOCK_METHOD1_(typename, , , m, F) 658 #define MOCK_METHOD2_T(m, F) GMOCK_METHOD2_(typename, , , m, F) 659 #define MOCK_METHOD3_T(m, F) GMOCK_METHOD3_(typename, , , m, F) 660 #define MOCK_METHOD4_T(m, F) GMOCK_METHOD4_(typename, , , m, F) 661 #define MOCK_METHOD5_T(m, F) GMOCK_METHOD5_(typename, , , m, F) 662 #define MOCK_METHOD6_T(m, F) GMOCK_METHOD6_(typename, , , m, F) 663 #define MOCK_METHOD7_T(m, F) GMOCK_METHOD7_(typename, , , m, F) 664 #define MOCK_METHOD8_T(m, F) GMOCK_METHOD8_(typename, , , m, F) 665 #define MOCK_METHOD9_T(m, F) GMOCK_METHOD9_(typename, , , m, F) 666 #define MOCK_METHOD10_T(m, F) GMOCK_METHOD10_(typename, , , m, F) 667 668 #define MOCK_CONST_METHOD0_T(m, F) GMOCK_METHOD0_(typename, const, , m, F) 669 #define MOCK_CONST_METHOD1_T(m, F) GMOCK_METHOD1_(typename, const, , m, F) 670 #define MOCK_CONST_METHOD2_T(m, F) GMOCK_METHOD2_(typename, const, , m, F) 671 #define MOCK_CONST_METHOD3_T(m, F) GMOCK_METHOD3_(typename, const, , m, F) 672 #define MOCK_CONST_METHOD4_T(m, F) GMOCK_METHOD4_(typename, const, , m, F) 673 #define MOCK_CONST_METHOD5_T(m, F) GMOCK_METHOD5_(typename, const, , m, F) 674 #define MOCK_CONST_METHOD6_T(m, F) GMOCK_METHOD6_(typename, const, , m, F) 675 #define MOCK_CONST_METHOD7_T(m, F) GMOCK_METHOD7_(typename, const, , m, F) 676 #define MOCK_CONST_METHOD8_T(m, F) GMOCK_METHOD8_(typename, const, , m, F) 677 #define MOCK_CONST_METHOD9_T(m, F) GMOCK_METHOD9_(typename, const, , m, F) 678 #define MOCK_CONST_METHOD10_T(m, F) GMOCK_METHOD10_(typename, const, , m, F) 679 680 #define MOCK_METHOD0_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD0_(, , ct, m, F) 681 #define MOCK_METHOD1_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD1_(, , ct, m, F) 682 #define MOCK_METHOD2_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD2_(, , ct, m, F) 683 #define MOCK_METHOD3_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD3_(, , ct, m, F) 684 #define MOCK_METHOD4_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD4_(, , ct, m, F) 685 #define MOCK_METHOD5_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD5_(, , ct, m, F) 686 #define MOCK_METHOD6_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD6_(, , ct, m, F) 687 #define MOCK_METHOD7_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD7_(, , ct, m, F) 688 #define MOCK_METHOD8_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD8_(, , ct, m, F) 689 #define MOCK_METHOD9_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD9_(, , ct, m, F) 690 #define MOCK_METHOD10_WITH_CALLTYPE(ct, m, F) GMOCK_METHOD10_(, , ct, m, F) 691 692 #define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, F) \ 693 GMOCK_METHOD0_(, const, ct, m, F) 694 #define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, F) \ 695 GMOCK_METHOD1_(, const, ct, m, F) 696 #define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, F) \ 697 GMOCK_METHOD2_(, const, ct, m, F) 698 #define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, F) \ 699 GMOCK_METHOD3_(, const, ct, m, F) 700 #define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, F) \ 701 GMOCK_METHOD4_(, const, ct, m, F) 702 #define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, F) \ 703 GMOCK_METHOD5_(, const, ct, m, F) 704 #define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, F) \ 705 GMOCK_METHOD6_(, const, ct, m, F) 706 #define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, F) \ 707 GMOCK_METHOD7_(, const, ct, m, F) 708 #define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, F) \ 709 GMOCK_METHOD8_(, const, ct, m, F) 710 #define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, F) \ 711 GMOCK_METHOD9_(, const, ct, m, F) 712 #define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, F) \ 713 GMOCK_METHOD10_(, const, ct, m, F) 714 715 #define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, F) \ 716 GMOCK_METHOD0_(typename, , ct, m, F) 717 #define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, F) \ 718 GMOCK_METHOD1_(typename, , ct, m, F) 719 #define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, F) \ 720 GMOCK_METHOD2_(typename, , ct, m, F) 721 #define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, F) \ 722 GMOCK_METHOD3_(typename, , ct, m, F) 723 #define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, F) \ 724 GMOCK_METHOD4_(typename, , ct, m, F) 725 #define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, F) \ 726 GMOCK_METHOD5_(typename, , ct, m, F) 727 #define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, F) \ 728 GMOCK_METHOD6_(typename, , ct, m, F) 729 #define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, F) \ 730 GMOCK_METHOD7_(typename, , ct, m, F) 731 #define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, F) \ 732 GMOCK_METHOD8_(typename, , ct, m, F) 733 #define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, F) \ 734 GMOCK_METHOD9_(typename, , ct, m, F) 735 #define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, F) \ 736 GMOCK_METHOD10_(typename, , ct, m, F) 737 738 #define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, F) \ 739 GMOCK_METHOD0_(typename, const, ct, m, F) 740 #define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, F) \ 741 GMOCK_METHOD1_(typename, const, ct, m, F) 742 #define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, F) \ 743 GMOCK_METHOD2_(typename, const, ct, m, F) 744 #define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, F) \ 745 GMOCK_METHOD3_(typename, const, ct, m, F) 746 #define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, F) \ 747 GMOCK_METHOD4_(typename, const, ct, m, F) 748 #define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, F) \ 749 GMOCK_METHOD5_(typename, const, ct, m, F) 750 #define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, F) \ 751 GMOCK_METHOD6_(typename, const, ct, m, F) 752 #define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, F) \ 753 GMOCK_METHOD7_(typename, const, ct, m, F) 754 #define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, F) \ 755 GMOCK_METHOD8_(typename, const, ct, m, F) 756 #define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, F) \ 757 GMOCK_METHOD9_(typename, const, ct, m, F) 758 #define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, F) \ 759 GMOCK_METHOD10_(typename, const, ct, m, F) 760 761 // A MockFunction<F> class has one mock method whose type is F. It is 762 // useful when you just want your test code to emit some messages and 763 // have Google Mock verify the right messages are sent (and perhaps at 764 // the right times). For example, if you are exercising code: 765 // 766 // Foo(1); 767 // Foo(2); 768 // Foo(3); 769 // 770 // and want to verify that Foo(1) and Foo(3) both invoke 771 // mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: 772 // 773 // TEST(FooTest, InvokesBarCorrectly) { 774 // MyMock mock; 775 // MockFunction<void(string check_point_name)> check; 776 // { 777 // InSequence s; 778 // 779 // EXPECT_CALL(mock, Bar("a")); 780 // EXPECT_CALL(check, Call("1")); 781 // EXPECT_CALL(check, Call("2")); 782 // EXPECT_CALL(mock, Bar("a")); 783 // } 784 // Foo(1); 785 // check.Call("1"); 786 // Foo(2); 787 // check.Call("2"); 788 // Foo(3); 789 // } 790 // 791 // The expectation spec says that the first Bar("a") must happen 792 // before check point "1", the second Bar("a") must happen after check 793 // point "2", and nothing should happen between the two check 794 // points. The explicit check points make it easy to tell which 795 // Bar("a") is called by which call to Foo(). 796 template <typename F> 797 class MockFunction; 798 799 template <typename R> 800 class MockFunction<R()> { 801 public: 802 MockFunction() {} 803 804 MOCK_METHOD0_T(Call, R()); 805 806 private: 807 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 808 }; 809 810 template <typename R, typename A0> 811 class MockFunction<R(A0)> { 812 public: 813 MockFunction() {} 814 815 MOCK_METHOD1_T(Call, R(A0)); 816 817 private: 818 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 819 }; 820 821 template <typename R, typename A0, typename A1> 822 class MockFunction<R(A0, A1)> { 823 public: 824 MockFunction() {} 825 826 MOCK_METHOD2_T(Call, R(A0, A1)); 827 828 private: 829 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 830 }; 831 832 template <typename R, typename A0, typename A1, typename A2> 833 class MockFunction<R(A0, A1, A2)> { 834 public: 835 MockFunction() {} 836 837 MOCK_METHOD3_T(Call, R(A0, A1, A2)); 838 839 private: 840 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 841 }; 842 843 template <typename R, typename A0, typename A1, typename A2, typename A3> 844 class MockFunction<R(A0, A1, A2, A3)> { 845 public: 846 MockFunction() {} 847 848 MOCK_METHOD4_T(Call, R(A0, A1, A2, A3)); 849 850 private: 851 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 852 }; 853 854 template <typename R, typename A0, typename A1, typename A2, typename A3, 855 typename A4> 856 class MockFunction<R(A0, A1, A2, A3, A4)> { 857 public: 858 MockFunction() {} 859 860 MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4)); 861 862 private: 863 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 864 }; 865 866 template <typename R, typename A0, typename A1, typename A2, typename A3, 867 typename A4, typename A5> 868 class MockFunction<R(A0, A1, A2, A3, A4, A5)> { 869 public: 870 MockFunction() {} 871 872 MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5)); 873 874 private: 875 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 876 }; 877 878 template <typename R, typename A0, typename A1, typename A2, typename A3, 879 typename A4, typename A5, typename A6> 880 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> { 881 public: 882 MockFunction() {} 883 884 MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6)); 885 886 private: 887 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 888 }; 889 890 template <typename R, typename A0, typename A1, typename A2, typename A3, 891 typename A4, typename A5, typename A6, typename A7> 892 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> { 893 public: 894 MockFunction() {} 895 896 MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7)); 897 898 private: 899 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 900 }; 901 902 template <typename R, typename A0, typename A1, typename A2, typename A3, 903 typename A4, typename A5, typename A6, typename A7, typename A8> 904 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> { 905 public: 906 MockFunction() {} 907 908 MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8)); 909 910 private: 911 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 912 }; 913 914 template <typename R, typename A0, typename A1, typename A2, typename A3, 915 typename A4, typename A5, typename A6, typename A7, typename A8, 916 typename A9> 917 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> { 918 public: 919 MockFunction() {} 920 921 MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); 922 923 private: 924 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction); 925 }; 926 927 } // namespace testing 928 929 #endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ 930
