llvm/third-party/unittest/googlemock/include/gmock/gmock-function-mocker.h

// 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 implements MOCK_METHOD.

// IWYU pragma: private, include "gmock/gmock.h"
// IWYU pragma: friend gmock/.*

#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_

#include <type_traits>  // IWYU pragma: keep
#include <utility>      // IWYU pragma: keep

#include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-pp.h"

namespace testing {
namespace internal {
identity_t;

template <typename Pattern>
struct ThisRefAdjuster {};

constexpr bool PrefixOf(const char* a, const char* b) {}

template <int N, int M>
constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {}

template <int N, int M>
constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {}

template <int N, int M>
constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {}

template <int N>
constexpr bool ValidateSpec(const char (&spec)[N]) {}

}  // namespace internal

// The style guide prohibits "using" statements in a namespace scope
// inside a header file.  However, the FunctionMocker class template
// is meant to be defined in the ::testing namespace.  The following
// line is just a trick for working around a bug in MSVC 8.0, which
// cannot handle it if we define FunctionMocker in ::testing.
FunctionMocker;
}  // namespace testing

#define MOCK_METHOD(...)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...)

#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...)

#define GMOCK_INTERNAL_WRONG_ARITY(...)

#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple)

#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)

#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)

#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
                                        _Override, _Final, _NoexceptSpec,      \
                                        _CallType, _RefSpec, _Signature)

#define GMOCK_INTERNAL_EXPAND(...)

// Valid modifiers.
#define GMOCK_INTERNAL_HAS_CONST(_Tuple)

#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple)

#define GMOCK_INTERNAL_HAS_FINAL(_Tuple)

#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple)

#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)

#define GMOCK_INTERNAL_GET_CALLTYPE_SPEC(_Tuple)

#define GMOCK_INTERNAL_CALLTYPE_SPEC_IF_CALLTYPE(_i, _, _elem)

#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple)

#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)

#ifdef GMOCK_INTERNAL_STRICT_SPEC_ASSERT
#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT
#else
#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)
#endif  // GMOCK_INTERNAL_STRICT_SPEC_ASSERT

// Modifiers implementation.
#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_CONST_I_const

#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override

#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_FINAL_I_final

#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept

#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_REF_I_ref

#define GMOCK_INTERNAL_UNPACK_ref(x)

#define GMOCK_INTERNAL_DETECT_CALLTYPE(_i, _, _elem)

#define GMOCK_INTERNAL_DETECT_CALLTYPE_I_Calltype

#define GMOCK_INTERNAL_UNPACK_Calltype(...)

// Note: The use of `identity_t` here allows _Ret to represent return types that
// would normally need to be specified in a different way. For example, a method
// returning a function pointer must be written as
//
// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
//
// But we only support placing the return type at the beginning. To handle this,
// we wrap all calls in identity_t, so that a declaration will be expanded to
//
// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
//
// This allows us to work around the syntactic oddities of function/method
// types.
#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)

#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)

#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)

#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _)

#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)

#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2)

#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _)

#define GMOCK_INTERNAL_ARG_O(_i, ...)

#define GMOCK_INTERNAL_MATCHER_O(_i, ...)

#define MOCK_METHOD0(m, ...)
#define MOCK_METHOD1(m, ...)
#define MOCK_METHOD2(m, ...)
#define MOCK_METHOD3(m, ...)
#define MOCK_METHOD4(m, ...)
#define MOCK_METHOD5(m, ...)
#define MOCK_METHOD6(m, ...)
#define MOCK_METHOD7(m, ...)
#define MOCK_METHOD8(m, ...)
#define MOCK_METHOD9(m, ...)
#define MOCK_METHOD10(m, ...)

#define MOCK_CONST_METHOD0(m, ...)
#define MOCK_CONST_METHOD1(m, ...)
#define MOCK_CONST_METHOD2(m, ...)
#define MOCK_CONST_METHOD3(m, ...)
#define MOCK_CONST_METHOD4(m, ...)
#define MOCK_CONST_METHOD5(m, ...)
#define MOCK_CONST_METHOD6(m, ...)
#define MOCK_CONST_METHOD7(m, ...)
#define MOCK_CONST_METHOD8(m, ...)
#define MOCK_CONST_METHOD9(m, ...)
#define MOCK_CONST_METHOD10(m, ...)

#define MOCK_METHOD0_T(m, ...)
#define MOCK_METHOD1_T(m, ...)
#define MOCK_METHOD2_T(m, ...)
#define MOCK_METHOD3_T(m, ...)
#define MOCK_METHOD4_T(m, ...)
#define MOCK_METHOD5_T(m, ...)
#define MOCK_METHOD6_T(m, ...)
#define MOCK_METHOD7_T(m, ...)
#define MOCK_METHOD8_T(m, ...)
#define MOCK_METHOD9_T(m, ...)
#define MOCK_METHOD10_T(m, ...)

#define MOCK_CONST_METHOD0_T(m, ...)
#define MOCK_CONST_METHOD1_T(m, ...)
#define MOCK_CONST_METHOD2_T(m, ...)
#define MOCK_CONST_METHOD3_T(m, ...)
#define MOCK_CONST_METHOD4_T(m, ...)
#define MOCK_CONST_METHOD5_T(m, ...)
#define MOCK_CONST_METHOD6_T(m, ...)
#define MOCK_CONST_METHOD7_T(m, ...)
#define MOCK_CONST_METHOD8_T(m, ...)
#define MOCK_CONST_METHOD9_T(m, ...)
#define MOCK_CONST_METHOD10_T(m, ...)

#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...)

#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...)

#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...)

#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...)
#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...)

#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...)

#define GMOCK_MOCKER_(arity, constness, Method)

#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_