diff options
Diffstat (limited to 'googlemock')
| -rw-r--r-- | googlemock/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | googlemock/Makefile.am | 3 | ||||
| -rw-r--r-- | googlemock/include/gmock/gmock-function-mocker.h | 205 | ||||
| -rw-r--r-- | googlemock/include/gmock/gmock.h | 1 | ||||
| -rw-r--r-- | googlemock/include/gmock/internal/gmock-pp.h | 360 | ||||
| -rw-r--r-- | googlemock/test/gmock-function-mocker_test.cc | 659 | ||||
| -rw-r--r-- | googlemock/test/gmock-pp_test.cc | 73 |
7 files changed, 1302 insertions, 0 deletions
diff --git a/googlemock/CMakeLists.txt b/googlemock/CMakeLists.txt index 1fd758e7..3e72d75c 100644 --- a/googlemock/CMakeLists.txt +++ b/googlemock/CMakeLists.txt @@ -153,6 +153,7 @@ $env:Path = \"$project_bin;$env:Path\" 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-generated-actions_test gmock_main) cxx_test(gmock-generated-function-mockers_test gmock_main) cxx_test(gmock-generated-internal-utils_test gmock_main) diff --git a/googlemock/Makefile.am b/googlemock/Makefile.am index 9adbc516..016a60e9 100644 --- a/googlemock/Makefile.am +++ b/googlemock/Makefile.am @@ -28,6 +28,7 @@ lib_libgmock_la_SOURCES = src/gmock-all.cc pkginclude_HEADERS = \ include/gmock/gmock-actions.h \ include/gmock/gmock-cardinalities.h \ + include/gmock/gmock-function-mocker.h \ include/gmock/gmock-generated-actions.h \ include/gmock/gmock-generated-function-mockers.h \ include/gmock/gmock-generated-matchers.h \ @@ -43,6 +44,7 @@ pkginclude_internal_HEADERS = \ include/gmock/internal/gmock-generated-internal-utils.h \ include/gmock/internal/gmock-internal-utils.h \ include/gmock/internal/gmock-port.h \ + include/gmock/internal/gmock-pp.h \ include/gmock/internal/custom/gmock-generated-actions.h \ include/gmock/internal/custom/gmock-matchers.h \ include/gmock/internal/custom/gmock-port.h @@ -107,6 +109,7 @@ EXTRA_DIST += \ test/gmock-cardinalities_test.cc \ test/gmock_ex_test.cc \ test/gmock-generated-actions_test.cc \ + test/gmock-function-mocker_test.cc \ test/gmock-generated-function-mockers_test.cc \ test/gmock-generated-internal-utils_test.cc \ test/gmock-generated-matchers_test.cc \ diff --git a/googlemock/include/gmock/gmock-function-mocker.h b/googlemock/include/gmock/gmock-function-mocker.h new file mode 100644 index 00000000..953d7465 --- /dev/null +++ b/googlemock/include/gmock/gmock-function-mocker.h @@ -0,0 +1,205 @@ +#ifndef THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT +#define THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT + +#include "gmock/gmock-generated-function-mockers.h" // NOLINT +#include "gmock/internal/gmock-pp.h" + +#define MOCK_METHOD(...) \ + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ + GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) + +#define GMOCK_INTERNAL_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_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_HAS_NOEXCEPT(_Spec), GMOCK_INTERNAL_GET_CALLTYPE(_Spec), \ + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_WRONG_ARITY(...) \ + static_assert( \ + false, \ + "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 GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ + static_assert(GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ + "_Tuple should be enclosed in parentheses") + +#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ + static_assert( \ + std::is_function<__VA_ARGS__>::value, \ + "Signature must be a function type, maybe return type contains " \ + "unprotected comma."); \ + static_assert( \ + ::testing::tuple_size<typename ::testing::internal::Function< \ + __VA_ARGS__>::ArgumentTuple>::value == _N, \ + "This method does not take " GMOCK_PP_STRINGIZE( \ + _N) " arguments. Parenthesize all types with unproctected commas.") + +// TODO(iserna): Verify each element in spec is one of the allowed. +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) static_assert(true, ""); + +#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ + _Override, _Final, _Noexcept, \ + _CallType, _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, ) GMOCK_PP_IF(_Noexcept, noexcept, ) \ + GMOCK_PP_IF(_Override, override, ) \ + GMOCK_PP_IF(_Final, final, ) { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .SetOwnerAndName(this, #_MethodName); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ + } \ + ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ + } \ + ::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 GMOCK_PP_IF(_Noexcept, noexcept, ) { \ + return GMOCK_PP_CAT(::testing::internal::AdjustConstness_, \ + GMOCK_PP_IF(_Constness, const, ))(this) \ + ->gmock_##_MethodName(GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ + } \ + mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)> \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) + +#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ + +#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ + GMOCK_PP_HAS_COMMA( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_NOEXCEPT(_Tuple) \ + GMOCK_PP_HAS_COMMA( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_NOEXCEPT, ~, _Tuple)) + +#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple) + +#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_CONST_I_const , + +#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , + +#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_FINAL_I_final , + +// TODO(iserna): Maybe noexcept should accept an argument here as well. +#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , + +#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem) \ + GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem), \ + GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \ + (_elem) + +// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and +// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows +// maybe they can be simplified somehow. +#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \ + GMOCK_INTERNAL_IS_CALLTYPE_I( \ + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) +#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg) + +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \ + GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I( \ + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \ + GMOCK_PP_CAT(GMOCK_PP_IDENTITY, _arg) + +#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype + +#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), GMOCK_PP_REMOVE_PARENS, \ + GMOCK_PP_IDENTITY) \ + (_Ret)(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) + +#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ + GMOCK_PP_IDENTITY) \ + (_elem) + +#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \ + GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::std::forward<GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \ + GMOCK_PP_REMOVE_PARENS(_Signature))>( \ + gmock_a##_i) + +#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_MATCHER_O(typename, GMOCK_PP_INC(_i), \ + GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ + GMOCK_PP_COMMA_IF(_i) \ + gmock_a##_i + +#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::testing::A<GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \ + GMOCK_PP_REMOVE_PARENS(_Signature))>() + +#define GMOCK_INTERNAL_ARG_O(_tn, _i, ...) GMOCK_ARG_(_tn, _i, __VA_ARGS__) + +#define GMOCK_INTERNAL_MATCHER_O(_tn, _i, ...) \ + GMOCK_MATCHER_(_tn, _i, __VA_ARGS__) + +#endif // THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ diff --git a/googlemock/include/gmock/gmock.h b/googlemock/include/gmock/gmock.h index dd962260..a1e1e6f1 100644 --- a/googlemock/include/gmock/gmock.h +++ b/googlemock/include/gmock/gmock.h @@ -58,6 +58,7 @@ #include "gmock/gmock-actions.h" #include "gmock/gmock-cardinalities.h" +#include "gmock/gmock-function-mocker.h" #include "gmock/gmock-generated-actions.h" #include "gmock/gmock-generated-function-mockers.h" #include "gmock/gmock-generated-matchers.h" diff --git a/googlemock/include/gmock/internal/gmock-pp.h b/googlemock/include/gmock/internal/gmock-pp.h new file mode 100644 index 00000000..056c4ef6 --- /dev/null +++ b/googlemock/include/gmock/internal/gmock-pp.h @@ -0,0 +1,360 @@ +#ifndef THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_PP_H_ +#define THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_PP_H_ + +#undef GMOCK_PP_INTERNAL_USE_MSVC +#if defined(__clang__) +#define GMOCK_PP_INTERNAL_USE_MSVC 0 +#elif defined(_MSC_VER) +// TODO(iserna): Also verify tradional versus comformant preprocessor. +static_assert( + _MSC_VER >= 1900, + "MSVC version not supported. There is support for MSVC 14.0 and above."); +#define GMOCK_PP_INTERNAL_USE_MSVC 1 +#else +#define GMOCK_PP_INTERNAL_USE_MSVC 0 +#endif + +// Expands and concatenates the arguments. Constructed macros reevaluate. +#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2) + +// Expands and stringifies the only argument. +#define GMOCK_PP_STRINGIZE(_x) GMOCK_PP_INTERNAL_STRINGIZE(_x) + +// Returns empty. Given a variadic number of arguments. +#define GMOCK_PP_EMPTY(...) + +// Returns a comma. Given a variadic number of arguments. +#define GMOCK_PP_COMMA(...) , + +// Returns the only argument. +#define GMOCK_PP_IDENTITY(_1) _1 + +// MSVC preprocessor collapses __VA_ARGS__ in a single argument, we use a +// CAT-like directive to force correct evaluation. Each macro has its own. +#if GMOCK_PP_INTERNAL_USE_MSVC + +// Evaluates to the number of arguments after expansion. +// +// #define PAIR x, y +// +// GMOCK_PP_NARG() => 1 +// GMOCK_PP_NARG(x) => 1 +// GMOCK_PP_NARG(x, y) => 2 +// GMOCK_PP_NARG(PAIR) => 2 +// +// Requires: the number of arguments after expansion is at most 15. +#define GMOCK_PP_NARG(...) \ + GMOCK_PP_INTERNAL_NARG_CAT( \ + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, \ + 8, 7, 6, 5, 4, 3, 2, 1), ) + +// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise +// returns 0. Requires no more than 15 unprotected commas. +#define GMOCK_PP_HAS_COMMA(...) \ + GMOCK_PP_INTERNAL_HAS_COMMA_CAT( \ + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 1, 1, 1, 1, 1, 0), ) +// Returns the first argument. +#define GMOCK_PP_HEAD(...) \ + GMOCK_PP_INTERNAL_HEAD_CAT(GMOCK_PP_INTERNAL_HEAD(__VA_ARGS__), ) + +// Returns the tail. A variadic list of all arguments minus the first. Requires +// at least one argument. +#define GMOCK_PP_TAIL(...) \ + GMOCK_PP_INTERNAL_TAIL_CAT(GMOCK_PP_INTERNAL_TAIL(__VA_ARGS__), ) + +// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__) +#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \ + GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT( \ + GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__), ) + +#else // GMOCK_PP_INTERNAL_USE_MSVC + +#define GMOCK_PP_NARG(...) \ + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, \ + 7, 6, 5, 4, 3, 2, 1) +#define GMOCK_PP_HAS_COMMA(...) \ + GMOCK_PP_INTERNAL_INTERNAL_16TH(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ + 1, 1, 1, 1, 0) +#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD(__VA_ARGS__) +#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL(__VA_ARGS__) +#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \ + GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__) + +#endif // GMOCK_PP_INTERNAL_USE_MSVC + +// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise +// evaluates to `0`. +// +// Requires: * the number of arguments after expansion is at most 15. +// * If the argument is a macro, it must be able to be called with one +// argument. +// +// Implementation details: +// +// There is one case when it generates a compile error: if the argument is macro +// that cannot be called with one argument. +// +// #define M(a, b) // it doesn't matter what it expands to +// +// // Expected: expands to `0`. +// // Actual: compile error. +// GMOCK_PP_IS_EMPTY(M) +// +// There are 4 cases tested: +// +// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0. +// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0. +// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma. +// Expected 0 +// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in +// parenthesis, or is a macro that ()-evaluates to comma. Expected 1. +// +// We trigger detection on '0001', i.e. on empty. +#define GMOCK_PP_IS_EMPTY(...) \ + GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__), \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \ + GMOCK_PP_HAS_COMMA(__VA_ARGS__()), \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__())) + +// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0. +#define GMOCK_PP_IF(_Cond, _Then, _Else) \ + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else) + +// Evaluates to the number of arguments after expansion. Identifies 'empty' as +// 0. +// +// #define PAIR x, y +// +// GMOCK_PP_NARG0() => 0 +// GMOCK_PP_NARG0(x) => 1 +// GMOCK_PP_NARG0(x, y) => 2 +// GMOCK_PP_NARG0(PAIR) => 2 +// +// Requires: * the number of arguments after expansion is at most 15. +// * If the argument is a macro, it must be able to be called with one +// argument. +#define GMOCK_PP_NARG0(...) \ + GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__)) + +// Expands to 1 if the first argument starts with something in parentheses, +// otherwise to 0. +#define GMOCK_PP_IS_BEGIN_PARENS(...) \ + GMOCK_PP_INTERNAL_ALTERNATE_HEAD( \ + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \ + GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__)) + +// Expands to 1 is there is only one argument and it is enclosed in parentheses. +#define GMOCK_PP_IS_ENCLOSED_PARENS(...) \ + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \ + GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0) + +// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1. +#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__ + +// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data, +// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple. +// Requires: * |_Macro| can be called with 3 arguments. +// * |_Tuple| expansion has no more than 15 elements. +#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple) \ + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \ + (0, _Macro, _Data, _Tuple) + +// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, ) +// Empty if _K = 0. +// Requires: * |_Macro| can be called with 3 arguments. +// * |_K| literal between 0 and 15 +#define GMOCK_PP_REPEAT(_Macro, _Data, _N) \ + GMOCK_PP_CAT(GMOCK_PP_INTERNAL_REPEAT_IMPL_, _N)(0, _Macro, _Data) + +// Increments the argument, requires the argument to be between 0 and 15. +#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i) + +// Returns comma if _i != 0. Requires _i to be between 0 and 15. +#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i) + +// Internal details follow. Do not use any of these symbols outside of this +// file or we will break your code. +#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_STRINGIZE(_x) #_x +#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \ + _10, _11, _12, _13, _14, _15, _16, \ + ...) \ + _16 +#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5 +#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \ + _1, _2, _3, _4)) +#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 , +#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then +#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else +#define GMOCK_PP_INTERNAL_HEAD(_1, ...) _1 +#define GMOCK_PP_INTERNAL_TAIL(_1, ...) __VA_ARGS__ + +#if GMOCK_PP_INTERNAL_USE_MSVC +#define GMOCK_PP_INTERNAL_NARG_CAT(_1, _2) GMOCK_PP_INTERNAL_NARG_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_HEAD_CAT(_1, _2) GMOCK_PP_INTERNAL_HEAD_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_HAS_COMMA_CAT(_1, _2) \ + GMOCK_PP_INTERNAL_HAS_COMMA_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_TAIL_CAT(_1, _2) GMOCK_PP_INTERNAL_TAIL_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT(_1, _2) \ + GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_NARG_CAT_I(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_HEAD_CAT_I(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_HAS_COMMA_CAT_I(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_TAIL_CAT_I(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_VARIADIC_CALL_CAT_I(_1, _2) _1##_2 +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD(...) \ + GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT(GMOCK_PP_HEAD(__VA_ARGS__), ) +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT(_1, _2) \ + GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT_I(_1, _2) +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD_CAT_I(_1, _2) _1##_2 +#else // GMOCK_PP_INTERNAL_USE_MSVC +#define GMOCK_PP_INTERNAL_ALTERNATE_HEAD(...) GMOCK_PP_HEAD(__VA_ARGS__) +#endif // GMOCK_PP_INTERNAL_USE_MSVC + +#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _ +#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1, +#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \ + 0, +#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__ +#define GMOCK_PP_INTERNAL_INC_0 1 +#define GMOCK_PP_INTERNAL_INC_1 2 +#define GMOCK_PP_INTERNAL_INC_2 3 +#define GMOCK_PP_INTERNAL_INC_3 4 +#define GMOCK_PP_INTERNAL_INC_4 5 +#define GMOCK_PP_INTERNAL_INC_5 6 +#define GMOCK_PP_INTERNAL_INC_6 7 +#define GMOCK_PP_INTERNAL_INC_7 8 +#define GMOCK_PP_INTERNAL_INC_8 9 +#define GMOCK_PP_INTERNAL_INC_9 10 +#define GMOCK_PP_INTERNAL_INC_10 11 +#define GMOCK_PP_INTERNAL_INC_11 12 +#define GMOCK_PP_INTERNAL_INC_12 13 +#define GMOCK_PP_INTERNAL_INC_13 14 +#define GMOCK_PP_INTERNAL_INC_14 15 +#define GMOCK_PP_INTERNAL_INC_15 16 +#define GMOCK_PP_INTERNAL_COMMA_IF_0 +#define GMOCK_PP_INTERNAL_COMMA_IF_1 , +#define GMOCK_PP_INTERNAL_COMMA_IF_2 , +#define GMOCK_PP_INTERNAL_COMMA_IF_3 , +#define GMOCK_PP_INTERNAL_COMMA_IF_4 , +#define GMOCK_PP_INTERNAL_COMMA_IF_5 , +#define GMOCK_PP_INTERNAL_COMMA_IF_6 , +#define GMOCK_PP_INTERNAL_COMMA_IF_7 , +#define GMOCK_PP_INTERNAL_COMMA_IF_8 , +#define GMOCK_PP_INTERNAL_COMMA_IF_9 , +#define GMOCK_PP_INTERNAL_COMMA_IF_10 , +#define GMOCK_PP_INTERNAL_COMMA_IF_11 , +#define GMOCK_PP_INTERNAL_COMMA_IF_12 , +#define GMOCK_PP_INTERNAL_COMMA_IF_13 , +#define GMOCK_PP_INTERNAL_COMMA_IF_14 , +#define GMOCK_PP_INTERNAL_COMMA_IF_15 , +#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \ + _Macro(_i, _Data, _element) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ + GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data, \ + (GMOCK_PP_TAIL _Tuple)) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_0(_i, _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_1(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_2(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_3(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_4(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_5(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_6(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_7(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_8(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_9(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_10(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_11(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_12(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_13(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_14(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data) +#define GMOCK_PP_INTERNAL_REPEAT_IMPL_15(_i, _Macro, _Data) \ + GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, ) \ + GMOCK_PP_INTERNAL_REPEAT_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data) + +#endif // THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ diff --git a/googlemock/test/gmock-function-mocker_test.cc b/googlemock/test/gmock-function-mocker_test.cc new file mode 100644 index 00000000..007e86c2 --- /dev/null +++ b/googlemock/test/gmock-function-mocker_test.cc @@ -0,0 +1,659 @@ +// Copyright 2007, 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. + + +// Google Mock - a framework for writing C++ mock classes. +// +// This file tests the function mocker classes. +#include "gmock/gmock-generated-function-mockers.h" + +#if GTEST_OS_WINDOWS +// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but +// we are getting compiler errors if we use basetyps.h, hence including +// objbase.h for definition of STDMETHOD. +# include <objbase.h> +#endif // GTEST_OS_WINDOWS + +#include <map> +#include <string> +#include "gmock/gmock.h" +#include "gtest/gtest.h" + +// There is a bug in MSVC (fixed in VS 2008) that prevents creating a +// mock for a function with const arguments, so we don't test such +// cases for MSVC versions older than 2008. +#if !GTEST_OS_WINDOWS || (_MSC_VER >= 1500) +# define GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS +#endif // !GTEST_OS_WINDOWS || (_MSC_VER >= 1500) + +namespace testing { +namespace gmock_function_mocker_test { + +using testing::_; +using testing::A; +using testing::An; +using testing::AnyNumber; +using testing::Const; +using testing::DoDefault; +using testing::Eq; +using testing::Lt; +using testing::MockFunction; +using testing::Ref; +using testing::Return; +using testing::ReturnRef; +using testing::TypedEq; + +class FooInterface { + public: + virtual ~FooInterface() {} + + virtual void VoidReturning(int x) = 0; + + virtual int Nullary() = 0; + virtual bool Unary(int x) = 0; + virtual long Binary(short x, int y) = 0; // NOLINT + virtual int Decimal(bool b, char c, short d, int e, long f, // NOLINT + float g, double h, unsigned i, char* j, + const std::string& k) = 0; + + virtual bool TakesNonConstReference(int& n) = 0; // NOLINT + virtual std::string TakesConstReference(const int& n) = 0; +#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS + virtual bool TakesConst(const int x) = 0; +#endif // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS + + virtual int OverloadedOnArgumentNumber() = 0; + virtual int OverloadedOnArgumentNumber(int n) = 0; + + virtual int OverloadedOnArgumentType(int n) = 0; + virtual char OverloadedOnArgumentType(char c) = 0; + + virtual int OverloadedOnConstness() = 0; + virtual char OverloadedOnConstness() const = 0; + + virtual int TypeWithHole(int (*func)()) = 0; + virtual int TypeWithComma(const std::map<int, std::string>& a_map) = 0; + +#if GTEST_OS_WINDOWS + STDMETHOD_(int, CTNullary)() = 0; + STDMETHOD_(bool, CTUnary)(int x) = 0; + STDMETHOD_(int, CTDecimal) + (bool b, char c, short d, int e, long f, // NOLINT + float g, double h, unsigned i, char* j, const std::string& k) = 0; + STDMETHOD_(char, CTConst)(int x) const = 0; +#endif // GTEST_OS_WINDOWS +}; + +// Const qualifiers on arguments were once (incorrectly) considered +// significant in determining whether two virtual functions had the same +// signature. This was fixed in Visual Studio 2008. However, the compiler +// still emits a warning that alerts about this change in behavior. +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable : 4373) +#endif +class MockFoo : public FooInterface { + public: + MockFoo() {} + + // Makes sure that a mock function parameter can be named. + MOCK_METHOD(void, VoidReturning, (int n)); // NOLINT + + MOCK_METHOD(int, Nullary, ()); // NOLINT + + // Makes sure that a mock function parameter can be unnamed. + MOCK_METHOD(bool, Unary, (int)); // NOLINT + MOCK_METHOD(long, Binary, (short, int)); // NOLINT + MOCK_METHOD(int, Decimal, + (bool, char, short, int, long, float, // NOLINT + double, unsigned, char*, const std::string& str), + (override)); + + MOCK_METHOD(bool, TakesNonConstReference, (int&)); // NOLINT + MOCK_METHOD(std::string, TakesConstReference, (const int&)); + +#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS + MOCK_METHOD(bool, TakesConst, (const int)); // NOLINT +#endif + + // Tests that the function return type can contain unprotected comma. + MOCK_METHOD((std::map<int, std::string>), ReturnTypeWithComma, (), ()); + MOCK_METHOD((std::map<int, std::string>), ReturnTypeWithComma, (int), + (const)); // NOLINT + + MOCK_METHOD(int, OverloadedOnArgumentNumber, ()); // NOLINT + MOCK_METHOD(int, OverloadedOnArgumentNumber, (int)); // NOLINT + + MOCK_METHOD(int, OverloadedOnArgumentType, (int)); // NOLINT + MOCK_METHOD(char, OverloadedOnArgumentType, (char)); // NOLINT + + MOCK_METHOD(int, OverloadedOnConstness, (), (override)); // NOLINT + MOCK_METHOD(char, OverloadedOnConstness, (), (override, const)); // NOLINT + + MOCK_METHOD(int, TypeWithHole, (int (*)()), ()); // NOLINT + MOCK_METHOD(int, TypeWithComma, ((const std::map<int, std::string>&))); + +#if GTEST_OS_WINDOWS + MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD(int, CTDecimal, + (bool b, char c, short d, int e, long f, float g, double h, + unsigned i, char* j, const std::string& k), + (Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD(char, CTConst, (int), (const, Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD((std::map<int, std::string>), CTReturnTypeWithComma, (), + (Calltype(STDMETHODCALLTYPE))); +#endif // GTEST_OS_WINDOWS + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo); +}; +#ifdef _MSC_VER +# pragma warning(pop) +#endif + +class MockMethodFunctionMockerTest : public testing::Test { + protected: + MockMethodFunctionMockerTest() : foo_(&mock_foo_) {} + + FooInterface* const foo_; + MockFoo mock_foo_; +}; + +// Tests mocking a void-returning function. +TEST_F(MockMethodFunctionMockerTest, MocksVoidFunction) { + EXPECT_CALL(mock_foo_, VoidReturning(Lt(100))); + foo_->VoidReturning(0); +} + +// Tests mocking a nullary function. +TEST_F(MockMethodFunctionMockerTest, MocksNullaryFunction) { + EXPECT_CALL(mock_foo_, Nullary()) + .WillOnce(DoDefault()) + .WillOnce(Return(1)); + + EXPECT_EQ(0, foo_->Nullary()); + EXPECT_EQ(1, foo_->Nullary()); +} + +// Tests mocking a unary function. +TEST_F(MockMethodFunctionMockerTest, MocksUnaryFunction) { + EXPECT_CALL(mock_foo_, Unary(Eq(2))) + .Times(2) + .WillOnce(Return(true)); + + EXPECT_TRUE(foo_->Unary(2)); + EXPECT_FALSE(foo_->Unary(2)); +} + +// Tests mocking a binary function. +TEST_F(MockMethodFunctionMockerTest, MocksBinaryFunction) { + EXPECT_CALL(mock_foo_, Binary(2, _)) + .WillOnce(Return(3)); + + EXPECT_EQ(3, foo_->Binary(2, 1)); +} + +// Tests mocking a decimal function. +TEST_F(MockMethodFunctionMockerTest, MocksDecimalFunction) { + EXPECT_CALL(mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(), + Lt(100), 5U, NULL, "hi")) + .WillOnce(Return(5)); + + EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi")); +} + +// Tests mocking a function that takes a non-const reference. +TEST_F(MockMethodFunctionMockerTest, + MocksFunctionWithNonConstReferenceArgument) { + int a = 0; + EXPECT_CALL(mock_foo_, TakesNonConstReference(Ref(a))) + .WillOnce(Return(true)); + + EXPECT_TRUE(foo_->TakesNonConstReference(a)); +} + +// Tests mocking a function that takes a const reference. +TEST_F(MockMethodFunctionMockerTest, MocksFunctionWithConstReferenceArgument) { + int a = 0; + EXPECT_CALL(mock_foo_, TakesConstReference(Ref(a))) + .WillOnce(Return("Hello")); + + EXPECT_EQ("Hello", foo_->TakesConstReference(a)); +} + +#ifdef GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS +// Tests mocking a function that takes a const variable. +TEST_F(MockMethodFunctionMockerTest, MocksFunctionWithConstArgument) { + EXPECT_CALL(mock_foo_, TakesConst(Lt(10))) + .WillOnce(DoDefault()); + + EXPECT_FALSE(foo_->TakesConst(5)); +} +#endif // GMOCK_ALLOWS_CONST_PARAM_FUNCTIONS + +// Tests mocking functions overloaded on the number of arguments. +TEST_F(MockMethodFunctionMockerTest, MocksFunctionsOverloadedOnArgumentNumber) { + EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber()) + .WillOnce(Return(1)); + EXPECT_CALL(mock_foo_, OverloadedOnArgumentNumber(_)) + .WillOnce(Return(2)); + + EXPECT_EQ(2, foo_->OverloadedOnArgumentNumber(1)); + EXPECT_EQ(1, foo_->OverloadedOnArgumentNumber()); +} + +// Tests mocking functions overloaded on the types of argument. +TEST_F(MockMethodFunctionMockerTest, MocksFunctionsOverloadedOnArgumentType) { + EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(An<int>())) + .WillOnce(Return(1)); + EXPECT_CALL(mock_foo_, OverloadedOnArgumentType(TypedEq<char>('a'))) + .WillOnce(Return('b')); + + EXPECT_EQ(1, foo_->OverloadedOnArgumentType(0)); + EXPECT_EQ('b', foo_->OverloadedOnArgumentType('a')); +} + +// Tests mocking functions overloaded on the const-ness of this object. +TEST_F(MockMethodFunctionMockerTest, + MocksFunctionsOverloadedOnConstnessOfThis) { + EXPECT_CALL(mock_foo_, OverloadedOnConstness()); + EXPECT_CALL(Const(mock_foo_), OverloadedOnConstness()) + .WillOnce(Return('a')); + + EXPECT_EQ(0, foo_->OverloadedOnConstness()); + EXPECT_EQ('a', Const(*foo_).OverloadedOnConstness()); +} + +TEST_F(MockMethodFunctionMockerTest, MocksReturnTypeWithComma) { + const std::map<int, std::string> a_map; + EXPECT_CALL(mock_foo_, ReturnTypeWithComma()) + .WillOnce(Return(a_map)); + EXPECT_CALL(mock_foo_, ReturnTypeWithComma(42)) + .WillOnce(Return(a_map)); + + EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma()); + EXPECT_EQ(a_map, mock_foo_.ReturnTypeWithComma(42)); +} + +#if GTEST_OS_WINDOWS +// Tests mocking a nullary function with calltype. +TEST_F(MockMethodFunctionMockerTest, MocksNullaryFunctionWithCallType) { + EXPECT_CALL(mock_foo_, CTNullary()) + .WillOnce(Return(-1)) + .WillOnce(Return(0)); + + EXPECT_EQ(-1, foo_->CTNullary()); + EXPECT_EQ(0, foo_->CTNullary()); +} + +// Tests mocking a unary function with calltype. +TEST_F(MockMethodFunctionMockerTest, MocksUnaryFunctionWithCallType) { + EXPECT_CALL(mock_foo_, CTUnary(Eq(2))) + .Times(2) + .WillOnce(Return(true)) + .WillOnce(Return(false)); + + EXPECT_TRUE(foo_->CTUnary(2)); + EXPECT_FALSE(foo_->CTUnary(2)); +} + +// Tests mocking a decimal function with calltype. +TEST_F(MockMethodFunctionMockerTest, MocksDecimalFunctionWithCallType) { + EXPECT_CALL(mock_foo_, CTDecimal(true, 'a', 0, 0, 1L, A<float>(), + Lt(100), 5U, NULL, "hi")) + .WillOnce(Return(10)); + + EXPECT_EQ(10, foo_->CTDecimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi")); +} + +// Tests mocking functions overloaded on the const-ness of this object. +TEST_F(MockMethodFunctionMockerTest, MocksFunctionsConstFunctionWithCallType) { + EXPECT_CALL(Const(mock_foo_), CTConst(_)) + .WillOnce(Return('a')); + + EXPECT_EQ('a', Const(*foo_).CTConst(0)); +} + +TEST_F(MockMethodFunctionMockerTest, MocksReturnTypeWithCommaAndCallType) { + const std::map<int, std::string> a_map; + EXPECT_CALL(mock_foo_, CTReturnTypeWithComma()) + .WillOnce(Return(a_map)); + + EXPECT_EQ(a_map, mock_foo_.CTReturnTypeWithComma()); +} + +#endif // GTEST_OS_WINDOWS + +class MockB { + public: + MockB() {} + + MOCK_METHOD(void, DoB, ()); + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB); +}; + +// Tests that functions with no EXPECT_CALL() rules can be called any +// number of times. +TEST(MockMethodExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) { + { + MockB b; + } + + { + MockB b; + b.DoB(); + } + + { + MockB b; + b.DoB(); + b.DoB(); + } +} + +// Tests mocking template interfaces. + +template <typename T> +class StackInterface { + public: + virtual ~StackInterface() {} + + // Template parameter appears in function parameter. + virtual void Push(const T& value) = 0; + virtual void Pop() = 0; + virtual int GetSize() const = 0; + // Template parameter appears in function return type. + virtual const T& GetTop() const = 0; +}; + +template <typename T> +class MockStack : public StackInterface<T> { + public: + MockStack() {} + + MOCK_METHOD(void, Push, (const T& elem), ()); + MOCK_METHOD(void, Pop, (), (final)); + MOCK_METHOD(int, GetSize, (), (const, override)); + MOCK_METHOD(const T&, GetTop, (), (const)); + + // Tests that the function return type can contain unprotected comma. + MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (), ()); + MOCK_METHOD((std::map<int, int>), ReturnTypeWithComma, (int), (const)); + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack); +}; + +// Tests that template mock works. +TEST(MockMethodTemplateMockTest, Works) { + MockStack<int> mock; + + EXPECT_CALL(mock, GetSize()) + .WillOnce(Return(0)) + .WillOnce(Return(1)) + .WillOnce(Return(0)); + EXPECT_CALL(mock, Push(_)); + int n = 5; + EXPECT_CALL(mock, GetTop()) + .WillOnce(ReturnRef(n)); + EXPECT_CALL(mock, Pop()) + .Times(AnyNumber()); + + EXPECT_EQ(0, mock.GetSize()); + mock.Push(5); + EXPECT_EQ(1, mock.GetSize()); + EXPECT_EQ(5, mock.GetTop()); + mock.Pop(); + EXPECT_EQ(0, mock.GetSize()); +} + +TEST(MockMethodTemplateMockTest, MethodWithCommaInReturnTypeWorks) { + MockStack<int> mock; + + const std::map<int, int> a_map; + EXPECT_CALL(mock, ReturnTypeWithComma()) + .WillOnce(Return(a_map)); + EXPECT_CALL(mock, ReturnTypeWithComma(1)) + .WillOnce(Return(a_map)); + + EXPECT_EQ(a_map, mock.ReturnTypeWithComma()); + EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1)); +} + +#if GTEST_OS_WINDOWS +// Tests mocking template interfaces with calltype. + +template <typename T> +class StackInterfaceWithCallType { + public: + virtual ~StackInterfaceWithCallType() {} + + // Template parameter appears in function parameter. + STDMETHOD_(void, Push)(const T& value) = 0; + STDMETHOD_(void, Pop)() = 0; + STDMETHOD_(int, GetSize)() const = 0; + // Template parameter appears in function return type. + STDMETHOD_(const T&, GetTop)() const = 0; +}; + +template <typename T> +class MockStackWithCallType : public StackInterfaceWithCallType<T> { + public: + MockStackWithCallType() {} + + MOCK_METHOD(void, Push, (const T& elem), + (Calltype(STDMETHODCALLTYPE), override)); + MOCK_METHOD(void, Pop, (), (Calltype(STDMETHODCALLTYPE), override)); + MOCK_METHOD(int, GetSize, (), (Calltype(STDMETHODCALLTYPE), override, const)); + MOCK_METHOD(const T&, GetTop, (), + (Calltype(STDMETHODCALLTYPE), override, const)); + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType); +}; + +// Tests that template mock with calltype works. +TEST(MockMethodTemplateMockTestWithCallType, Works) { + MockStackWithCallType<int> mock; + + EXPECT_CALL(mock, GetSize()) + .WillOnce(Return(0)) + .WillOnce(Return(1)) + .WillOnce(Return(0)); + EXPECT_CALL(mock, Push(_)); + int n = 5; + EXPECT_CALL(mock, GetTop()) + .WillOnce(ReturnRef(n)); + EXPECT_CALL(mock, Pop()) + .Times(AnyNumber()); + + EXPECT_EQ(0, mock.GetSize()); + mock.Push(5); + EXPECT_EQ(1, mock.GetSize()); + EXPECT_EQ(5, mock.GetTop()); + mock.Pop(); + EXPECT_EQ(0, mock.GetSize()); +} +#endif // GTEST_OS_WINDOWS + +#define MY_MOCK_METHODS1_ \ + MOCK_METHOD(void, Overloaded, ()); \ + MOCK_METHOD(int, Overloaded, (int), (const)); \ + MOCK_METHOD(bool, Overloaded, (bool f, int n)) + +class MockOverloadedOnArgNumber { + public: + MockOverloadedOnArgNumber() {} + + MY_MOCK_METHODS1_; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber); +}; + +TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) { + MockOverloadedOnArgNumber mock; + EXPECT_CALL(mock, Overloaded()); + EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); + EXPECT_CALL(mock, Overloaded(true, 1)).WillOnce(Return(true)); + + mock.Overloaded(); + EXPECT_EQ(2, mock.Overloaded(1)); + EXPECT_TRUE(mock.Overloaded(true, 1)); +} + +#define MY_MOCK_METHODS2_ \ + MOCK_CONST_METHOD1(Overloaded, int(int n)); \ + MOCK_METHOD1(Overloaded, int(int n)); + +class MockOverloadedOnConstness { + public: + MockOverloadedOnConstness() {} + + MY_MOCK_METHODS2_; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness); +}; + +TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) { + MockOverloadedOnConstness mock; + const MockOverloadedOnConstness* const_mock = &mock; + EXPECT_CALL(mock, Overloaded(1)).WillOnce(Return(2)); + EXPECT_CALL(*const_mock, Overloaded(1)).WillOnce(Return(3)); + + EXPECT_EQ(2, mock.Overloaded(1)); + EXPECT_EQ(3, const_mock->Overloaded(1)); +} + +TEST(MockMethodMockFunctionTest, WorksForVoidNullary) { + MockFunction<void()> foo; + EXPECT_CALL(foo, Call()); + foo.Call(); +} + +TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) { + MockFunction<int()> foo; + EXPECT_CALL(foo, Call()) + .WillOnce(Return(1)) + .WillOnce(Return(2)); + EXPECT_EQ(1, foo.Call()); + EXPECT_EQ(2, foo.Call()); +} + +TEST(MockMethodMockFunctionTest, WorksForVoidUnary) { + MockFunction<void(int)> foo; + EXPECT_CALL(foo, Call(1)); + foo.Call(1); +} + +TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) { + MockFunction<int(bool, int)> foo; + EXPECT_CALL(foo, Call(false, 42)) + .WillOnce(Return(1)) + .WillOnce(Return(2)); + EXPECT_CALL(foo, Call(true, Ge(100))) + .WillOnce(Return(3)); + EXPECT_EQ(1, foo.Call(false, 42)); + EXPECT_EQ(2, foo.Call(false, 42)); + EXPECT_EQ(3, foo.Call(true, 120)); +} + +TEST(MockMethodMockFunctionTest, WorksFor10Arguments) { + MockFunction<int(bool a0, char a1, int a2, int a3, int a4, + int a5, int a6, char a7, int a8, bool a9)> foo; + EXPECT_CALL(foo, Call(_, 'a', _, _, _, _, _, _, _, _)) + .WillOnce(Return(1)) + .WillOnce(Return(2)); + EXPECT_EQ(1, foo.Call(false, 'a', 0, 0, 0, 0, 0, 'b', 0, true)); + EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false)); +} + +#if GTEST_HAS_STD_FUNCTION_ +TEST(MockMethodMockFunctionTest, AsStdFunction) { + MockFunction<int(int)> foo; + auto call = [](const std::function<int(int)> &f, int i) { + return f(i); + }; + EXPECT_CALL(foo, Call(1)).WillOnce(Return(-1)); + EXPECT_CALL(foo, Call(2)).WillOnce(Return(-2)); + EXPECT_EQ(-1, call(foo.AsStdFunction(), 1)); + EXPECT_EQ(-2, call(foo.AsStdFunction(), 2)); +} + +TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) { + MockFunction<int&()> foo; + int value = 1; + EXPECT_CALL(foo, Call()).WillOnce(ReturnRef(value)); + int& ref = foo.AsStdFunction()(); + EXPECT_EQ(1, ref); + value = 2; + EXPECT_EQ(2, ref); +} + +TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) { + MockFunction<int(int &)> foo; + auto call = [](const std::function<int(int& )> &f, int &i) { + return f(i); + }; + int i = 42; + EXPECT_CALL(foo, Call(i)).WillOnce(Return(-1)); + EXPECT_EQ(-1, call(foo.AsStdFunction(), i)); +} + +#endif // GTEST_HAS_STD_FUNCTION_ + +struct MockMethodSizes0 { + MOCK_METHOD(void, func, ()); +}; +struct MockMethodSizes1 { + MOCK_METHOD(void, func, (int)); +}; +struct MockMethodSizes2 { + MOCK_METHOD(void, func, (int, int)); +}; +struct MockMethodSizes3 { + MOCK_METHOD(void, func, (int, int, int)); +}; +struct MockMethodSizes4 { + MOCK_METHOD(void, func, (int, int, int, int)); +}; + +TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) { + EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes1)); + EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes2)); + EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes3)); + EXPECT_EQ(sizeof(MockMethodSizes0), sizeof(MockMethodSizes4)); +} + +} // namespace gmock_function_mocker_test +} // namespace testing diff --git a/googlemock/test/gmock-pp_test.cc b/googlemock/test/gmock-pp_test.cc new file mode 100644 index 00000000..7387d398 --- /dev/null +++ b/googlemock/test/gmock-pp_test.cc @@ -0,0 +1,73 @@ +#include "gmock/internal/gmock-pp.h" + +// Static assertions. +namespace testing { +namespace internal { +namespace gmockpp { + +static_assert(GMOCK_PP_CAT(1, 4) == 14, ""); +static_assert(GMOCK_PP_INTERNAL_INTERNAL_16TH(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18) == 16, + ""); +static_assert(GMOCK_PP_NARG() == 1, ""); +static_assert(GMOCK_PP_NARG(x) == 1, ""); +static_assert(GMOCK_PP_NARG(x, y) == 2, ""); +static_assert(GMOCK_PP_NARG(x, y, z) == 3, ""); +static_assert(GMOCK_PP_NARG(x, y, z, w) == 4, ""); +static_assert(!GMOCK_PP_HAS_COMMA(), ""); +static_assert(GMOCK_PP_HAS_COMMA(b, ), ""); +static_assert(!GMOCK_PP_HAS_COMMA((, )), ""); +static_assert(!GMOCK_PP_IS_EMPTY(, ), ""); +static_assert(!GMOCK_PP_IS_EMPTY(a), ""); +static_assert(!GMOCK_PP_IS_EMPTY(()), ""); +static_assert(GMOCK_PP_IF(1, 1, 2) == 1, ""); +static_assert(GMOCK_PP_IF(0, 1, 2) == 2, ""); +static_assert(GMOCK_PP_NARG0(x) == 1, ""); +static_assert(GMOCK_PP_NARG0(x, y) == 2, ""); +static_assert(GMOCK_PP_HEAD(1) == 1, ""); +static_assert(GMOCK_PP_HEAD(1, 2) == 1, ""); +static_assert(GMOCK_PP_HEAD(1, 2, 3) == 1, ""); +static_assert(GMOCK_PP_TAIL(1, 2) == 2, ""); +static_assert(GMOCK_PP_HEAD(GMOCK_PP_TAIL(1, 2, 3)) == 2, ""); +static_assert(!GMOCK_PP_IS_BEGIN_PARENS(sss), ""); +static_assert(!GMOCK_PP_IS_BEGIN_PARENS(sss()), ""); +static_assert(!GMOCK_PP_IS_BEGIN_PARENS(sss() sss), ""); +static_assert(GMOCK_PP_IS_BEGIN_PARENS((sss)), ""); +static_assert(GMOCK_PP_IS_BEGIN_PARENS((sss)ss), ""); +static_assert(!GMOCK_PP_IS_ENCLOSED_PARENS(sss), ""); +static_assert(!GMOCK_PP_IS_ENCLOSED_PARENS(sss()), ""); +static_assert(!GMOCK_PP_IS_ENCLOSED_PARENS(sss() sss), ""); +static_assert(!GMOCK_PP_IS_ENCLOSED_PARENS((sss)ss), ""); +static_assert(GMOCK_PP_REMOVE_PARENS((1 + 1)) * 2 == 3, ""); +static_assert(GMOCK_PP_INC(4) == 5, ""); + +template <class... Args> +struct Test { + static constexpr int kArgs = sizeof...(Args); +}; +#define GMOCK_PP_INTERNAL_TYPE_TEST(_i, _Data, _element) \ + GMOCK_PP_COMMA_IF(_i) _element +static_assert(Test<GMOCK_PP_FOR_EACH(GMOCK_PP_INTERNAL_TYPE_TEST, ~, + (int, float, double, char))>::kArgs == 4, + ""); +#define GMOCK_PP_INTERNAL_VAR_TEST_1(_x) 1 +#define GMOCK_PP_INTERNAL_VAR_TEST_2(_x, _y) 2 +#define GMOCK_PP_INTERNAL_VAR_TEST_3(_x, _y, _z) 3 + +#define GMOCK_PP_INTERNAL_VAR_TEST(...) \ + GMOCK_PP_VARIADIC_CALL(GMOCK_PP_INTERNAL_VAR_TEST_, __VA_ARGS__) +static_assert(GMOCK_PP_INTERNAL_VAR_TEST(x, y) == 2, ""); +static_assert(GMOCK_PP_INTERNAL_VAR_TEST(silly) == 1, ""); +static_assert(GMOCK_PP_INTERNAL_VAR_TEST(x, y, z) == 3, ""); + +// TODO(iserna): The following asserts fail in --config=lexan. +#define GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1 +static_assert(GMOCK_PP_IS_EMPTY(GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1), ""); +static_assert(GMOCK_PP_IS_EMPTY(), ""); +static_assert(GMOCK_PP_IS_ENCLOSED_PARENS((sss)), ""); +static_assert(GMOCK_PP_IS_EMPTY(GMOCK_PP_TAIL(1)), ""); +static_assert(GMOCK_PP_NARG0() == 0, ""); + +} // namespace gmockpp +} // namespace internal +} // namespace testing |