mirror of
https://github.com/google/googletest.git
synced 2026-06-15 08:26:11 +08:00
Merge faf2028a338aa89098068ed9fd802a2143e7e49b into 7140cd416cecd7462a8aae488024abeee55598e4
This commit is contained in:
nautical-exact
GitHub
commit
bb5ce08eb7
@ -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
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -50,6 +50,9 @@ namespace internal {
|
||||
template <typename T>
|
||||
using identity_t = T;
|
||||
|
||||
template <typename T>
|
||||
struct TypeTag {};
|
||||
|
||||
template <typename Pattern>
|
||||
struct ThisRefAdjuster {
|
||||
template <typename T>
|
||||
@ -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_PP_REMOVE_PARENS(_Signature)> \
|
||||
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<GMOCK_PP_REMOVE_PARENS( \
|
||||
_Signature)>::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_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
|
||||
GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \
|
||||
GMOCK_PP_IF(_Constness, const, ) _RefSpec; \
|
||||
::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> 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_PP_REMOVE_PARENS(_Signature)>& \
|
||||
gmock_get_mocker_##_MethodName( \
|
||||
::testing::internal::TypeTag<GMOCK_PP_REMOVE_PARENS( \
|
||||
_Signature) GMOCK_PP_IF(_Constness, const, ) _RefSpec>) const { \
|
||||
return GMOCK_MOCKER_(_N, _Constness, _MethodName); \
|
||||
} \
|
||||
mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> \
|
||||
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<GMOCK_PP_REMOVE_PARENS( \
|
||||
_Signature)>::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<GMOCK_PP_REMOVE_PARENS( \
|
||||
_Signature) GMOCK_PP_IF(_Constness, const, ) _RefSpec>{}); \
|
||||
mocker.SetOwnerAndName(this, #_MethodName); \
|
||||
return mocker.Invoke( \
|
||||
GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \
|
||||
} \
|
||||
::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> \
|
||||
_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<GMOCK_PP_REMOVE_PARENS( \
|
||||
_Signature) GMOCK_PP_IF(_Constness, const, ) _RefSpec>{}); \
|
||||
mocker.RegisterOwner(this); \
|
||||
return mocker.With( \
|
||||
GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \
|
||||
} \
|
||||
::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> \
|
||||
_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<GMOCK_PP_IF( \
|
||||
_Constness, const, ) int _RefSpec>::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__)
|
||||
|
||||
|
||||
@ -53,9 +53,11 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503)
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
#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;
|
||||
|
||||
57
googlemock/test/split-mock_test_helper.cc
Normal file
57
googlemock/test/split-mock_test_helper.cc
Normal file
@ -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));
|
||||
55
googlemock/test/split-mock_test_helper.h
Normal file
55
googlemock/test/split-mock_test_helper.h
Normal file
@ -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_
|
||||
Loading…
x
Reference in New Issue
Block a user