Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-11-13 10:39:08 

0001 // Copyright 2007, Google Inc.
0002 // All rights reserved.
0003 //
0004 // Redistribution and use in source and binary forms, with or without
0005 // modification, are permitted provided that the following conditions are
0006 // met:
0007 //
0008 //     * Redistributions of source code must retain the above copyright
0009 // notice, this list of conditions and the following disclaimer.
0010 //     * Redistributions in binary form must reproduce the above
0011 // copyright notice, this list of conditions and the following disclaimer
0012 // in the documentation and/or other materials provided with the
0013 // distribution.
0014 //     * Neither the name of Google Inc. nor the names of its
0015 // contributors may be used to endorse or promote products derived from
0016 // this software without specific prior written permission.
0017 //
0018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
0019 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
0020 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
0021 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
0022 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
0023 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
0024 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
0025 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
0026 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0027 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
0028 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0029 
0030 // Google Mock - a framework for writing C++ mock classes.
0031 //
0032 // This file implements MOCK_METHOD.
0033 
0034 // IWYU pragma: private, include "gmock/gmock.h"
0035 // IWYU pragma: friend gmock/.*
0036 
0037 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
0038 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
0039 
0040 #include <cstddef>
0041 #include <type_traits>  // IWYU pragma: keep
0042 #include <utility>      // IWYU pragma: keep
0043 
0044 #include "gmock/gmock-spec-builders.h"
0045 #include "gmock/internal/gmock-internal-utils.h"
0046 #include "gmock/internal/gmock-pp.h"
0047 
0048 namespace testing {
0049 namespace internal {
0050 template <typename T>
0051 using identity_t = T;
0052 
0053 template <typename Pattern>
0054 struct ThisRefAdjuster {
0055   template <typename T>
0056   using AdjustT = typename std::conditional<
0057       std::is_const<typename std::remove_reference<Pattern>::type>::value,
0058       typename std::conditional<std::is_lvalue_reference<Pattern>::value,
0059                                 const T&, const T&&>::type,
0060       typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
0061                                 T&&>::type>::type;
0062 
0063   template <typename MockType>
0064   static AdjustT<MockType> Adjust(const MockType& mock) {
0065     return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
0066   }
0067 };
0068 
0069 constexpr bool PrefixOf(const char* a, const char* b) {
0070   return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
0071 }
0072 
0073 template <size_t N, size_t M>
0074 constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
0075   return N <= M && internal::PrefixOf(prefix, str);
0076 }
0077 
0078 template <size_t N, size_t M>
0079 constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
0080   return N <= M && internal::PrefixOf(suffix, str + M - N);
0081 }
0082 
0083 template <size_t N, size_t M>
0084 constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
0085   return N == M && internal::PrefixOf(a, b);
0086 }
0087 
0088 template <size_t N>
0089 constexpr bool ValidateSpec(const char (&spec)[N]) {
0090   return internal::Equals("const", spec) ||
0091          internal::Equals("override", spec) ||
0092          internal::Equals("final", spec) ||
0093          internal::Equals("noexcept", spec) ||
0094          (internal::StartsWith("noexcept(", spec) &&
0095           internal::EndsWith(")", spec)) ||
0096          internal::Equals("ref(&)", spec) ||
0097          internal::Equals("ref(&&)", spec) ||
0098          (internal::StartsWith("Calltype(", spec) &&
0099           internal::EndsWith(")", spec));
0100 }
0101 
0102 }  // namespace internal
0103 
0104 // The style guide prohibits "using" statements in a namespace scope
0105 // inside a header file.  However, the FunctionMocker class template
0106 // is meant to be defined in the ::testing namespace.  The following
0107 // line is just a trick for working around a bug in MSVC 8.0, which
0108 // cannot handle it if we define FunctionMocker in ::testing.
0109 using internal::FunctionMocker;
0110 }  // namespace testing
0111 
0112 #define MOCK_METHOD(...)                                               \
0113   GMOCK_INTERNAL_WARNING_PUSH()                                        \
0114   GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function")    \
0115   GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) \
0116   GMOCK_INTERNAL_WARNING_POP()
0117 
0118 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
0119   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
0120 
0121 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
0122   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
0123 
0124 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
0125   GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
0126 
0127 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)  \
0128   GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                \
0129   GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                \
0130   GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                   \
0131       GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));        \
0132   GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                  \
0133   GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                         \
0134       GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),  \
0135       GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \
0136       GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                             \
0137       GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec),                             \
0138       GMOCK_INTERNAL_GET_REF_SPEC(_Spec),                                  \
0139       (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
0140 
0141 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
0142   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
0143 
0144 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
0145   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
0146 
0147 #define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
0148   GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
0149 
0150 #define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
0151   static_assert(                                                             \
0152       false,                                                                 \
0153       "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
0154       "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
0155       "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
0156       "it must also be enclosed in parentheses.")
0157 
0158 #define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
0159   static_assert(                                  \
0160       GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
0161       GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
0162 
0163 #define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
0164   static_assert(                                                       \
0165       std::is_function<__VA_ARGS__>::value,                            \
0166       "Signature must be a function type, maybe return type contains " \
0167       "unprotected comma.");                                           \
0168   static_assert(                                                       \
0169       ::testing::tuple_size<typename ::testing::internal::Function<    \
0170               __VA_ARGS__>::ArgumentTuple>::value == _N,               \
0171       "This method does not take " GMOCK_PP_STRINGIZE(                 \
0172           _N) " arguments. Parenthesize all types with unprotected commas.")
0173 
0174 #define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
0175   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
0176 
0177 #define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
0178                                         _Override, _Final, _NoexceptSpec,      \
0179                                         _CallType, _RefSpec, _Signature)       \
0180   typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
0181       _Signature)>::Result                                                     \
0182   GMOCK_INTERNAL_EXPAND(_CallType)                                             \
0183       _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
0184           GMOCK_PP_IF(_Constness, const, )                                     \
0185               _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, )        \
0186                   GMOCK_PP_IF(_Final, final, ) {                               \
0187     GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
0188         .SetOwnerAndName(this, #_MethodName);                                  \
0189     return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
0190         .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
0191   }                                                                            \
0192   ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
0193       GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
0194       GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
0195     GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
0196     return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
0197         .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
0198   }                                                                            \
0199   ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
0200       const ::testing::internal::WithoutMatchers&,                             \
0201       GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
0202           GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
0203     return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
0204         _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
0205         .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
0206             GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
0207   }                                                                            \
0208   mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
0209   GMOCK_MOCKER_(_N, _Constness, _MethodName)
0210 
0211 #define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
0212 
0213 // Valid modifiers.
0214 #define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
0215   GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
0216 
0217 #define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
0218   GMOCK_PP_HAS_COMMA(                       \
0219       GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
0220 
0221 #define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
0222   GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))
0223 
0224 #define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
0225   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)
0226 
0227 #define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
0228   GMOCK_PP_IF(                                                          \
0229       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
0230       _elem, )
0231 
0232 #define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple) \
0233   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE, ~, _Tuple)
0234 
0235 #define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem)          \
0236   GMOCK_PP_IF(                                                          \
0237       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)), \
0238       GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
0239 
0240 #define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
0241   GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
0242 
0243 #define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
0244   GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
0245               GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
0246 
0247 #ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT
0248 #define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \
0249   static_assert(                                                     \
0250       ::testing::internal::ValidateSpec(GMOCK_PP_STRINGIZE(_elem)),  \
0251       "Token \'" GMOCK_PP_STRINGIZE(                                 \
0252           _elem) "\' cannot be recognized as a valid specification " \
0253                  "modifier. Is a ',' missing?");
0254 #else
0255 #define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)                 \
0256   static_assert(                                                               \
0257       (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +         \
0258        GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) +      \
0259        GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +         \
0260        GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) +      \
0261        GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +           \
0262        GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem))) == 1, \
0263       GMOCK_PP_STRINGIZE(                                                      \
0264           _elem) " cannot be recognized as a valid specification modifier.");
0265 #endif  // GMOCK_INTERNAL_STRICT_SPEC_ASSERT
0266 
0267 // Modifiers implementation.
0268 #define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
0269   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
0270 
0271 #define GMOCK_INTERNAL_DETECT_CONST_I_const ,
0272 
0273 #define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
0274   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
0275 
0276 #define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
0277 
0278 #define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
0279   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
0280 
0281 #define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
0282 
0283 #define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
0284   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
0285 
0286 #define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
0287 
0288 #define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
0289   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)
0290 
0291 #define GMOCK_INTERNAL_DETECT_REF_I_ref ,
0292 
0293 #define GMOCK_INTERNAL_UNPACK_ref(x) x
0294 
0295 #define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem) \
0296   GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CALLTYPE_I_, _elem)
0297 
0298 #define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype ,
0299 
0300 #define GMOCK_INTERNAL_UNPACK_Calltype(...) __VA_ARGS__
0301 
0302 // Note: The use of `identity_t` here allows _Ret to represent return types that
0303 // would normally need to be specified in a different way. For example, a method
0304 // returning a function pointer must be written as
0305 //
0306 // fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
0307 //
0308 // But we only support placing the return type at the beginning. To handle this,
0309 // we wrap all calls in identity_t, so that a declaration will be expanded to
0310 //
0311 // identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
0312 //
0313 // This allows us to work around the syntactic oddities of function/method
0314 // types.
0315 #define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
0316   ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
0317                                               GMOCK_PP_REMOVE_PARENS,         \
0318                                               GMOCK_PP_IDENTITY)(_Ret)>(      \
0319       GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
0320 
0321 #define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
0322   GMOCK_PP_COMMA_IF(_i)                                                \
0323   GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
0324               GMOCK_PP_IDENTITY)                                       \
0325   (_elem)
0326 
0327 #define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
0328   GMOCK_PP_COMMA_IF(_i)                                        \
0329   GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
0330   gmock_a##_i
0331 
0332 #define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
0333   GMOCK_PP_COMMA_IF(_i)                               \
0334   ::std::forward<GMOCK_INTERNAL_ARG_O(                \
0335       _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)
0336 
0337 #define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
0338   GMOCK_PP_COMMA_IF(_i)                                            \
0339   GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
0340   gmock_a##_i
0341 
0342 #define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
0343   GMOCK_PP_COMMA_IF(_i)                             \
0344   gmock_a##_i
0345 
0346 #define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
0347   GMOCK_PP_COMMA_IF(_i)                                      \
0348   ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()
0349 
0350 #define GMOCK_INTERNAL_ARG_O(_i, ...) \
0351   typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type
0352 
0353 #define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
0354   const ::testing::Matcher<typename ::testing::internal::Function< \
0355       __VA_ARGS__>::template Arg<_i>::type>&
0356 
0357 #define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
0358 #define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
0359 #define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
0360 #define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
0361 #define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
0362 #define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
0363 #define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
0364 #define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
0365 #define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
0366 #define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
0367 #define MOCK_METHOD10(m, ...) \
0368   GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
0369 
0370 #define MOCK_CONST_METHOD0(m, ...) \
0371   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
0372 #define MOCK_CONST_METHOD1(m, ...) \
0373   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
0374 #define MOCK_CONST_METHOD2(m, ...) \
0375   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
0376 #define MOCK_CONST_METHOD3(m, ...) \
0377   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
0378 #define MOCK_CONST_METHOD4(m, ...) \
0379   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
0380 #define MOCK_CONST_METHOD5(m, ...) \
0381   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
0382 #define MOCK_CONST_METHOD6(m, ...) \
0383   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
0384 #define MOCK_CONST_METHOD7(m, ...) \
0385   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
0386 #define MOCK_CONST_METHOD8(m, ...) \
0387   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
0388 #define MOCK_CONST_METHOD9(m, ...) \
0389   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
0390 #define MOCK_CONST_METHOD10(m, ...) \
0391   GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)
0392 
0393 #define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
0394 #define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
0395 #define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
0396 #define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
0397 #define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
0398 #define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
0399 #define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
0400 #define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
0401 #define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
0402 #define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
0403 #define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)
0404 
0405 #define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
0406 #define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
0407 #define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
0408 #define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
0409 #define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
0410 #define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
0411 #define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
0412 #define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
0413 #define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
0414 #define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
0415 #define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)
0416 
0417 #define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
0418   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
0419 #define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
0420   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
0421 #define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
0422   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
0423 #define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
0424   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
0425 #define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
0426   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
0427 #define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
0428   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
0429 #define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
0430   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
0431 #define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
0432   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
0433 #define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
0434   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
0435 #define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
0436   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
0437 #define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
0438   GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)
0439 
0440 #define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
0441   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
0442 #define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
0443   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
0444 #define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
0445   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
0446 #define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
0447   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
0448 #define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
0449   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
0450 #define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
0451   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
0452 #define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
0453   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
0454 #define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
0455   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
0456 #define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
0457   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
0458 #define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
0459   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
0460 #define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
0461   GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)
0462 
0463 #define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
0464   MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0465 #define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
0466   MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0467 #define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
0468   MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0469 #define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
0470   MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0471 #define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
0472   MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0473 #define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
0474   MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0475 #define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
0476   MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0477 #define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
0478   MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0479 #define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
0480   MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0481 #define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
0482   MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0483 #define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
0484   MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0485 
0486 #define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
0487   MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0488 #define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
0489   MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0490 #define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
0491   MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0492 #define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
0493   MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0494 #define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
0495   MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0496 #define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
0497   MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0498 #define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
0499   MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0500 #define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
0501   MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0502 #define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
0503   MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0504 #define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
0505   MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0506 #define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
0507   MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
0508 
0509 #define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
0510   GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
0511       args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
0512   GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
0513       args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
0514       (::testing::internal::identity_t<__VA_ARGS__>))
0515 
0516 #define GMOCK_MOCKER_(arity, constness, Method) \
0517   GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
0518 
0519 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!