external/C-Mock/v0.3.1/cmock/cmock-function-mockers.h

   1 // This file was GENERATED by command:
   2 //     pump.py cmock-function-mockers.h.pump
   3 // DO NOT EDIT BY HAND!!!
   4
   5 // Copyright 2021, Hubert Jagodziński
   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 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 //
  31 // Author: hubert.jagodzinski@gmail.com (Hubert Jagodziński)
  32
  33 // C Mock - Google Mock's extension allowing a function mocking.
  34 //
  35 // This file implements DECLARE_FUNCTION_MOCKn() and IMPLEMENT_FUNCTION_MOCKn()
  36 // macros of various arities.
  37
  38 #ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
  39 #define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_
  40
  41 #include <dlfcn.h>
  42
  43 #include <sstream>
  44 #include <stdexcept>
  45
  46 #define DECLARE_FUNCTION_MOCK0(c, n, F) \
  47 class c \
  48 { \
  49     typedef GMOCK_RESULT_(, F) (*func_type)(); \
  50 \
  51     public: \
  52         static func_type real; \
  53 \
  54         c(); \
  55         ~c(); \
  56 \
  57         GMOCK_RESULT_(, F) operator()(); \
  58         ::testing::MockSpec<F> cmock_func(); \
  59 \
  60     private: \
  61         static func_type lookup(); \
  62         static GMOCK_RESULT_(, F) call(); \
  63 \
  64         static c *instance; \
  65 \
  66         ::testing::FunctionMocker<F> mocker; \
  67 \
  68         friend GMOCK_RESULT_(, F) n(); \
  69 };
  70
  71 #define IMPLEMENT_FUNCTION_MOCK0(c, n, F) \
  72 c::c() { \
  73     instance = this; \
  74 } \
  75 \
  76 c::~c() { \
  77     instance = NULL; \
  78 } \
  79 \
  80 GMOCK_RESULT_(, F) c::operator()() { \
  81     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
  82     ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
  83      this_method_does_not_take_0_arguments); \
  84      mocker.SetOwnerAndName(this, #n); \
  85      return mocker.Invoke(); \
  86 } \
  87 \
  88 ::testing::MockSpec<F> c::cmock_func() { \
  89     mocker.RegisterOwner(this); \
  90     return mocker.With(); \
  91 } \
  92 \
  93 c::func_type c::lookup() { \
  94     return (c::func_type)dlsym(RTLD_NEXT, #n); \
  95 } \
  96 \
  97 GMOCK_RESULT_(, F) c::call() { \
  98     if (instance != NULL) { \
  99         return (*instance)(); \
 100     } \
 101 \
 102     if (real == NULL) { \
 103         std::ostringstream msg; \
 104         msg << "Error: Function " << #n; \
 105         msg << " not found. Neither mock nor real function is present."; \
 106         throw std::logic_error(msg.str()); \
 107     } \
 108     return real(); \
 109 } \
 110 \
 111 c *c::instance = NULL; \
 112 c::func_type c::real = lookup(); \
 113 \
 114 GMOCK_RESULT_(, F) n() { \
 115     return c::call(); \
 116 }
 117
 118 #define DECLARE_FUNCTION_MOCK1(c, n, F) \
 119 class c \
 120 { \
 121     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1); \
 122 \
 123     public: \
 124         static func_type real; \
 125 \
 126         c(); \
 127         ~c(); \
 128 \
 129         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1); \
 130         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1); \
 131 \
 132     private: \
 133         static func_type lookup(); \
 134         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1); \
 135 \
 136         static c *instance; \
 137 \
 138         ::testing::FunctionMocker<F> mocker; \
 139 \
 140         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1); \
 141 };
 142
 143 #define IMPLEMENT_FUNCTION_MOCK1(c, n, F) \
 144 c::c() { \
 145     instance = this; \
 146 } \
 147 \
 148 c::~c() { \
 149     instance = NULL; \
 150 } \
 151 \
 152 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1) { \
 153     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 154     ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
 155      this_method_does_not_take_1_argument); \
 156      mocker.SetOwnerAndName(this, #n); \
 157      return mocker.Invoke(cmock_a1); \
 158 } \
 159 \
 160 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1) { \
 161     mocker.RegisterOwner(this); \
 162     return mocker.With(cmock_a1); \
 163 } \
 164 \
 165 c::func_type c::lookup() { \
 166     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 167 } \
 168 \
 169 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1) { \
 170     if (instance != NULL) { \
 171         return (*instance)(cmock_a1); \
 172     } \
 173 \
 174     if (real == NULL) { \
 175         std::ostringstream msg; \
 176         msg << "Error: Function " << #n; \
 177         msg << " not found. Neither mock nor real function is present."; \
 178         throw std::logic_error(msg.str()); \
 179     } \
 180     return real(cmock_a1); \
 181 } \
 182 \
 183 c *c::instance = NULL; \
 184 c::func_type c::real = lookup(); \
 185 \
 186 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1) { \
 187     return c::call(cmock_a1); \
 188 }
 189
 190 #define DECLARE_FUNCTION_MOCK2(c, n, F) \
 191 class c \
 192 { \
 193     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 194         GMOCK_ARG_(, 2, F) cmock_a2); \
 195 \
 196     public: \
 197         static func_type real; \
 198 \
 199         c(); \
 200         ~c(); \
 201 \
 202         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 203             GMOCK_ARG_(, 2, F) cmock_a2); \
 204         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 205             GMOCK_MATCHER_(, 2, F) cmock_a2); \
 206 \
 207     private: \
 208         static func_type lookup(); \
 209         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 210             GMOCK_ARG_(, 2, F) cmock_a2); \
 211 \
 212         static c *instance; \
 213 \
 214         ::testing::FunctionMocker<F> mocker; \
 215 \
 216         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 217             2, F) cmock_a2); \
 218 };
 219
 220 #define IMPLEMENT_FUNCTION_MOCK2(c, n, F) \
 221 c::c() { \
 222     instance = this; \
 223 } \
 224 \
 225 c::~c() { \
 226     instance = NULL; \
 227 } \
 228 \
 229 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 230     F) cmock_a2) { \
 231     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 232     ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
 233      this_method_does_not_take_2_arguments); \
 234      mocker.SetOwnerAndName(this, #n); \
 235      return mocker.Invoke(cmock_a1, cmock_a2); \
 236 } \
 237 \
 238 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 239     GMOCK_MATCHER_(, 2, F) cmock_a2) { \
 240     mocker.RegisterOwner(this); \
 241     return mocker.With(cmock_a1, cmock_a2); \
 242 } \
 243 \
 244 c::func_type c::lookup() { \
 245     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 246 } \
 247 \
 248 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 249     F) cmock_a2) { \
 250     if (instance != NULL) { \
 251         return (*instance)(cmock_a1, cmock_a2); \
 252     } \
 253 \
 254     if (real == NULL) { \
 255         std::ostringstream msg; \
 256         msg << "Error: Function " << #n; \
 257         msg << " not found. Neither mock nor real function is present."; \
 258         throw std::logic_error(msg.str()); \
 259     } \
 260     return real(cmock_a1, cmock_a2); \
 261 } \
 262 \
 263 c *c::instance = NULL; \
 264 c::func_type c::real = lookup(); \
 265 \
 266 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 267     F) cmock_a2) { \
 268     return c::call(cmock_a1, cmock_a2); \
 269 }
 270
 271 #define DECLARE_FUNCTION_MOCK3(c, n, F) \
 272 class c \
 273 { \
 274     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 275         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
 276 \
 277     public: \
 278         static func_type real; \
 279 \
 280         c(); \
 281         ~c(); \
 282 \
 283         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 284             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
 285         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 286             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, \
 287             F) cmock_a3); \
 288 \
 289     private: \
 290         static func_type lookup(); \
 291         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 292             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
 293 \
 294         static c *instance; \
 295 \
 296         ::testing::FunctionMocker<F> mocker; \
 297 \
 298         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 299             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3); \
 300 };
 301
 302 #define IMPLEMENT_FUNCTION_MOCK3(c, n, F) \
 303 c::c() { \
 304     instance = this; \
 305 } \
 306 \
 307 c::~c() { \
 308     instance = NULL; \
 309 } \
 310 \
 311 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 312     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
 313     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 314     ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
 315      this_method_does_not_take_3_arguments); \
 316      mocker.SetOwnerAndName(this, #n); \
 317      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3); \
 318 } \
 319 \
 320 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 321     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3) { \
 322     mocker.RegisterOwner(this); \
 323     return mocker.With(cmock_a1, cmock_a2, cmock_a3); \
 324 } \
 325 \
 326 c::func_type c::lookup() { \
 327     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 328 } \
 329 \
 330 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 331     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
 332     if (instance != NULL) { \
 333         return (*instance)(cmock_a1, cmock_a2, cmock_a3); \
 334     } \
 335 \
 336     if (real == NULL) { \
 337         std::ostringstream msg; \
 338         msg << "Error: Function " << #n; \
 339         msg << " not found. Neither mock nor real function is present."; \
 340         throw std::logic_error(msg.str()); \
 341     } \
 342     return real(cmock_a1, cmock_a2, cmock_a3); \
 343 } \
 344 \
 345 c *c::instance = NULL; \
 346 c::func_type c::real = lookup(); \
 347 \
 348 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 349     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
 350     return c::call(cmock_a1, cmock_a2, cmock_a3); \
 351 }
 352
 353 #define DECLARE_FUNCTION_MOCK4(c, n, F) \
 354 class c \
 355 { \
 356     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 357         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 358         GMOCK_ARG_(, 4, F) cmock_a4); \
 359 \
 360     public: \
 361         static func_type real; \
 362 \
 363         c(); \
 364         ~c(); \
 365 \
 366         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 367             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 368             GMOCK_ARG_(, 4, F) cmock_a4); \
 369         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 370             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 371             GMOCK_MATCHER_(, 4, F) cmock_a4); \
 372 \
 373     private: \
 374         static func_type lookup(); \
 375         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 376             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 377             GMOCK_ARG_(, 4, F) cmock_a4); \
 378 \
 379         static c *instance; \
 380 \
 381         ::testing::FunctionMocker<F> mocker; \
 382 \
 383         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 384             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 385             F) cmock_a4); \
 386 };
 387
 388 #define IMPLEMENT_FUNCTION_MOCK4(c, n, F) \
 389 c::c() { \
 390     instance = this; \
 391 } \
 392 \
 393 c::~c() { \
 394     instance = NULL; \
 395 } \
 396 \
 397 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 398     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 399     F) cmock_a4) { \
 400     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 401     ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
 402      this_method_does_not_take_4_arguments); \
 403      mocker.SetOwnerAndName(this, #n); \
 404      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 405 } \
 406 \
 407 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 408     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 409     GMOCK_MATCHER_(, 4, F) cmock_a4) { \
 410     mocker.RegisterOwner(this); \
 411     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 412 } \
 413 \
 414 c::func_type c::lookup() { \
 415     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 416 } \
 417 \
 418 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 419     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 420     F) cmock_a4) { \
 421     if (instance != NULL) { \
 422         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 423     } \
 424 \
 425     if (real == NULL) { \
 426         std::ostringstream msg; \
 427         msg << "Error: Function " << #n; \
 428         msg << " not found. Neither mock nor real function is present."; \
 429         throw std::logic_error(msg.str()); \
 430     } \
 431     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 432 } \
 433 \
 434 c *c::instance = NULL; \
 435 c::func_type c::real = lookup(); \
 436 \
 437 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 438     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 439     F) cmock_a4) { \
 440     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 441 }
 442
 443 #define DECLARE_FUNCTION_MOCK5(c, n, F) \
 444 class c \
 445 { \
 446     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 447         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 448         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
 449 \
 450     public: \
 451         static func_type real; \
 452 \
 453         c(); \
 454         ~c(); \
 455 \
 456         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 457             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 458             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
 459         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 460             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 461             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, \
 462             F) cmock_a5); \
 463 \
 464     private: \
 465         static func_type lookup(); \
 466         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 467             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 468             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
 469 \
 470         static c *instance; \
 471 \
 472         ::testing::FunctionMocker<F> mocker; \
 473 \
 474         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 475             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 476             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5); \
 477 };
 478
 479 #define IMPLEMENT_FUNCTION_MOCK5(c, n, F) \
 480 c::c() { \
 481     instance = this; \
 482 } \
 483 \
 484 c::~c() { \
 485     instance = NULL; \
 486 } \
 487 \
 488 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 489     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 490     GMOCK_ARG_(, 5, F) cmock_a5) { \
 491     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 492     ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
 493      this_method_does_not_take_5_arguments); \
 494      mocker.SetOwnerAndName(this, #n); \
 495      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 496 } \
 497 \
 498 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 499     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 500     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5) { \
 501     mocker.RegisterOwner(this); \
 502     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 503 } \
 504 \
 505 c::func_type c::lookup() { \
 506     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 507 } \
 508 \
 509 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 510     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 511     GMOCK_ARG_(, 5, F) cmock_a5) { \
 512     if (instance != NULL) { \
 513         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 514     } \
 515 \
 516     if (real == NULL) { \
 517         std::ostringstream msg; \
 518         msg << "Error: Function " << #n; \
 519         msg << " not found. Neither mock nor real function is present."; \
 520         throw std::logic_error(msg.str()); \
 521     } \
 522     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 523 } \
 524 \
 525 c *c::instance = NULL; \
 526 c::func_type c::real = lookup(); \
 527 \
 528 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 529     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 530     GMOCK_ARG_(, 5, F) cmock_a5) { \
 531     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 532 }
 533
 534 #define DECLARE_FUNCTION_MOCK6(c, n, F) \
 535 class c \
 536 { \
 537     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 538         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 539         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 540         GMOCK_ARG_(, 6, F) cmock_a6); \
 541 \
 542     public: \
 543         static func_type real; \
 544 \
 545         c(); \
 546         ~c(); \
 547 \
 548         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 549             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 550             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 551             GMOCK_ARG_(, 6, F) cmock_a6); \
 552         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 553             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 554             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 555             GMOCK_MATCHER_(, 6, F) cmock_a6); \
 556 \
 557     private: \
 558         static func_type lookup(); \
 559         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 560             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 561             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 562             GMOCK_ARG_(, 6, F) cmock_a6); \
 563 \
 564         static c *instance; \
 565 \
 566         ::testing::FunctionMocker<F> mocker; \
 567 \
 568         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 569             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 570             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 571             F) cmock_a6); \
 572 };
 573
 574 #define IMPLEMENT_FUNCTION_MOCK6(c, n, F) \
 575 c::c() { \
 576     instance = this; \
 577 } \
 578 \
 579 c::~c() { \
 580     instance = NULL; \
 581 } \
 582 \
 583 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 584     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 585     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
 586     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 587     ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
 588      this_method_does_not_take_6_arguments); \
 589      mocker.SetOwnerAndName(this, #n); \
 590      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 591          cmock_a6); \
 592 } \
 593 \
 594 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 595     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 596     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 597     GMOCK_MATCHER_(, 6, F) cmock_a6) { \
 598     mocker.RegisterOwner(this); \
 599     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 600         cmock_a6); \
 601 } \
 602 \
 603 c::func_type c::lookup() { \
 604     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 605 } \
 606 \
 607 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 608     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 609     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
 610     if (instance != NULL) { \
 611         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 612             cmock_a6); \
 613     } \
 614 \
 615     if (real == NULL) { \
 616         std::ostringstream msg; \
 617         msg << "Error: Function " << #n; \
 618         msg << " not found. Neither mock nor real function is present."; \
 619         throw std::logic_error(msg.str()); \
 620     } \
 621     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6); \
 622 } \
 623 \
 624 c *c::instance = NULL; \
 625 c::func_type c::real = lookup(); \
 626 \
 627 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 628     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 629     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
 630     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 631         cmock_a6); \
 632 }
 633
 634 #define DECLARE_FUNCTION_MOCK7(c, n, F) \
 635 class c \
 636 { \
 637     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 638         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 639         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 640         GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
 641 \
 642     public: \
 643         static func_type real; \
 644 \
 645         c(); \
 646         ~c(); \
 647 \
 648         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 649             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 650             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 651             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
 652         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 653             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 654             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 655             GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, \
 656             F) cmock_a7); \
 657 \
 658     private: \
 659         static func_type lookup(); \
 660         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 661             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 662             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 663             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
 664 \
 665         static c *instance; \
 666 \
 667         ::testing::FunctionMocker<F> mocker; \
 668 \
 669         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 670             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 671             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 672             F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7); \
 673 };
 674
 675 #define IMPLEMENT_FUNCTION_MOCK7(c, n, F) \
 676 c::c() { \
 677     instance = this; \
 678 } \
 679 \
 680 c::~c() { \
 681     instance = NULL; \
 682 } \
 683 \
 684 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 685     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 686     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 687     F) cmock_a7) { \
 688     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 689     ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
 690      this_method_does_not_take_7_arguments); \
 691      mocker.SetOwnerAndName(this, #n); \
 692      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 693          cmock_a6, cmock_a7); \
 694 } \
 695 \
 696 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 697     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 698     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 699     GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7) { \
 700     mocker.RegisterOwner(this); \
 701     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 702         cmock_a6, cmock_a7); \
 703 } \
 704 \
 705 c::func_type c::lookup() { \
 706     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 707 } \
 708 \
 709 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 710     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 711     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 712     F) cmock_a7) { \
 713     if (instance != NULL) { \
 714         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 715             cmock_a6, cmock_a7); \
 716     } \
 717 \
 718     if (real == NULL) { \
 719         std::ostringstream msg; \
 720         msg << "Error: Function " << #n; \
 721         msg << " not found. Neither mock nor real function is present."; \
 722         throw std::logic_error(msg.str()); \
 723     } \
 724     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
 725         cmock_a7); \
 726 } \
 727 \
 728 c *c::instance = NULL; \
 729 c::func_type c::real = lookup(); \
 730 \
 731 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 732     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 733     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 734     F) cmock_a7) { \
 735     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 736         cmock_a6, cmock_a7); \
 737 }
 738
 739 #define DECLARE_FUNCTION_MOCK8(c, n, F) \
 740 class c \
 741 { \
 742     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 743         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 744         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 745         GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 746         GMOCK_ARG_(, 8, F) cmock_a8); \
 747 \
 748     public: \
 749         static func_type real; \
 750 \
 751         c(); \
 752         ~c(); \
 753 \
 754         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 755             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 756             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 757             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 758             GMOCK_ARG_(, 8, F) cmock_a8); \
 759         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 760             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 761             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 762             GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
 763             GMOCK_MATCHER_(, 8, F) cmock_a8); \
 764 \
 765     private: \
 766         static func_type lookup(); \
 767         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 768             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 769             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 770             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 771             GMOCK_ARG_(, 8, F) cmock_a8); \
 772 \
 773         static c *instance; \
 774 \
 775         ::testing::FunctionMocker<F> mocker; \
 776 \
 777         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 778             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 779             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 780             F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
 781             F) cmock_a8); \
 782 };
 783
 784 #define IMPLEMENT_FUNCTION_MOCK8(c, n, F) \
 785 c::c() { \
 786     instance = this; \
 787 } \
 788 \
 789 c::~c() { \
 790     instance = NULL; \
 791 } \
 792 \
 793 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 794     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 795     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 796     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
 797     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 798     ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
 799      this_method_does_not_take_8_arguments); \
 800      mocker.SetOwnerAndName(this, #n); \
 801      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 802          cmock_a6, cmock_a7, cmock_a8); \
 803 } \
 804 \
 805 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 806     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 807     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 808     GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
 809     GMOCK_MATCHER_(, 8, F) cmock_a8) { \
 810     mocker.RegisterOwner(this); \
 811     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 812         cmock_a6, cmock_a7, cmock_a8); \
 813 } \
 814 \
 815 c::func_type c::lookup() { \
 816     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 817 } \
 818 \
 819 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 820     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 821     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 822     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
 823     if (instance != NULL) { \
 824         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 825             cmock_a6, cmock_a7, cmock_a8); \
 826     } \
 827 \
 828     if (real == NULL) { \
 829         std::ostringstream msg; \
 830         msg << "Error: Function " << #n; \
 831         msg << " not found. Neither mock nor real function is present."; \
 832         throw std::logic_error(msg.str()); \
 833     } \
 834     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
 835         cmock_a7, cmock_a8); \
 836 } \
 837 \
 838 c *c::instance = NULL; \
 839 c::func_type c::real = lookup(); \
 840 \
 841 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 842     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 843     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 844     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
 845     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 846         cmock_a6, cmock_a7, cmock_a8); \
 847 }
 848
 849 #define DECLARE_FUNCTION_MOCK9(c, n, F) \
 850 class c \
 851 { \
 852     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 853         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 854         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 855         GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 856         GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
 857 \
 858     public: \
 859         static func_type real; \
 860 \
 861         c(); \
 862         ~c(); \
 863 \
 864         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 865             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 866             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 867             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 868             GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
 869         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 870             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 871             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 872             GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
 873             GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, \
 874             F) cmock_a9); \
 875 \
 876     private: \
 877         static func_type lookup(); \
 878         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 879             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 880             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 881             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 882             GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
 883 \
 884         static c *instance; \
 885 \
 886         ::testing::FunctionMocker<F> mocker; \
 887 \
 888         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
 889             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 890             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 891             F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
 892             F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9); \
 893 };
 894
 895 #define IMPLEMENT_FUNCTION_MOCK9(c, n, F) \
 896 c::c() { \
 897     instance = this; \
 898 } \
 899 \
 900 c::~c() { \
 901     instance = NULL; \
 902 } \
 903 \
 904 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 905     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 906     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 907     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 908     F) cmock_a9) { \
 909     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
 910     ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
 911      this_method_does_not_take_9_arguments); \
 912      mocker.SetOwnerAndName(this, #n); \
 913      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 914          cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 915 } \
 916 \
 917 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 918     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 919     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 920     GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
 921     GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9) { \
 922     mocker.RegisterOwner(this); \
 923     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 924         cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 925 } \
 926 \
 927 c::func_type c::lookup() { \
 928     return (c::func_type)dlsym(RTLD_NEXT, #n); \
 929 } \
 930 \
 931 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 932     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 933     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 934     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 935     F) cmock_a9) { \
 936     if (instance != NULL) { \
 937         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 938             cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 939     } \
 940 \
 941     if (real == NULL) { \
 942         std::ostringstream msg; \
 943         msg << "Error: Function " << #n; \
 944         msg << " not found. Neither mock nor real function is present."; \
 945         throw std::logic_error(msg.str()); \
 946     } \
 947     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
 948         cmock_a7, cmock_a8, cmock_a9); \
 949 } \
 950 \
 951 c *c::instance = NULL; \
 952 c::func_type c::real = lookup(); \
 953 \
 954 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 955     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 956     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 957     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 958     F) cmock_a9) { \
 959     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 960         cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 961 }
 962
 963 #define DECLARE_FUNCTION_MOCK10(c, n, F) \
 964 class c \
 965 { \
 966     typedef GMOCK_RESULT_(, F) (*func_type)(GMOCK_ARG_(, 1, F) cmock_a1, \
 967         GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 968         GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 969         GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 970         GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
 971         GMOCK_ARG_(, 10, F) cmock_a10); \
 972 \
 973     public: \
 974         static func_type real; \
 975 \
 976         c(); \
 977         ~c(); \
 978 \
 979         GMOCK_RESULT_(, F) operator()(GMOCK_ARG_(, 1, F) cmock_a1, \
 980             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 981             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 982             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 983             GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
 984             GMOCK_ARG_(, 10, F) cmock_a10); \
 985         ::testing::MockSpec<F> cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
 986             GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
 987             GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
 988             GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
 989             GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9, \
 990             GMOCK_MATCHER_(, 10, F) cmock_a10); \
 991 \
 992     private: \
 993         static func_type lookup(); \
 994         static GMOCK_RESULT_(, F) call(GMOCK_ARG_(, 1, F) cmock_a1, \
 995             GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 996             GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, \
 997             GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, \
 998             GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
 999             GMOCK_ARG_(, 10, F) cmock_a10); \
