14098f2015
Merge CONTRIBUTORS, delete LICENSEs in googletest/ and googlemock/ PiperOrigin-RevId: 352558822
150 lines
4.8 KiB
C++
150 lines
4.8 KiB
C++
// GOOGLETEST_CM0002 DO NOT DELETE
|
|
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
|
|
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
|
|
|
|
#include "gmock/internal/gmock-port.h"
|
|
#if GTEST_GOOGLE3_MODE_
|
|
|
|
#include <memory>
|
|
#include <type_traits>
|
|
|
|
#include "base/callback.h"
|
|
#include "gmock/gmock-actions.h"
|
|
|
|
namespace testing {
|
|
namespace internal {
|
|
|
|
// Implements the Invoke(callback) action.
|
|
template <typename CallbackType, typename Signature>
|
|
class InvokeCallbackAction;
|
|
|
|
template <typename CallbackType, typename R, typename... Args>
|
|
class InvokeCallbackAction<CallbackType, R(Args...)> {
|
|
public:
|
|
// The c'tor takes ownership of the callback.
|
|
explicit InvokeCallbackAction(CallbackType* callback) : callback_(callback) {
|
|
callback->CheckIsRepeatable(); // Makes sure the callback is permanent.
|
|
}
|
|
|
|
R operator()(Args... args) const {
|
|
return callback_->Run(std::forward<Args>(args)...);
|
|
}
|
|
|
|
private:
|
|
const std::shared_ptr<CallbackType> callback_;
|
|
};
|
|
|
|
// Implements the InvokeWithoutArgs(callback) action.
|
|
template <typename CallbackType>
|
|
class InvokeCallbackWithoutArgsAction {
|
|
const std::shared_ptr<CallbackType> callback_;
|
|
|
|
public:
|
|
// The c'tor takes ownership of the callback.
|
|
explicit InvokeCallbackWithoutArgsAction(CallbackType* callback)
|
|
: callback_(callback) {
|
|
callback->CheckIsRepeatable(); // Makes sure the callback is permanent.
|
|
}
|
|
|
|
template <typename... Args>
|
|
auto operator()(const Args&...) -> decltype(this->callback_->Run()) {
|
|
return callback_->Run();
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct TypeIdentity {
|
|
using type = T;
|
|
};
|
|
|
|
inline TypeIdentity<void()> CallbackSignatureImpl(Closure*);
|
|
template <typename R>
|
|
TypeIdentity<R()> CallbackSignatureImpl(ResultCallback<R>*);
|
|
|
|
template <typename... Args>
|
|
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback1<Args...>*);
|
|
template <typename R, typename... Args>
|
|
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback1<R, Args...>*);
|
|
|
|
template <typename... Args>
|
|
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback2<Args...>*);
|
|
template <typename R, typename... Args>
|
|
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback2<R, Args...>*);
|
|
|
|
template <typename... Args>
|
|
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback3<Args...>*);
|
|
template <typename R, typename... Args>
|
|
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback3<R, Args...>*);
|
|
|
|
template <typename... Args>
|
|
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback4<Args...>*);
|
|
template <typename R, typename... Args>
|
|
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback4<R, Args...>*);
|
|
|
|
template <typename... Args>
|
|
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback5<Args...>*);
|
|
template <typename R, typename... Args>
|
|
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback5<R, Args...>*);
|
|
|
|
template <typename T>
|
|
using CallbackSignature = typename decltype(
|
|
internal::CallbackSignatureImpl(std::declval<T*>()))::type;
|
|
|
|
// Specialization for protocol buffers.
|
|
// We support setting a proto2::Message, which doesn't have an assignment
|
|
// operator.
|
|
template <size_t N, typename A>
|
|
struct SetArgumentPointeeAction<
|
|
N, A,
|
|
typename std::enable_if<std::is_base_of<proto2::Message, A>::value>::type> {
|
|
A value;
|
|
|
|
template <typename... Args>
|
|
void operator()(const Args&... args) const {
|
|
::std::get<N>(std::tie(args...))->CopyFrom(value);
|
|
}
|
|
};
|
|
|
|
// Add Invoke overloads for google3 Callback types.
|
|
|
|
template <typename C, typename... Args,
|
|
typename = internal::CallbackSignature<C>>
|
|
auto InvokeArgument(C* cb, Args... args) -> decltype(cb->Run(args...)) {
|
|
return cb->Run(args...);
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
// Add Invoke overloads for google3 Callback types.
|
|
|
|
// Creates an action that invokes the given callback with the mock
|
|
// function's arguments. The action takes ownership of the callback
|
|
// and verifies that it's permanent.
|
|
//
|
|
// google3 doesn't support callbacks with more than 5
|
|
// arguments yet, so we only support invoking callbacks with up to
|
|
// 5 arguments.
|
|
|
|
template <typename Callback>
|
|
internal::InvokeCallbackAction<Callback, internal::CallbackSignature<Callback>>
|
|
Invoke(Callback* callback) {
|
|
return internal::InvokeCallbackAction<Callback,
|
|
internal::CallbackSignature<Callback>>(
|
|
callback);
|
|
}
|
|
|
|
// Creates an action that invokes the given callback with no argument.
|
|
// The action takes ownership of the callback and verifies that it's
|
|
// permanent.
|
|
template <typename Callback, typename = internal::CallbackSignature<Callback>>
|
|
internal::InvokeCallbackWithoutArgsAction<Callback> InvokeWithoutArgs(
|
|
Callback* callback) {
|
|
return internal::InvokeCallbackWithoutArgsAction<Callback>(callback);
|
|
}
|
|
|
|
} // namespace testing
|
|
|
|
#endif // GTEST_GOOGLE3_MODE_
|
|
|
|
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
|