1// Copyright 2007, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30// Google Mock - a framework for writing C++ mock classes. 31// 32// This file implements MOCK_METHOD. 33 34// IWYU pragma: private, include "gmock/gmock.h" 35// IWYU pragma: friend gmock/.* 36 37#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ 38#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ 39 40#include <type_traits> // IWYU pragma: keep 41#include <utility> // IWYU pragma: keep 42 43#include "gmock/gmock-spec-builders.h" 44#include "gmock/internal/gmock-internal-utils.h" 45#include "gmock/internal/gmock-pp.h" 46 47namespace testing { 48namespace internal { 49template <typename T> 50using identity_t = T; 51 52template <typename Pattern> 53struct ThisRefAdjuster { 54 template <typename T> 55 using AdjustT = typename std::conditional< 56 std::is_const<typename std::remove_reference<Pattern>::type>::value, 57 typename std::conditional<std::is_lvalue_reference<Pattern>::value, 58 const T&, const T&&>::type, 59 typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&, 60 T&&>::type>::type; 61 62 template <typename MockType> 63 static AdjustT<MockType> Adjust(const MockType& mock) { 64 return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock)); 65 } 66}; 67 68constexpr bool PrefixOf(const char* a, const char* b) { 69 return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1)); 70} 71 72template <int N, int M> 73constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) { 74 return N <= M && internal::PrefixOf(prefix, str); 75} 76 77template <int N, int M> 78constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) { 79 return N <= M && internal::PrefixOf(suffix, str + M - N); 80} 81 82template <int N, int M> 83constexpr bool Equals(const char (&a)[N], const char (&b)[M]) { 84 return N == M && internal::PrefixOf(a, b); 85} 86 87template <int N> 88constexpr bool ValidateSpec(const char (&spec)[N]) { 89 return internal::Equals("const", spec) || 90 internal::Equals("override", spec) || 91 internal::Equals("final", spec) || 92 internal::Equals("noexcept", spec) || 93 (internal::StartsWith("noexcept(", spec) && 94 internal::EndsWith(")", spec)) || 95 internal::Equals("ref(&)", spec) || 96 internal::Equals("ref(&&)", spec) || 97 (internal::StartsWith("Calltype(", spec) && 98 internal::EndsWith(")", spec)); 99} 100 101} // namespace internal 102 103// The style guide prohibits "using" statements in a namespace scope 104// inside a header file. However, the FunctionMocker class template 105// is meant to be defined in the ::testing namespace. The following 106// line is just a trick for working around a bug in MSVC 8.0, which 107// cannot handle it if we define FunctionMocker in ::testing. 108using internal::FunctionMocker; 109} // namespace testing 110 111#define MOCK_METHOD(...) \ 112 GMOCK_INTERNAL_WARNING_PUSH() \ 113 GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \ 114 GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) \ 115 GMOCK_INTERNAL_WARNING_POP() 116 117#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ 118 GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 119 120#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ 121 GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 122 123#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ 124 GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) 125 126#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec) \ 127 GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ 128 GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ 129 GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ 130 GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ 131 GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ 132 GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ 133 GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ 134 GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ 135 GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ 136 GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec), \ 137 GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ 138 (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) 139 140#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ 141 GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 142 143#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ 144 GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 145 146#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ 147 GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 148 149#define GMOCK_INTERNAL_WRONG_ARITY(...) \ 150 static_assert( \ 151 false, \ 152 "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ 153 "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ 154 "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ 155 "it must also be enclosed in parentheses.") 156 157#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ 158 static_assert( \ 159 GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ 160 GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") 161 162#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ 163 static_assert( \ 164 std::is_function<__VA_ARGS__>::value, \ 165 "Signature must be a function type, maybe return type contains " \ 166 "unprotected comma."); \ 167 static_assert( \ 168 ::testing::tuple_size<typename ::testing::internal::Function< \ 169 __VA_ARGS__>::ArgumentTuple>::value == _N, \ 170 "This method does not take " GMOCK_PP_STRINGIZE( \ 171 _N) " arguments. Parenthesize all types with unprotected commas.") 172 173#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ 174 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) 175 176#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ 177 _Override, _Final, _NoexceptSpec, \ 178 _CallType, _RefSpec, _Signature) \ 179 typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS( \ 180 _Signature)>::Result \ 181 GMOCK_INTERNAL_EXPAND(_CallType) \ 182 _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ 183 GMOCK_PP_IF(_Constness, const, ) \ 184 _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, ) \ 185 GMOCK_PP_IF(_Final, final, ) { \ 186 GMOCK_MOCKER_(_N, _Constness, _MethodName) \ 187 .SetOwnerAndName(this, #_MethodName); \ 188 return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ 189 .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ 190 } \ 191 ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ 192 GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ 193 GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ 194 GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ 195 return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ 196 .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ 197 } \ 198 ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ 199 const ::testing::internal::WithoutMatchers&, \ 200 GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ 201 GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ 202 return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF( \ 203 _Constness, const, ) int _RefSpec>::Adjust(*this) \ 204 .gmock_##_MethodName(GMOCK_PP_REPEAT( \ 205 GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ 206 } \ 207 mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> \ 208 GMOCK_MOCKER_(_N, _Constness, _MethodName) 209 210#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ 211 212// Valid modifiers. 213#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ 214 GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) 215 216#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ 217 GMOCK_PP_HAS_COMMA( \ 218 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) 219 220#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ 221 GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) 222 223#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ 224 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) 225 226#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ 227 GMOCK_PP_IF( \ 228 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ 229 _elem, ) 230 231#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \ 232 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple) 233 234#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem) \ 235 GMOCK_PP_IF( \ 236 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \ 237 GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) 238 239#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ 240 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) 241 242#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ 243 GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ 244 GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) 245 246#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT 247#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ 248 static_assert( \ 249 ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)), \ 250 "Token \'" GMOCK_PP_STRINGIZE( \ 251 _elem) "\' cannot be recognized as a valid specification " \ 252 "modifier. Is a ',' missing?"); 253#else 254#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ 255 static_assert( \ 256 (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) + \ 257 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ 258 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ 259 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ 260 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ 261 GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \ 262 GMOCK_PP_STRINGIZE( \ 263 _elem) " cannot be recognized as a valid specification modifier."); 264#endif // GMOCK_INTERNAL_STRICT_SPEC_ASSERT 265 266// Modifiers implementation. 267#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ 268 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) 269 270#define GMOCK_INTERNAL_DETECT_CONST_I_const , 271 272#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ 273 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) 274 275#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , 276 277#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ 278 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) 279 280#define GMOCK_INTERNAL_DETECT_FINAL_I_final , 281 282#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ 283 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) 284 285#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , 286 287#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ 288 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) 289 290#define GMOCK_INTERNAL_DETECT_REF_I_ref , 291 292#define GMOCK_INTERNAL_UNPACK_ref(x) x 293 294#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \ 295 GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem) 296 297#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype , 298 299#define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__ 300 301// Note: The use of `identity_t` here allows _Ret to represent return types that 302// would normally need to be specified in a different way. For example, a method 303// returning a function pointer must be written as 304// 305// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) 306// 307// But we only support placing the return type at the beginning. To handle this, 308// we wrap all calls in identity_t, so that a declaration will be expanded to 309// 310// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...) 311// 312// This allows us to work around the syntactic oddities of function/method 313// types. 314#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ 315 ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \ 316 GMOCK_PP_REMOVE_PARENS, \ 317 GMOCK_PP_IDENTITY)(_Ret)>( \ 318 GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) 319 320#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ 321 GMOCK_PP_COMMA_IF(_i) \ 322 GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ 323 GMOCK_PP_IDENTITY) \ 324 (_elem) 325 326#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ 327 GMOCK_PP_COMMA_IF(_i) \ 328 GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ 329 gmock_a##_i 330 331#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ 332 GMOCK_PP_COMMA_IF(_i) \ 333 ::std::forward<GMOCK_INTERNAL_ARG_O( \ 334 _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i) 335 336#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ 337 GMOCK_PP_COMMA_IF(_i) \ 338 GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ 339 gmock_a##_i 340 341#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ 342 GMOCK_PP_COMMA_IF(_i) \ 343 gmock_a##_i 344 345#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ 346 GMOCK_PP_COMMA_IF(_i) \ 347 ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>() 348 349#define GMOCK_INTERNAL_ARG_O(_i, ...) \ 350 typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type 351 352#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ 353 const ::testing::Matcher<typename ::testing::internal::Function< \ 354 __VA_ARGS__>::template Arg<_i>::type>& 355 356#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) 357#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) 358#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) 359#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) 360#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) 361#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) 362#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) 363#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) 364#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) 365#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) 366#define MOCK_METHOD10(m, ...) \ 367 GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) 368 369#define MOCK_CONST_METHOD0(m, ...) \ 370 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) 371#define MOCK_CONST_METHOD1(m, ...) \ 372 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) 373#define MOCK_CONST_METHOD2(m, ...) \ 374 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) 375#define MOCK_CONST_METHOD3(m, ...) \ 376 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) 377#define MOCK_CONST_METHOD4(m, ...) \ 378 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) 379#define MOCK_CONST_METHOD5(m, ...) \ 380 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) 381#define MOCK_CONST_METHOD6(m, ...) \ 382 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) 383#define MOCK_CONST_METHOD7(m, ...) \ 384 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) 385#define MOCK_CONST_METHOD8(m, ...) \ 386 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) 387#define MOCK_CONST_METHOD9(m, ...) \ 388 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) 389#define MOCK_CONST_METHOD10(m, ...) \ 390 GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) 391 392#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) 393#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) 394#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) 395#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) 396#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) 397#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) 398#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) 399#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) 400#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) 401#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) 402#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) 403 404#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) 405#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) 406#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) 407#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) 408#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) 409#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) 410#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) 411#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) 412#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) 413#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) 414#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) 415 416#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 417 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) 418#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 419 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) 420#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 421 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) 422#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 423 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) 424#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 425 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) 426#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 427 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) 428#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 429 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) 430#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 431 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) 432#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 433 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) 434#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 435 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) 436#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 437 GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) 438 439#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 440 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) 441#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 442 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) 443#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 444 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) 445#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 446 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) 447#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 448 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) 449#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 450 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) 451#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 452 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) 453#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 454 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) 455#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 456 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) 457#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 458 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) 459#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 460 GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) 461 462#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 463 MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) 464#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 465 MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) 466#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 467 MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) 468#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 469 MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) 470#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 471 MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) 472#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 473 MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) 474#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 475 MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) 476#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 477 MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) 478#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 479 MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) 480#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 481 MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) 482#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 483 MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) 484 485#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 486 MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) 487#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 488 MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) 489#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 490 MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) 491#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 492 MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) 493#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 494 MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) 495#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 496 MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) 497#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 498 MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) 499#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 500 MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) 501#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 502 MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) 503#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 504 MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) 505#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 506 MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) 507 508#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ 509 GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ 510 args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ 511 GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ 512 args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ 513 (::testing::internal::identity_t<__VA_ARGS__>)) 514 515#define GMOCK_MOCKER_(arity, constness, Method) \ 516 GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) 517 518#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_ 519