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

   1 // This file was GENERATED by command:
   2 //     pump.py cmock-function-class-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 CMockMocker class and CMOCK_MOCK_FUNCTIONn() macros of
  36 // various arities.
  37
  38 #ifndef CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
  39 #define CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_
  40
  41 #include <dlfcn.h>
  42
  43 #include <sstream>
  44 #include <stdexcept>
  45
  46 // Allows finding an instance of a class:
  47 //   class Foo : public CMockMocker<Foo> { ... }
  48 //   Foo *p = CMockMocker<Foo>::cmock_get_instance();
  49 template<typename T>
  50 class CMockMocker
  51 {
  52 public:
  53         CMockMocker()
  54         {
  55                 instance = (T *)this;
  56         }
  57
  58         ~CMockMocker()
  59         {
  60                 instance = (T *)NULL;
  61         }
  62
  63         static T *cmock_get_instance() { return instance; }
  64
  65 private:
  66         static T *instance;
  67 };
  68
  69 template<typename T>
  70 T *CMockMocker<T>::instance = NULL;
  71
  72 // Find the real implementation of a mocked function
  73 static inline void *
  74 cmock_lookup(const char *fname)
  75 {
  76     return dlsym(RTLD_NEXT, fname);
  77 }
  78
  79 #define CMOCK_MOCK_FUNCTION0(c, n, F) \
  80 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)() = \
  81         (GMOCK_RESULT_(, F) (*)())cmock_lookup(#n); \
  82 \
  83 GMOCK_RESULT_(, F) n() { \
  84     c *mock = c::cmock_get_instance(); \
  85     if (mock != NULL) { \
  86         return mock->n(); \
  87     } \
  88         \
  89     if (__cmock_real_##c##_##n == NULL) { \
  90         std::ostringstream msg; \
  91         msg << "Error: Function " << #n; \
  92         msg << " not found. Neither mock nor real function is present."; \
  93         throw std::logic_error(msg.str()); \
  94     } \
  95     return __cmock_real_##c##_##n(); \
  96 } \
  97
  98 #define CMOCK_MOCK_FUNCTION1(c, n, F) \
  99 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 100     F) cmock_a1) = \
 101         (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1))cmock_lookup(#n); \
 102 \
 103 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1) { \
 104     c *mock = c::cmock_get_instance(); \
 105     if (mock != NULL) { \
 106         return mock->n(cmock_a1); \
 107     } \
 108         \
 109     if (__cmock_real_##c##_##n == NULL) { \
 110         std::ostringstream msg; \
 111         msg << "Error: Function " << #n; \
 112         msg << " not found. Neither mock nor real function is present."; \
 113         throw std::logic_error(msg.str()); \
 114     } \
 115     return __cmock_real_##c##_##n(cmock_a1); \
 116 } \
 117
 118 #define CMOCK_MOCK_FUNCTION2(c, n, F) \
 119 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 120     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2) = \
 121  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 122      F) cmock_a2))cmock_lookup(#n); \
 123 \
 124 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 125     F) cmock_a2) { \
 126     c *mock = c::cmock_get_instance(); \
 127     if (mock != NULL) { \
 128         return mock->n(cmock_a1, cmock_a2); \
 129     } \
 130         \
 131     if (__cmock_real_##c##_##n == NULL) { \
 132         std::ostringstream msg; \
 133         msg << "Error: Function " << #n; \
 134         msg << " not found. Neither mock nor real function is present."; \
 135         throw std::logic_error(msg.str()); \
 136     } \
 137     return __cmock_real_##c##_##n(cmock_a1, cmock_a2); \
 138 } \
 139
 140 #define CMOCK_MOCK_FUNCTION3(c, n, F) \
 141 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 142     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, \
 143     F) cmock_a3) = \
 144  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 145      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3))cmock_lookup(#n); \
 146 \
 147 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 148     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3) { \
 149     c *mock = c::cmock_get_instance(); \
 150     if (mock != NULL) { \
 151         return mock->n(cmock_a1, cmock_a2, cmock_a3); \
 152     } \
 153         \
 154     if (__cmock_real_##c##_##n == NULL) { \
 155         std::ostringstream msg; \
 156         msg << "Error: Function " << #n; \
 157         msg << " not found. Neither mock nor real function is present."; \
 158         throw std::logic_error(msg.str()); \
 159     } \
 160     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3); \
 161 } \
 162
 163 #define CMOCK_MOCK_FUNCTION4(c, n, F) \
 164 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 165     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 166     GMOCK_ARG_(, 4, F) cmock_a4) = \
 167  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 168      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 169      F) cmock_a4))cmock_lookup(#n); \
 170 \
 171 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 172     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, \
 173     F) cmock_a4) { \
 174     c *mock = c::cmock_get_instance(); \
 175     if (mock != NULL) { \
 176         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 177     } \
 178         \
 179     if (__cmock_real_##c##_##n == NULL) { \
 180         std::ostringstream msg; \
 181         msg << "Error: Function " << #n; \
 182         msg << " not found. Neither mock nor real function is present."; \
 183         throw std::logic_error(msg.str()); \
 184     } \
 185     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4); \
 186 } \
 187
 188 #define CMOCK_MOCK_FUNCTION5(c, n, F) \
 189 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 190     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 191     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5) = \
 192  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 193      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 194      GMOCK_ARG_(, 5, F) cmock_a5))cmock_lookup(#n); \
 195 \
 196 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 197     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 198     GMOCK_ARG_(, 5, F) cmock_a5) { \
 199     c *mock = c::cmock_get_instance(); \
 200     if (mock != NULL) { \
 201         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5); \
 202     } \
 203         \
 204     if (__cmock_real_##c##_##n == NULL) { \
 205         std::ostringstream msg; \
 206         msg << "Error: Function " << #n; \
 207         msg << " not found. Neither mock nor real function is present."; \
 208         throw std::logic_error(msg.str()); \
 209     } \
 210     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 211         cmock_a5); \
 212 } \
 213
 214 #define CMOCK_MOCK_FUNCTION6(c, n, F) \
 215 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 216     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 217     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 218     F) cmock_a6) = \
 219  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 220      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 221      GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 222      F) cmock_a6))cmock_lookup(#n); \
 223 \
 224 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 225     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 226     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6) { \
 227     c *mock = c::cmock_get_instance(); \
 228     if (mock != NULL) { \
 229         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 230             cmock_a6); \
 231     } \
 232         \
 233     if (__cmock_real_##c##_##n == NULL) { \
 234         std::ostringstream msg; \
 235         msg << "Error: Function " << #n; \
 236         msg << " not found. Neither mock nor real function is present."; \
 237         throw std::logic_error(msg.str()); \
 238     } \
 239     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 240         cmock_a5, cmock_a6); \
 241 } \
 242
 243 #define CMOCK_MOCK_FUNCTION7(c, n, F) \
 244 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 245     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 246     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 247     F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7) = \
 248  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 249      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 250      GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
 251      7, F) cmock_a7))cmock_lookup(#n); \
 252 \
 253 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 254     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 255     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 256     F) cmock_a7) { \
 257     c *mock = c::cmock_get_instance(); \
 258     if (mock != NULL) { \
 259         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 260             cmock_a6, cmock_a7); \
 261     } \
 262         \
 263     if (__cmock_real_##c##_##n == NULL) { \
 264         std::ostringstream msg; \
 265         msg << "Error: Function " << #n; \
 266         msg << " not found. Neither mock nor real function is present."; \
 267         throw std::logic_error(msg.str()); \
 268     } \
 269     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 270         cmock_a5, cmock_a6, cmock_a7); \
 271 } \
 272
 273 #define CMOCK_MOCK_FUNCTION8(c, n, F) \
 274 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 275     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 276     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 277     F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, \
 278     F) cmock_a8) = \
 279  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 280      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 281      GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
 282      7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8))cmock_lookup(#n); \
 283 \
 284 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 285     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 286     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 287     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8) { \
 288     c *mock = c::cmock_get_instance(); \
 289     if (mock != NULL) { \
 290         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 291             cmock_a6, cmock_a7, cmock_a8); \
 292     } \
 293         \
 294     if (__cmock_real_##c##_##n == NULL) { \
 295         std::ostringstream msg; \
 296         msg << "Error: Function " << #n; \
 297         msg << " not found. Neither mock nor real function is present."; \
 298         throw std::logic_error(msg.str()); \
 299     } \
 300     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 301         cmock_a5, cmock_a6, cmock_a7, cmock_a8); \
 302 } \
 303
 304 #define CMOCK_MOCK_FUNCTION9(c, n, F) \
 305 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 306     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 307     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 308     F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, \
 309     GMOCK_ARG_(, 9, F) cmock_a9) = \
 310  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 311      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 312      GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
 313      7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 314      F) cmock_a9))cmock_lookup(#n); \
 315 \
 316 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 317     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 318     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 319     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 320     F) cmock_a9) { \
 321     c *mock = c::cmock_get_instance(); \
 322     if (mock != NULL) { \
 323         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 324             cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 325     } \
 326         \
 327     if (__cmock_real_##c##_##n == NULL) { \
 328         std::ostringstream msg; \
 329         msg << "Error: Function " << #n; \
 330         msg << " not found. Neither mock nor real function is present."; \
 331         throw std::logic_error(msg.str()); \
 332     } \
 333     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 334         cmock_a5, cmock_a6, cmock_a7, cmock_a8, cmock_a9); \
 335 } \
 336
 337 #define CMOCK_MOCK_FUNCTION10(c, n, F) \
 338 static GMOCK_RESULT_(, F) (*__cmock_real_##c##_##n)(GMOCK_ARG_(, 1, \
 339     F) cmock_a1, GMOCK_ARG_(, 2, F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, \
 340     GMOCK_ARG_(, 4, F) cmock_a4, GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, \
 341     F) cmock_a6, GMOCK_ARG_(, 7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, \
 342     GMOCK_ARG_(, 9, F) cmock_a9, GMOCK_ARG_(, 10, F) cmock_a10) = \
 343  (GMOCK_RESULT_(, F) (*)(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 344      F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 345      GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, \
 346      7, F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, \
 347      F) cmock_a9, GMOCK_ARG_(, 10, F) cmock_a10))cmock_lookup(#n); \
 348 \
 349 GMOCK_RESULT_(, F) n(GMOCK_ARG_(, 1, F) cmock_a1, GMOCK_ARG_(, 2, \
 350     F) cmock_a2, GMOCK_ARG_(, 3, F) cmock_a3, GMOCK_ARG_(, 4, F) cmock_a4, \
 351     GMOCK_ARG_(, 5, F) cmock_a5, GMOCK_ARG_(, 6, F) cmock_a6, GMOCK_ARG_(, 7, \
 352     F) cmock_a7, GMOCK_ARG_(, 8, F) cmock_a8, GMOCK_ARG_(, 9, F) cmock_a9, \
 353     GMOCK_ARG_(, 10, F) cmock_a10) { \
 354     c *mock = c::cmock_get_instance(); \
 355     if (mock != NULL) { \
 356         return mock->n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, cmock_a5, \
 357             cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
 358     } \
 359         \
 360     if (__cmock_real_##c##_##n == NULL) { \
 361         std::ostringstream msg; \
 362         msg << "Error: Function " << #n; \
 363         msg << " not found. Neither mock nor real function is present."; \
 364         throw std::logic_error(msg.str()); \
 365     } \
 366     return __cmock_real_##c##_##n(cmock_a1, cmock_a2, cmock_a3, cmock_a4, \
 367         cmock_a5, cmock_a6, cmock_a7, cmock_a8, cmock_a9, cmock_a10); \
 368 } \
 369
 370 #endif // CMOCK_INCLUDE_CMOCK_CMOCK_FUNCTION_CLASS_MOCKERS_H_