1000 \
1001         static c *instance; \
1002 \
1003         ::testing::FunctionMocker<F> mocker; \
1004 \
1005         friend GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, \
1006             2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
1007             F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
1008             F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
1009             F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, GMOCK_ARG_(, 10, \
1010             F) cmock_a10); \
1011 };
1012
1013 #define IMPLEMENT_FUNCTION_MOCK10(c, n, F) \
1014 c::c() { \
1015     instance = this; \
1016 } \
1017 \
1018 c::~c() { \
1019     instance = NULL; \
1020 } \
1021 \
1022 GMOCK_RESULT_(, F) c::operator()(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
1023     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
1024     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
1025     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
1026     GMOCK_ARG_(, 10, F) cmock_a10) { \
1027     GTEST_COMPILE_ASSERT_(::std::tuple_size< \
1028     ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
1029      this_method_does_not_take_10_arguments); \
1030      mocker.SetOwnerAndName(this, #n); \
1031      return mocker.Invoke(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
1032          cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
1033 } \
1034 \
1035 ::testing::MockSpec<F> c::cmock_func(GMOCK_MATCHER_(, 1, F) cmock_a1, \
1036     GMOCK_MATCHER_(, 2, F) cmock_a2, GMOCK_MATCHER_(, 3, F) cmock_a3, \
1037     GMOCK_MATCHER_(, 4, F) cmock_a4, GMOCK_MATCHER_(, 5, F) cmock_a5, \
1038     GMOCK_MATCHER_(, 6, F) cmock_a6, GMOCK_MATCHER_(, 7, F) cmock_a7, \
1039     GMOCK_MATCHER_(, 8, F) cmock_a8, GMOCK_MATCHER_(, 9, F) cmock_a9, \
1040     GMOCK_MATCHER_(, 10, F) cmock_a10) { \
1041     mocker.RegisterOwner(this); \
1042     return mocker.With(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
1043         cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
1044 } \
1045 \
1046 c::func_type c::lookup() { \
1047     return (c::func_type)dlsym(RTLD_NEXT, #n); \
1048 } \
1049 \
1050 GMOCK_RESULT_(, F) c::call(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
1051     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
1052     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
1053     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
1054     GMOCK_ARG_(, 10, F) cmock_a10) { \
1055     if (instance != NULL) { \
1056         return (*instance)(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
1057             cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
1058     } \
1059 \
1060     if (real == NULL) { \
1061         std::ostringstream msg; \
1062         msg << "Error: Function " << #n; \
1063         msg << " not found. Neither mock nor real function is present."; \
1064         throw std::logic_error(msg.str()); \
1065     } \
1066     return real(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, cmock_a6, \
1067         cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
1068 } \
1069 \
1070 c *c::instance = NULL; \
1071 c::func_type c::real = lookup(); \
1072 \
1073 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
1074     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
1075     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
1076     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
1077     GMOCK_ARG_(, 10, F) cmock_a10) { \
1078     return c::call(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
1079         cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
1080 }
1081
1082 #endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_MOCKERS_H_