diff --git a/docs/gmock_cook_book.md b/docs/gmock_cook_book.md index cee1da8e2..b7530b247 100644 --- a/docs/gmock_cook_book.md +++ b/docs/gmock_cook_book.md @@ -2895,8 +2895,13 @@ file. This way, even if you `#include` your mock class in N files, the compiler only needs to generate its constructor and destructor once, resulting in a much faster compilation. +If your compilation times are still slow, you can also move the definitions of +your mock methods into a `.cc` file by replacing uses of the `MOCK_METHOD` +macro in the class body with `DECLARE_MOCK_METHOD`, and adding corresponding +calls to `DEFINE_MOCK_METHOD` in your `.cc` file. + Let's illustrate the idea using an example. Here's the definition of a mock -class before applying this recipe: +class before applying these recipes: ```cpp // File mock_foo.h. @@ -2924,8 +2929,9 @@ class MockFoo : public Foo { MockFoo(); virtual ~MockFoo(); - MOCK_METHOD(int, DoThis, (), (override)); - MOCK_METHOD(bool, DoThat, (const char* str), (override)); + // These macros declare the mock methods but do not define them. + DECLARE_MOCK_METHOD(int, DoThis, (), (override)); + DECLARE_MOCK_METHOD(bool, DoThat, (const char* str), (override)); ... more mock methods ... }; ``` @@ -2941,6 +2947,13 @@ and // variables used to implement the mock methods. MockFoo::MockFoo() {} MockFoo::~MockFoo() {} + +// These macros expand to the actual definitions of the mock methods. +// For each DECLARE_MOCK_METHOD call in your class body, you need a +// corresponding DEFINE_MOCK_METHOD call in your .cc file. +DEFINE_MOCK_METHOD(MockFoo, int, DoThis, (), (override)); +DEFINE_MOCK_METHOD(MockFoo, bool, DoThat, (const char* str), (override)); +... more mock methods ... ``` ### Forcing a Verification diff --git a/googlemock/CMakeLists.txt b/googlemock/CMakeLists.txt index 99b2411f3..1d5bc0941 100644 --- a/googlemock/CMakeLists.txt +++ b/googlemock/CMakeLists.txt @@ -141,7 +141,7 @@ if (gmock_build_tests) cxx_test(gmock-actions_test gmock_main) cxx_test(gmock-cardinalities_test gmock_main) cxx_test(gmock_ex_test gmock_main) - cxx_test(gmock-function-mocker_test gmock_main) + cxx_test(gmock-function-mocker_test gmock_main test/split-mock_test_helper.cc) cxx_test(gmock-internal-utils_test gmock_main) cxx_test(gmock-matchers-arithmetic_test gmock_main) cxx_test(gmock-matchers-comparisons_test gmock_main) diff --git a/googlemock/include/gmock/gmock-function-mocker.h b/googlemock/include/gmock/gmock-function-mocker.h index d2cb13cd8..9c5d2c9fd 100644 --- a/googlemock/include/gmock/gmock-function-mocker.h +++ b/googlemock/include/gmock/gmock-function-mocker.h @@ -50,6 +50,9 @@ namespace internal { template using identity_t = T; +template +struct TypeTag {}; + template struct ThisRefAdjuster { template @@ -116,10 +119,10 @@ using internal::FunctionMocker; GMOCK_INTERNAL_WARNING_POP() #define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) @@ -139,15 +142,15 @@ using internal::FunctionMocker; (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ - GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) -#define GMOCK_INTERNAL_WRONG_ARITY(...) \ +#define GMOCK_INTERNAL_MOCK_METHOD_WRONG_ARITY(...) \ static_assert( \ false, \ "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ @@ -155,6 +158,104 @@ using internal::FunctionMocker; "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ "it must also be enclosed in parentheses.") +#define DECLARE_MOCK_METHOD(...) \ + GMOCK_INTERNAL_WARNING_PUSH() \ + GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \ + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_, __VA_ARGS__) \ + GMOCK_INTERNAL_WARNING_POP() + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_1(...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_2(...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, \ + _Spec) \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ + GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_IMPL( \ + GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ + GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ + GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_5(...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_6(...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_ARG_7(...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_WRONG_ARITY(...) \ + static_assert( \ + false, \ + "DECLARE_MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ + "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ + "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ + "it must also be enclosed in parentheses.") + +#define DEFINE_MOCK_METHOD(...) \ + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_, __VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_1(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_2(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_3(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_4(_MockClass, _Ret, _MethodName, \ + _Args) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_5(_MockClass, _Ret, _MethodName, \ + _Args, ()) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_5(_MockClass, _Ret, _MethodName, \ + _Args, _Spec) \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ + GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_IMPL( \ + GMOCK_PP_NARG0 _Args, _MockClass, _MethodName, \ + GMOCK_INTERNAL_HAS_CONST(_Spec), GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), \ + GMOCK_INTERNAL_HAS_FINAL(_Spec), \ + GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_6(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_7(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_ARG_8(...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_WRONG_ARITY(...) \ + static_assert( \ + false, \ + "DEFINE_MOCK_METHOD must be called with 4 or 5 arguments. _MockClass, " \ + "_Ret, " \ + "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ + "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ + "it must also be enclosed in parentheses.") + #define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ static_assert( \ GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ @@ -208,6 +309,72 @@ using internal::FunctionMocker; mutable ::testing::FunctionMocker \ GMOCK_MOCKER_(_N, _Constness, _MethodName) +#define GMOCK_INTERNAL_DECLARE_MOCK_METHOD_IMPL( \ + _N, _MethodName, _Constness, _Override, _Final, _NoexceptSpec, _CallType, \ + _RefSpec, _Signature) \ + typename ::testing::internal::Function::Result GMOCK_INTERNAL_EXPAND(_CallType) \ + _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) \ + _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, ) \ + GMOCK_PP_IF(_Final, final, ); \ + ::testing::MockSpec gmock_##_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec; \ + ::testing::MockSpec gmock_##_MethodName( \ + const ::testing::internal::WithoutMatchers&, \ + GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ + GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec; \ + ::testing::FunctionMocker& \ + gmock_get_mocker_##_MethodName( \ + ::testing::internal::TypeTag) const { \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName); \ + } \ + mutable ::testing::FunctionMocker \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHOD_IMPL( \ + _N, _MockClass, _MethodName, _Constness, _Override, _Final, _NoexceptSpec, \ + _CallType, _RefSpec, _Signature) \ + typename ::testing::internal::Function::Result \ + GMOCK_INTERNAL_EXPAND(_CallType) _MockClass::_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) \ + _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, ) \ + GMOCK_PP_IF(_Final, final, ) { \ + auto& mocker = gmock_get_mocker_##_MethodName( \ + ::testing::internal::TypeTag{}); \ + mocker.SetOwnerAndName(this, #_MethodName); \ + return mocker.Invoke( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ + } \ + ::testing::MockSpec \ + _MockClass::gmock_##_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ + auto& mocker = gmock_get_mocker_##_MethodName( \ + ::testing::internal::TypeTag{}); \ + mocker.RegisterOwner(this); \ + return mocker.With( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ + } \ + ::testing::MockSpec \ + _MockClass::gmock_##_MethodName( \ + const ::testing::internal::WithoutMatchers&, \ + GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ + GMOCK_PP_REMOVE_PARENS(_Signature)>*) \ + const _RefSpec _NoexceptSpec { \ + return ::testing::internal::ThisRefAdjuster::Adjust(*this) \ + .gmock_##_MethodName(GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ + } \ + static_assert(true, "no-op to require trailing semicolon") + #define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ // Valid modifiers. @@ -513,6 +680,379 @@ using internal::FunctionMocker; args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ (::testing::internal::identity_t<__VA_ARGS__>)) +#define DECLARE_MOCK_METHOD0(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 0, __VA_ARGS__) +#define DECLARE_MOCK_METHOD1(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 1, __VA_ARGS__) +#define DECLARE_MOCK_METHOD2(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 2, __VA_ARGS__) +#define DECLARE_MOCK_METHOD3(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 3, __VA_ARGS__) +#define DECLARE_MOCK_METHOD4(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 4, __VA_ARGS__) +#define DECLARE_MOCK_METHOD5(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 5, __VA_ARGS__) +#define DECLARE_MOCK_METHOD6(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 6, __VA_ARGS__) +#define DECLARE_MOCK_METHOD7(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 7, __VA_ARGS__) +#define DECLARE_MOCK_METHOD8(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 8, __VA_ARGS__) +#define DECLARE_MOCK_METHOD9(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 9, __VA_ARGS__) +#define DECLARE_MOCK_METHOD10(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, , m, 10, __VA_ARGS__) + +#define DECLARE_MOCK_CONST_METHOD0(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 0, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD1(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 1, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD2(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 2, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD3(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 3, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD4(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 4, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD5(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 5, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD6(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 6, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD7(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 7, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD8(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 8, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD9(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 9, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD10(m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, , m, 10, __VA_ARGS__) + +#define DECLARE_MOCK_METHOD0_T(m, ...) DECLARE_MOCK_METHOD0(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD1_T(m, ...) DECLARE_MOCK_METHOD1(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD2_T(m, ...) DECLARE_MOCK_METHOD2(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD3_T(m, ...) DECLARE_MOCK_METHOD3(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD4_T(m, ...) DECLARE_MOCK_METHOD4(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD5_T(m, ...) DECLARE_MOCK_METHOD5(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD6_T(m, ...) DECLARE_MOCK_METHOD6(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD7_T(m, ...) DECLARE_MOCK_METHOD7(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD8_T(m, ...) DECLARE_MOCK_METHOD8(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD9_T(m, ...) DECLARE_MOCK_METHOD9(m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD10_T(m, ...) DECLARE_MOCK_METHOD10(m, __VA_ARGS__) + +#define DECLARE_MOCK_CONST_METHOD0_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD0(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD1_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD1(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD2_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD2(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD3_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD3(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD4_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD4(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD5_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD5(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD6_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD6(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD7_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD7(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD8_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD8(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD9_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD9(m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD10_T(m, ...) \ + DECLARE_MOCK_CONST_METHOD10(m, __VA_ARGS__) + +#define DECLARE_MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) +#define DECLARE_MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) +#define DECLARE_MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) +#define DECLARE_MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) +#define DECLARE_MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) +#define DECLARE_MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) +#define DECLARE_MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) +#define DECLARE_MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) +#define DECLARE_MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) +#define DECLARE_MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) +#define DECLARE_MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) + +#define DECLARE_MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_DECLARE_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) + +#define DECLARE_MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define DECLARE_MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define DECLARE_MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + DECLARE_MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define GMOCK_INTERNAL_DECLARE_MOCK_METHODN(constness, ct, Method, args_num, \ + ...) \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ + GMOCK_INTERNAL_DECLARE_MOCK_METHOD_IMPL( \ + args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ + (::testing::internal::identity_t<__VA_ARGS__>)) + +#define DEFINE_MOCK_METHOD0(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 0, __VA_ARGS__) +#define DEFINE_MOCK_METHOD1(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 1, __VA_ARGS__) +#define DEFINE_MOCK_METHOD2(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 2, __VA_ARGS__) +#define DEFINE_MOCK_METHOD3(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 3, __VA_ARGS__) +#define DEFINE_MOCK_METHOD4(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 4, __VA_ARGS__) +#define DEFINE_MOCK_METHOD5(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 5, __VA_ARGS__) +#define DEFINE_MOCK_METHOD6(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 6, __VA_ARGS__) +#define DEFINE_MOCK_METHOD7(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 7, __VA_ARGS__) +#define DEFINE_MOCK_METHOD8(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 8, __VA_ARGS__) +#define DEFINE_MOCK_METHOD9(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 9, __VA_ARGS__) +#define DEFINE_MOCK_METHOD10(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, , cls, m, 10, __VA_ARGS__) + +#define DEFINE_MOCK_CONST_METHOD0(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 0, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD1(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 1, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD2(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 2, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD3(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 3, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD4(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 4, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD5(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 5, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD6(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 6, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD7(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 7, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD8(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 8, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD9(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 9, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD10(cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, , cls, m, 10, __VA_ARGS__) + +#define DEFINE_MOCK_METHOD0_T(cls, m, ...) \ + DEFINE_MOCK_METHOD0(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD1_T(cls, m, ...) \ + DEFINE_MOCK_METHOD1(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD2_T(cls, m, ...) \ + DEFINE_MOCK_METHOD2(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD3_T(cls, m, ...) \ + DEFINE_MOCK_METHOD3(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD4_T(cls, m, ...) \ + DEFINE_MOCK_METHOD4(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD5_T(cls, m, ...) \ + DEFINE_MOCK_METHOD5(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD6_T(cls, m, ...) \ + DEFINE_MOCK_METHOD6(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD7_T(cls, m, ...) \ + DEFINE_MOCK_METHOD7(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD8_T(cls, m, ...) \ + DEFINE_MOCK_METHOD8(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD9_T(cls, m, ...) \ + DEFINE_MOCK_METHOD9(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD10_T(cls, m, ...) \ + DEFINE_MOCK_METHOD10(cls, m, __VA_ARGS__) + +#define DEFINE_MOCK_CONST_METHOD0_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD0(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD1_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD1(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD2_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD2(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD3_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD3(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD4_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD4(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD5_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD5(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD6_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD6(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD7_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD7(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD8_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD8(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD9_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD9(cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD10_T(cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD10(cls, m, __VA_ARGS__) + +#define DEFINE_MOCK_METHOD0_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 0, __VA_ARGS__) +#define DEFINE_MOCK_METHOD1_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 1, __VA_ARGS__) +#define DEFINE_MOCK_METHOD2_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 2, __VA_ARGS__) +#define DEFINE_MOCK_METHOD3_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 3, __VA_ARGS__) +#define DEFINE_MOCK_METHOD4_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 4, __VA_ARGS__) +#define DEFINE_MOCK_METHOD5_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 5, __VA_ARGS__) +#define DEFINE_MOCK_METHOD6_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 6, __VA_ARGS__) +#define DEFINE_MOCK_METHOD7_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 7, __VA_ARGS__) +#define DEFINE_MOCK_METHOD8_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 8, __VA_ARGS__) +#define DEFINE_MOCK_METHOD9_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 9, __VA_ARGS__) +#define DEFINE_MOCK_METHOD10_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(, ct, cls, m, 10, __VA_ARGS__) + +#define DEFINE_MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 0, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 1, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 2, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 3, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 4, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 5, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 6, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 7, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 8, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 9, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, cls, m, ...) \ + GMOCK_INTERNAL_DEFINE_MOCK_METHODN(const, ct, cls, m, 10, __VA_ARGS__) + +#define DEFINE_MOCK_METHOD0_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD0_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD1_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD1_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD2_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD2_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD3_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD3_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD4_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD4_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD5_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD5_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD6_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD6_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD7_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD7_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD8_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD8_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD9_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD9_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_METHOD10_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_METHOD10_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) + +#define DEFINE_MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) +#define DEFINE_MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, cls, m, ...) \ + DEFINE_MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, cls, m, __VA_ARGS__) + +#define GMOCK_INTERNAL_DEFINE_MOCK_METHODN(constness, ct, Class, Method, \ + args_num, ...) \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ + GMOCK_INTERNAL_DEFINE_MOCK_METHOD_IMPL( \ + args_num, Class, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ + (::testing::internal::identity_t<__VA_ARGS__>)) + #define GMOCK_MOCKER_(arity, constness, Method) \ GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) diff --git a/googlemock/test/gmock-function-mocker_test.cc b/googlemock/test/gmock-function-mocker_test.cc index 05e26c8c4..35d1d806e 100644 --- a/googlemock/test/gmock-function-mocker_test.cc +++ b/googlemock/test/gmock-function-mocker_test.cc @@ -53,9 +53,11 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503) #include #include #include +#include #include "gmock/gmock.h" #include "gtest/gtest.h" +#include "split-mock_test_helper.h" namespace testing { namespace gmock_function_mocker_test { @@ -573,6 +575,36 @@ TEST(FunctionMockerTest, RefQualified) { EXPECT_EQ(std::move(mock_foo).RefQualifiedOverloaded(), 8); // NOLINT } +TEST(SplitMockTest, CallMockMethods) { + MockSplitDeclarationAndDefinition mock_split; + + EXPECT_CALL(mock_split, func(1)).WillOnce(Return(2)); + EXPECT_CALL(mock_split, func_const(3)).WillOnce(Return(4)); + + EXPECT_CALL(mock_split, func_overloaded()).WillOnce(Return(5)); + EXPECT_CALL(mock_split, func_overloaded(6)).WillOnce(Return(7)); + EXPECT_CALL(std::as_const(mock_split), func_overloaded(8)) + .WillOnce(Return(9)); + EXPECT_CALL(mock_split, func_overloaded(10, 11)).WillOnce(Return(12)); + EXPECT_CALL(std::move(mock_split), func_overloaded(13, 14)) + .WillOnce(Return(15)); + + EXPECT_CALL(mock_split, func_legacy(16, 17)).WillOnce(Return(18)); + EXPECT_CALL(mock_split, func_legacy_const(19)).WillOnce(Return(20)); + + EXPECT_EQ(mock_split.func(1), 2); + EXPECT_EQ(std::as_const(mock_split).func_const(3), 4); + + EXPECT_EQ(mock_split.func_overloaded(), 5); + EXPECT_EQ(mock_split.func_overloaded(6), 7); + EXPECT_EQ(std::as_const(mock_split).func_overloaded(8), 9); + EXPECT_EQ(mock_split.func_overloaded(10, 11), 12); + EXPECT_EQ(std::move(std::as_const(mock_split)).func_overloaded(13, 14), 15); + + EXPECT_EQ(mock_split.func_legacy(16, 17), 18); + EXPECT_EQ(std::as_const(mock_split).func_legacy_const(19), 20); +} + class MockB { public: MockB() = default; diff --git a/googlemock/test/split-mock_test_helper.cc b/googlemock/test/split-mock_test_helper.cc new file mode 100644 index 000000000..64537e566 --- /dev/null +++ b/googlemock/test/split-mock_test_helper.cc @@ -0,0 +1,57 @@ +// Copyright 2026, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// A test helper file defining the methods of a mock class declared in +// a header file. + +#include "split-mock_test_helper.h" + +MockSplitDeclarationAndDefinition::MockSplitDeclarationAndDefinition() = + default; +MockSplitDeclarationAndDefinition::~MockSplitDeclarationAndDefinition() = + default; + +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func, (int)); +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_const, (int), + (const)); + +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_overloaded, ()); +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_overloaded, + (int)); +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_overloaded, + (int), (const)); +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_overloaded, + (int, int), (ref(&))); +DEFINE_MOCK_METHOD(MockSplitDeclarationAndDefinition, int, func_overloaded, + (int, int), (const, ref(&&))); + +DEFINE_MOCK_METHOD2(MockSplitDeclarationAndDefinition, func_legacy, + int(int, int)); +DEFINE_MOCK_CONST_METHOD1(MockSplitDeclarationAndDefinition, func_legacy_const, + int(int)); diff --git a/googlemock/test/split-mock_test_helper.h b/googlemock/test/split-mock_test_helper.h new file mode 100644 index 000000000..bea110c7a --- /dev/null +++ b/googlemock/test/split-mock_test_helper.h @@ -0,0 +1,55 @@ +// Copyright 2026, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// A test helper file declaring a mock class whose methods are defined in +// a .cc file. + +#ifndef GOOGLEMOCK_TEST_GMOCK_LINK_TEST_H_ +#define GOOGLEMOCK_TEST_GMOCK_LINK_TEST_H_ + +#include "gmock/gmock-function-mocker.h" + +struct MockSplitDeclarationAndDefinition { + MockSplitDeclarationAndDefinition(); + ~MockSplitDeclarationAndDefinition(); + + DECLARE_MOCK_METHOD(int, func, (int)); + DECLARE_MOCK_METHOD(int, func_const, (int), (const)); + + DECLARE_MOCK_METHOD(int, func_overloaded, ()); + DECLARE_MOCK_METHOD(int, func_overloaded, (int)); + DECLARE_MOCK_METHOD(int, func_overloaded, (int), (const)); + DECLARE_MOCK_METHOD(int, func_overloaded, (int, int), (ref(&))); + DECLARE_MOCK_METHOD(int, func_overloaded, (int, int), (const, ref(&&))); + + DECLARE_MOCK_METHOD2(func_legacy, int(int, int)); + DECLARE_MOCK_CONST_METHOD1(func_legacy_const, int(int)); +}; + +#endif // GOOGLEMOCK_TEST_SPLIT_MOCK_TEST_HELPER_H_