GoogleTest - Google Testing and Mocking Framework (grpc protobuff依赖)
https://google.github.io/googletest/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2690 lines
105 KiB
2690 lines
105 KiB
// This file was GENERATED by a script. DO NOT EDIT BY HAND!!! |
|
|
|
// 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. |
|
// |
|
// Author: wan@google.com (Zhanyong Wan) |
|
|
|
// Google Mock - a framework for writing C++ mock classes. |
|
// |
|
// This file implements some commonly used variadic actions. |
|
|
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ |
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ |
|
|
|
#include <gmock/gmock-actions.h> |
|
#include <gmock/internal/gmock-port.h> |
|
|
|
namespace testing { |
|
namespace internal { |
|
|
|
// InvokeHelper<F> knows how to unpack an N-tuple and invoke an N-ary |
|
// function or method with the unpacked values, where F is a function |
|
// type that takes N arguments. |
|
template <typename Result, typename ArgumentTuple> |
|
class InvokeHelper; |
|
|
|
template <typename R> |
|
class InvokeHelper<R, ::std::tr1::tuple<> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<>&) { |
|
return function(); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<>&) { |
|
return (obj_ptr->*method_ptr)(); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, |
|
A3>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, |
|
A4>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5, A6>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args), get<5>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5, A6, A7>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, |
|
A7>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args), get<5>(args), get<6>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5, A6, A7, A8>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, |
|
A8>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5, A6, A7, A8, A9>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, |
|
A9>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args), |
|
get<8>(args)); |
|
} |
|
}; |
|
|
|
template <typename R, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9, |
|
typename A10> |
|
class InvokeHelper<R, ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9, |
|
A10> > { |
|
public: |
|
template <typename Function> |
|
static R Invoke(Function function, const ::std::tr1::tuple<A1, A2, A3, A4, |
|
A5, A6, A7, A8, A9, A10>& args) { |
|
using ::std::tr1::get; |
|
return function(get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), |
|
get<9>(args)); |
|
} |
|
|
|
template <class Class, typename MethodPtr> |
|
static R InvokeMethod(Class* obj_ptr, |
|
MethodPtr method_ptr, |
|
const ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, |
|
A9, A10>& args) { |
|
using ::std::tr1::get; |
|
return (obj_ptr->*method_ptr)(get<0>(args), get<1>(args), get<2>(args), |
|
get<3>(args), get<4>(args), get<5>(args), get<6>(args), get<7>(args), |
|
get<8>(args), get<9>(args)); |
|
} |
|
}; |
|
|
|
|
|
// Implements the Invoke(f) action. The template argument |
|
// FunctionImpl is the implementation type of f, which can be either a |
|
// function pointer or a functor. Invoke(f) can be used as an |
|
// Action<F> as long as f's type is compatible with F (i.e. f can be |
|
// assigned to a tr1::function<F>). |
|
template <typename FunctionImpl> |
|
class InvokeAction { |
|
public: |
|
// The c'tor makes a copy of function_impl (either a function |
|
// pointer or a functor). |
|
explicit InvokeAction(FunctionImpl function_impl) |
|
: function_impl_(function_impl) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args); |
|
} |
|
private: |
|
FunctionImpl function_impl_; |
|
}; |
|
|
|
// Implements the Invoke(object_ptr, &Class::Method) action. |
|
template <class Class, typename MethodPtr> |
|
class InvokeMethodAction { |
|
public: |
|
InvokeMethodAction(Class* obj_ptr, MethodPtr method_ptr) |
|
: obj_ptr_(obj_ptr), method_ptr_(method_ptr) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) const { |
|
return InvokeHelper<Result, ArgumentTuple>::InvokeMethod( |
|
obj_ptr_, method_ptr_, args); |
|
} |
|
private: |
|
Class* const obj_ptr_; |
|
const MethodPtr method_ptr_; |
|
}; |
|
|
|
// A ReferenceWrapper<T> object represents a reference to type T, |
|
// which can be either const or not. It can be explicitly converted |
|
// from, and implicitly converted to, a T&. Unlike a reference, |
|
// ReferenceWrapper<T> can be copied and can survive template type |
|
// inference. This is used to support by-reference arguments in the |
|
// InvokeArgument<N>(...) action. The idea was from "reference |
|
// wrappers" in tr1, which we don't have in our source tree yet. |
|
template <typename T> |
|
class ReferenceWrapper { |
|
public: |
|
// Constructs a ReferenceWrapper<T> object from a T&. |
|
explicit ReferenceWrapper(T& l_value) : pointer_(&l_value) {} // NOLINT |
|
|
|
// Allows a ReferenceWrapper<T> object to be implicitly converted to |
|
// a T&. |
|
operator T&() const { return *pointer_; } |
|
private: |
|
T* pointer_; |
|
}; |
|
|
|
// CallableHelper has static methods for invoking "callables", |
|
// i.e. function pointers and functors. It uses overloading to |
|
// provide a uniform interface for invoking different kinds of |
|
// callables. In particular, you can use: |
|
// |
|
// CallableHelper<R>::Call(callable, a1, a2, ..., an) |
|
// |
|
// to invoke an n-ary callable, where R is its return type. If an |
|
// argument, say a2, needs to be passed by reference, you should write |
|
// ByRef(a2) instead of a2 in the above expression. |
|
template <typename R> |
|
class CallableHelper { |
|
public: |
|
// Calls a nullary callable. |
|
template <typename Function> |
|
static R Call(Function function) { return function(); } |
|
|
|
// Calls a unary callable. |
|
|
|
// We deliberately pass a1 by value instead of const reference here |
|
// in case it is a C-string literal. If we had declared the |
|
// parameter as 'const A1& a1' and write Call(function, "Hi"), the |
|
// compiler would've thought A1 is 'char[3]', which causes trouble |
|
// when you need to copy a value of type A1. By declaring the |
|
// parameter as 'A1 a1', the compiler will correctly infer that A1 |
|
// is 'const char*' when it sees Call(function, "Hi"). |
|
// |
|
// Since this function is defined inline, the compiler can get rid |
|
// of the copying of the arguments. Therefore the performance won't |
|
// be hurt. |
|
template <typename Function, typename A1> |
|
static R Call(Function function, A1 a1) { return function(a1); } |
|
|
|
// Calls a binary callable. |
|
template <typename Function, typename A1, typename A2> |
|
static R Call(Function function, A1 a1, A2 a2) { |
|
return function(a1, a2); |
|
} |
|
|
|
// Calls a ternary callable. |
|
template <typename Function, typename A1, typename A2, typename A3> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3) { |
|
return function(a1, a2, a3); |
|
} |
|
|
|
// Calls a 4-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4) { |
|
return function(a1, a2, a3, a4); |
|
} |
|
|
|
// Calls a 5-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { |
|
return function(a1, a2, a3, a4, a5); |
|
} |
|
|
|
// Calls a 6-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5, typename A6> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { |
|
return function(a1, a2, a3, a4, a5, a6); |
|
} |
|
|
|
// Calls a 7-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5, typename A6, typename A7> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, |
|
A7 a7) { |
|
return function(a1, a2, a3, a4, a5, a6, a7); |
|
} |
|
|
|
// Calls a 8-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5, typename A6, typename A7, typename A8> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, |
|
A7 a7, A8 a8) { |
|
return function(a1, a2, a3, a4, a5, a6, a7, a8); |
|
} |
|
|
|
// Calls a 9-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5, typename A6, typename A7, typename A8, |
|
typename A9> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, |
|
A7 a7, A8 a8, A9 a9) { |
|
return function(a1, a2, a3, a4, a5, a6, a7, a8, a9); |
|
} |
|
|
|
// Calls a 10-ary callable. |
|
template <typename Function, typename A1, typename A2, typename A3, |
|
typename A4, typename A5, typename A6, typename A7, typename A8, |
|
typename A9, typename A10> |
|
static R Call(Function function, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, |
|
A7 a7, A8 a8, A9 a9, A10 a10) { |
|
return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); |
|
} |
|
|
|
}; // class CallableHelper |
|
|
|
// Invokes a nullary callable argument. |
|
template <size_t N> |
|
class InvokeArgumentAction0 { |
|
public: |
|
template <typename Result, typename ArgumentTuple> |
|
static Result Perform(const ArgumentTuple& args) { |
|
return CallableHelper<Result>::Call(::std::tr1::get<N>(args)); |
|
} |
|
}; |
|
|
|
// Invokes a unary callable argument with the given argument. |
|
template <size_t N, typename A1> |
|
class InvokeArgumentAction1 { |
|
public: |
|
// We deliberately pass a1 by value instead of const reference here |
|
// in case it is a C-string literal. |
|
// |
|
// Since this function is defined inline, the compiler can get rid |
|
// of the copying of the arguments. Therefore the performance won't |
|
// be hurt. |
|
explicit InvokeArgumentAction1(A1 a1) : arg1_(a1) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
}; |
|
|
|
// Invokes a binary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2> |
|
class InvokeArgumentAction2 { |
|
public: |
|
InvokeArgumentAction2(A1 a1, A2 a2) : |
|
arg1_(a1), arg2_(a2) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
}; |
|
|
|
// Invokes a ternary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3> |
|
class InvokeArgumentAction3 { |
|
public: |
|
InvokeArgumentAction3(A1 a1, A2 a2, A3 a3) : |
|
arg1_(a1), arg2_(a2), arg3_(a3) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_, |
|
arg3_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
}; |
|
|
|
// Invokes a 4-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4> |
|
class InvokeArgumentAction4 { |
|
public: |
|
InvokeArgumentAction4(A1 a1, A2 a2, A3 a3, A4 a4) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
return CallableHelper<Result>::Call(::std::tr1::get<N>(args), arg1_, arg2_, |
|
arg3_, arg4_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
}; |
|
|
|
// Invokes a 5-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
class InvokeArgumentAction5 { |
|
public: |
|
InvokeArgumentAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
}; |
|
|
|
// Invokes a 6-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
class InvokeArgumentAction6 { |
|
public: |
|
InvokeArgumentAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
}; |
|
|
|
// Invokes a 7-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
class InvokeArgumentAction7 { |
|
public: |
|
InvokeArgumentAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), |
|
arg7_(a7) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
}; |
|
|
|
// Invokes a 8-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
class InvokeArgumentAction8 { |
|
public: |
|
InvokeArgumentAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, |
|
A8 a8) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), |
|
arg7_(a7), arg8_(a8) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
}; |
|
|
|
// Invokes a 9-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
class InvokeArgumentAction9 { |
|
public: |
|
InvokeArgumentAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, |
|
A9 a9) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), |
|
arg7_(a7), arg8_(a8), arg9_(a9) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, |
|
arg9_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
const A9 arg9_; |
|
}; |
|
|
|
// Invokes a 10-ary callable argument with the given arguments. |
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9, |
|
typename A10> |
|
class InvokeArgumentAction10 { |
|
public: |
|
InvokeArgumentAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, |
|
A8 a8, A9 a9, A10 a10) : |
|
arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6), |
|
arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& args) { |
|
// We extract the callable to a variable before invoking it, in |
|
// case it is a functor passed by value and its operator() is not |
|
// const. |
|
typename ::std::tr1::tuple_element<N, ArgumentTuple>::type function = |
|
::std::tr1::get<N>(args); |
|
return function(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, |
|
arg9_, arg10_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
const A9 arg9_; |
|
const A10 arg10_; |
|
}; |
|
|
|
// An INTERNAL macro for extracting the type of a tuple field. It's |
|
// subject to change without notice - DO NOT USE IN USER CODE! |
|
#define GMOCK_FIELD_(Tuple, N) \ |
|
typename ::std::tr1::tuple_element<N, Tuple>::type |
|
|
|
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::type is the |
|
// type of an n-ary function whose i-th (1-based) argument type is the |
|
// k{i}-th (0-based) field of ArgumentTuple, which must be a tuple |
|
// type, and whose return type is Result. For example, |
|
// SelectArgs<int, ::std::tr1::tuple<bool, char, double, long>, 0, 3>::type |
|
// is int(bool, long). |
|
// |
|
// SelectArgs<Result, ArgumentTuple, k1, k2, ..., k_n>::Select(args) |
|
// returns the selected fields (k1, k2, ..., k_n) of args as a tuple. |
|
// For example, |
|
// SelectArgs<int, ::std::tr1::tuple<bool, char, double>, 2, 0>::Select( |
|
// ::std::tr1::make_tuple(true, 'a', 2.5)) |
|
// returns ::std::tr1::tuple (2.5, true). |
|
// |
|
// The numbers in list k1, k2, ..., k_n must be >= 0, where n can be |
|
// in the range [0, 10]. Duplicates are allowed and they don't have |
|
// to be in an ascending or descending order. |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5, int k6, int k7, int k8, int k9, int k10> |
|
class SelectArgs { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), |
|
GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), |
|
GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9), |
|
GMOCK_FIELD_(ArgumentTuple, k10)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), |
|
get<k8>(args), get<k9>(args), get<k10>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
class SelectArgs<Result, ArgumentTuple, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& /* args */) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, -1, -1, -1, -1, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, -1, -1, -1, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, -1, -1, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, -1, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, -1, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5, int k6> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, k6, -1, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), |
|
GMOCK_FIELD_(ArgumentTuple, k6)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args), get<k6>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5, int k6, int k7> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, k6, k7, -1, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), |
|
GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5, int k6, int k7, int k8> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, k6, k7, k8, -1, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), |
|
GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), |
|
GMOCK_FIELD_(ArgumentTuple, k8)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), |
|
get<k8>(args)); |
|
} |
|
}; |
|
|
|
template <typename Result, typename ArgumentTuple, int k1, int k2, int k3, |
|
int k4, int k5, int k6, int k7, int k8, int k9> |
|
class SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, k6, k7, k8, k9, -1> { |
|
public: |
|
typedef Result type(GMOCK_FIELD_(ArgumentTuple, k1), |
|
GMOCK_FIELD_(ArgumentTuple, k2), GMOCK_FIELD_(ArgumentTuple, k3), |
|
GMOCK_FIELD_(ArgumentTuple, k4), GMOCK_FIELD_(ArgumentTuple, k5), |
|
GMOCK_FIELD_(ArgumentTuple, k6), GMOCK_FIELD_(ArgumentTuple, k7), |
|
GMOCK_FIELD_(ArgumentTuple, k8), GMOCK_FIELD_(ArgumentTuple, k9)); |
|
typedef typename Function<type>::ArgumentTuple SelectedArgs; |
|
static SelectedArgs Select(const ArgumentTuple& args) { |
|
using ::std::tr1::get; |
|
return SelectedArgs(get<k1>(args), get<k2>(args), get<k3>(args), |
|
get<k4>(args), get<k5>(args), get<k6>(args), get<k7>(args), |
|
get<k8>(args), get<k9>(args)); |
|
} |
|
}; |
|
|
|
#undef GMOCK_FIELD_ |
|
|
|
// Implements the WithArgs action. |
|
template <typename InnerAction, int k1 = -1, int k2 = -1, int k3 = -1, |
|
int k4 = -1, int k5 = -1, int k6 = -1, int k7 = -1, int k8 = -1, |
|
int k9 = -1, int k10 = -1> |
|
class WithArgsAction { |
|
public: |
|
explicit WithArgsAction(const InnerAction& action) : action_(action) {} |
|
|
|
template <typename F> |
|
operator Action<F>() const { return MakeAction(new Impl<F>(action_)); } |
|
|
|
private: |
|
template <typename F> |
|
class Impl : public ActionInterface<F> { |
|
public: |
|
typedef typename Function<F>::Result Result; |
|
typedef typename Function<F>::ArgumentTuple ArgumentTuple; |
|
|
|
explicit Impl(const InnerAction& action) : action_(action) {} |
|
|
|
virtual Result Perform(const ArgumentTuple& args) { |
|
return action_.Perform(SelectArgs<Result, ArgumentTuple, k1, k2, k3, k4, |
|
k5, k6, k7, k8, k9, k10>::Select(args)); |
|
} |
|
|
|
private: |
|
typedef typename SelectArgs<Result, ArgumentTuple, |
|
k1, k2, k3, k4, k5, k6, k7, k8, k9, k10>::type InnerFunctionType; |
|
|
|
Action<InnerFunctionType> action_; |
|
}; |
|
|
|
const InnerAction action_; |
|
}; |
|
|
|
// Does two actions sequentially. Used for implementing the DoAll(a1, |
|
// a2, ...) action. |
|
template <typename Action1, typename Action2> |
|
class DoBothAction { |
|
public: |
|
DoBothAction(Action1 action1, Action2 action2) |
|
: action1_(action1), action2_(action2) {} |
|
|
|
// This template type conversion operator allows DoAll(a1, ..., a_n) |
|
// to be used in ANY function of compatible type. |
|
template <typename F> |
|
operator Action<F>() const { |
|
return Action<F>(new Impl<F>(action1_, action2_)); |
|
} |
|
|
|
private: |
|
// Implements the DoAll(...) action for a particular function type F. |
|
template <typename F> |
|
class Impl : public ActionInterface<F> { |
|
public: |
|
typedef typename Function<F>::Result Result; |
|
typedef typename Function<F>::ArgumentTuple ArgumentTuple; |
|
typedef typename Function<F>::MakeResultVoid VoidResult; |
|
|
|
Impl(const Action<VoidResult>& action1, const Action<F>& action2) |
|
: action1_(action1), action2_(action2) {} |
|
|
|
virtual Result Perform(const ArgumentTuple& args) { |
|
action1_.Perform(args); |
|
return action2_.Perform(args); |
|
} |
|
|
|
private: |
|
const Action<VoidResult> action1_; |
|
const Action<F> action2_; |
|
}; |
|
|
|
Action1 action1_; |
|
Action2 action2_; |
|
}; |
|
|
|
// A macro from the ACTION* family (defined later in this file) |
|
// defines an action that can be used in a mock function. Typically, |
|
// these actions only care about a subset of the arguments of the mock |
|
// function. For example, if such an action only uses the second |
|
// argument, it can be used in any mock function that takes >= 2 |
|
// arguments where the type of the second argument is compatible. |
|
// |
|
// Therefore, the action implementation must be prepared to take more |
|
// arguments than it needs. The ExcessiveArg type is used to |
|
// represent those excessive arguments. In order to keep the compiler |
|
// error messages tractable, we define it in the testing namespace |
|
// instead of testing::internal. However, this is an INTERNAL TYPE |
|
// and subject to change without notice, so a user MUST NOT USE THIS |
|
// TYPE DIRECTLY. |
|
struct ExcessiveArg {}; |
|
|
|
// A helper class needed for implementing the ACTION* macros. |
|
template <typename Result, class Impl> |
|
class ActionHelper { |
|
public: |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<>(args, ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0>(args, get<0>(args), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1>(args, get<0>(args), |
|
get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2>(args, get<0>(args), |
|
get<1>(args), get<2>(args), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, |
|
A3>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3>(args, get<0>(args), |
|
get<1>(args), get<2>(args), get<3>(args), ExcessiveArg(), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, |
|
A4>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4>(args, |
|
get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), |
|
ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4, |
|
A5>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5>(args, |
|
get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), |
|
get<5>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4, |
|
A5, A6>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6>(args, |
|
get<0>(args), get<1>(args), get<2>(args), get<3>(args), get<4>(args), |
|
get<5>(args), get<6>(args), ExcessiveArg(), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4, |
|
A5, A6, A7>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, |
|
A7>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args), ExcessiveArg(), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4, |
|
A5, A6, A7, A8>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, |
|
A8>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), |
|
ExcessiveArg()); |
|
} |
|
|
|
template <typename A0, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
static Result Perform(Impl* impl, const ::std::tr1::tuple<A0, A1, A2, A3, A4, |
|
A5, A6, A7, A8, A9>& args) { |
|
using ::std::tr1::get; |
|
return impl->template gmock_PerformImpl<A0, A1, A2, A3, A4, A5, A6, A7, A8, |
|
A9>(args, get<0>(args), get<1>(args), get<2>(args), get<3>(args), |
|
get<4>(args), get<5>(args), get<6>(args), get<7>(args), get<8>(args), |
|
get<9>(args)); |
|
} |
|
}; |
|
|
|
} // namespace internal |
|
|
|
// Various overloads for Invoke(). |
|
|
|
// Creates an action that invokes 'function_impl' with the mock |
|
// function's arguments. |
|
template <typename FunctionImpl> |
|
PolymorphicAction<internal::InvokeAction<FunctionImpl> > Invoke( |
|
FunctionImpl function_impl) { |
|
return MakePolymorphicAction( |
|
internal::InvokeAction<FunctionImpl>(function_impl)); |
|
} |
|
|
|
// Creates an action that invokes the given method on the given object |
|
// with the mock function's arguments. |
|
template <class Class, typename MethodPtr> |
|
PolymorphicAction<internal::InvokeMethodAction<Class, MethodPtr> > Invoke( |
|
Class* obj_ptr, MethodPtr method_ptr) { |
|
return MakePolymorphicAction( |
|
internal::InvokeMethodAction<Class, MethodPtr>(obj_ptr, method_ptr)); |
|
} |
|
|
|
// Creates a reference wrapper for the given L-value. If necessary, |
|
// you can explicitly specify the type of the reference. For example, |
|
// suppose 'derived' is an object of type Derived, ByRef(derived) |
|
// would wrap a Derived&. If you want to wrap a const Base& instead, |
|
// where Base is a base class of Derived, just write: |
|
// |
|
// ByRef<const Base>(derived) |
|
template <typename T> |
|
inline internal::ReferenceWrapper<T> ByRef(T& l_value) { // NOLINT |
|
return internal::ReferenceWrapper<T>(l_value); |
|
} |
|
|
|
// Various overloads for InvokeArgument<N>(). |
|
// |
|
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th |
|
// (0-based) argument, which must be a k-ary callable, of the mock |
|
// function, with arguments a1, a2, ..., a_k. |
|
// |
|
// Notes: |
|
// |
|
// 1. The arguments are passed by value by default. If you need to |
|
// pass an argument by reference, wrap it inside ByRef(). For |
|
// example, |
|
// |
|
// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) |
|
// |
|
// passes 5 and string("Hello") by value, and passes foo by |
|
// reference. |
|
// |
|
// 2. If the callable takes an argument by reference but ByRef() is |
|
// not used, it will receive the reference to a copy of the value, |
|
// instead of the original value. For example, when the 0-th |
|
// argument of the mock function takes a const string&, the action |
|
// |
|
// InvokeArgument<0>(string("Hello")) |
|
// |
|
// makes a copy of the temporary string("Hello") object and passes a |
|
// reference of the copy, instead of the original temporary object, |
|
// to the callable. This makes it easy for a user to define an |
|
// InvokeArgument action from temporary values and have it performed |
|
// later. |
|
template <size_t N> |
|
inline PolymorphicAction<internal::InvokeArgumentAction0<N> > InvokeArgument() { |
|
return MakePolymorphicAction(internal::InvokeArgumentAction0<N>()); |
|
} |
|
|
|
// We deliberately pass a1 by value instead of const reference here in |
|
// case it is a C-string literal. If we had declared the parameter as |
|
// 'const A1& a1' and write InvokeArgument<0>("Hi"), the compiler |
|
// would've thought A1 is 'char[3]', which causes trouble as the |
|
// implementation needs to copy a value of type A1. By declaring the |
|
// parameter as 'A1 a1', the compiler will correctly infer that A1 is |
|
// 'const char*' when it sees InvokeArgument<0>("Hi"). |
|
// |
|
// Since this function is defined inline, the compiler can get rid of |
|
// the copying of the arguments. Therefore the performance won't be |
|
// hurt. |
|
template <size_t N, typename A1> |
|
inline PolymorphicAction<internal::InvokeArgumentAction1<N, A1> > |
|
InvokeArgument(A1 a1) { |
|
return MakePolymorphicAction(internal::InvokeArgumentAction1<N, A1>(a1)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2> |
|
inline PolymorphicAction<internal::InvokeArgumentAction2<N, A1, A2> > |
|
InvokeArgument(A1 a1, A2 a2) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction2<N, A1, A2>(a1, a2)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3> |
|
inline PolymorphicAction<internal::InvokeArgumentAction3<N, A1, A2, A3> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction3<N, A1, A2, A3>(a1, a2, a3)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4> |
|
inline PolymorphicAction<internal::InvokeArgumentAction4<N, A1, A2, A3, A4> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction4<N, A1, A2, A3, A4>(a1, a2, a3, a4)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
inline PolymorphicAction<internal::InvokeArgumentAction5<N, A1, A2, A3, A4, |
|
A5> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction5<N, A1, A2, A3, A4, A5>(a1, a2, a3, a4, |
|
a5)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
inline PolymorphicAction<internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5, |
|
A6> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction6<N, A1, A2, A3, A4, A5, A6>(a1, a2, a3, |
|
a4, a5, a6)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
inline PolymorphicAction<internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5, |
|
A6, A7> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction7<N, A1, A2, A3, A4, A5, A6, A7>(a1, a2, |
|
a3, a4, a5, a6, a7)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
inline PolymorphicAction<internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5, |
|
A6, A7, A8> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction8<N, A1, A2, A3, A4, A5, A6, A7, A8>(a1, |
|
a2, a3, a4, a5, a6, a7, a8)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
inline PolymorphicAction<internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5, |
|
A6, A7, A8, A9> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction9<N, A1, A2, A3, A4, A5, A6, A7, A8, |
|
A9>(a1, a2, a3, a4, a5, a6, a7, a8, a9)); |
|
} |
|
|
|
template <size_t N, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9, |
|
typename A10> |
|
inline PolymorphicAction<internal::InvokeArgumentAction10<N, A1, A2, A3, A4, |
|
A5, A6, A7, A8, A9, A10> > |
|
InvokeArgument(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, |
|
A10 a10) { |
|
return MakePolymorphicAction( |
|
internal::InvokeArgumentAction10<N, A1, A2, A3, A4, A5, A6, A7, A8, A9, |
|
A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); |
|
} |
|
|
|
// WithoutArgs(inner_action) can be used in a mock function with a |
|
// non-empty argument list to perform inner_action, which takes no |
|
// argument. In other words, it adapts an action accepting no |
|
// argument to one that accepts (and ignores) arguments. |
|
template <typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction> |
|
WithoutArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction>(action); |
|
} |
|
|
|
// WithArg<k>(an_action) creates an action that passes the k-th |
|
// (0-based) argument of the mock function to an_action and performs |
|
// it. It adapts an action accepting one argument to one that accepts |
|
// multiple arguments. For convenience, we also provide |
|
// WithArgs<k>(an_action) (defined below) as a synonym. |
|
template <int k, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k> |
|
WithArg(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k>(action); |
|
} |
|
|
|
// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes |
|
// the selected arguments of the mock function to an_action and |
|
// performs it. It serves as an adaptor between actions with |
|
// different argument lists. C++ doesn't support default arguments for |
|
// function templates, so we have to overload it. |
|
template <int k1, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1>(action); |
|
} |
|
|
|
template <int k1, int k2, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, int k6, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, |
|
typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, |
|
k7>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, |
|
typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, |
|
k8>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, |
|
int k9, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, k9> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, |
|
k9>(action); |
|
} |
|
|
|
template <int k1, int k2, int k3, int k4, int k5, int k6, int k7, int k8, |
|
int k9, int k10, typename InnerAction> |
|
inline internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, |
|
k9, k10> |
|
WithArgs(const InnerAction& action) { |
|
return internal::WithArgsAction<InnerAction, k1, k2, k3, k4, k5, k6, k7, k8, |
|
k9, k10>(action); |
|
} |
|
|
|
// Creates an action that does actions a1, a2, ..., sequentially in |
|
// each invocation. |
|
template <typename Action1, typename Action2> |
|
inline internal::DoBothAction<Action1, Action2> |
|
DoAll(Action1 a1, Action2 a2) { |
|
return internal::DoBothAction<Action1, Action2>(a1, a2); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
Action3> > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3) { |
|
return DoAll(a1, DoAll(a2, a3)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, Action4> > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4) { |
|
return DoAll(a1, DoAll(a2, a3, a4)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
Action5> > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5, typename Action6> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
internal::DoBothAction<Action5, Action6> > > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5, a6)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5, typename Action6, typename Action7> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
internal::DoBothAction<Action5, internal::DoBothAction<Action6, |
|
Action7> > > > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, |
|
Action7 a7) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5, typename Action6, typename Action7, |
|
typename Action8> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
internal::DoBothAction<Action5, internal::DoBothAction<Action6, |
|
internal::DoBothAction<Action7, Action8> > > > > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, |
|
Action7 a7, Action8 a8) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5, typename Action6, typename Action7, |
|
typename Action8, typename Action9> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
internal::DoBothAction<Action5, internal::DoBothAction<Action6, |
|
internal::DoBothAction<Action7, internal::DoBothAction<Action8, |
|
Action9> > > > > > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, |
|
Action7 a7, Action8 a8, Action9 a9) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9)); |
|
} |
|
|
|
template <typename Action1, typename Action2, typename Action3, |
|
typename Action4, typename Action5, typename Action6, typename Action7, |
|
typename Action8, typename Action9, typename Action10> |
|
inline internal::DoBothAction<Action1, internal::DoBothAction<Action2, |
|
internal::DoBothAction<Action3, internal::DoBothAction<Action4, |
|
internal::DoBothAction<Action5, internal::DoBothAction<Action6, |
|
internal::DoBothAction<Action7, internal::DoBothAction<Action8, |
|
internal::DoBothAction<Action9, Action10> > > > > > > > > |
|
DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6, |
|
Action7 a7, Action8 a8, Action9 a9, Action10 a10) { |
|
return DoAll(a1, DoAll(a2, a3, a4, a5, a6, a7, a8, a9, a10)); |
|
} |
|
|
|
} // namespace testing |
|
|
|
// The ACTION* family of macros can be used in a namespace scope to |
|
// define custom actions easily. The syntax: |
|
// |
|
// ACTION(name) { statements; } |
|
// |
|
// will define an action with the given name that executes the |
|
// statements. The value returned by the statements will be used as |
|
// the return value of the action. Inside the statements, you can |
|
// refer to the K-th (0-based) argument of the mock function by |
|
// 'argK', and refer to its type by 'argK_type'. For example: |
|
// |
|
// ACTION(IncrementArg1) { |
|
// arg1_type temp = arg1; |
|
// return ++(*temp); |
|
// } |
|
// |
|
// allows you to write |
|
// |
|
// ...WillOnce(IncrementArg1()); |
|
// |
|
// You can also refer to the entire argument tuple and its type by |
|
// 'args' and 'args_type', and refer to the mock function type and its |
|
// return type by 'function_type' and 'return_type'. |
|
// |
|
// Note that you don't need to specify the types of the mock function |
|
// arguments. However rest assured that your code is still type-safe: |
|
// you'll get a compiler error if *arg1 doesn't support the ++ |
|
// operator, or if the type of ++(*arg1) isn't compatible with the |
|
// mock function's return type, for example. |
|
// |
|
// Sometimes you'll want to parameterize the action. For that you can use |
|
// another macro: |
|
// |
|
// ACTION_P(name, param_name) { statements; } |
|
// |
|
// For example: |
|
// |
|
// ACTION_P(Add, n) { return arg0 + n; } |
|
// |
|
// will allow you to write: |
|
// |
|
// ...WillOnce(Add(5)); |
|
// |
|
// Note that you don't need to provide the type of the parameter |
|
// either. If you need to reference the type of a parameter named |
|
// 'foo', you can write 'foo_type'. For example, in the body of |
|
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type |
|
// of 'n'. |
|
// |
|
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support |
|
// multi-parameter actions. |
|
// |
|
// For the purpose of typing, you can view |
|
// |
|
// ACTION_Pk(Foo, p1, ..., pk) { ... } |
|
// |
|
// as shorthand for |
|
// |
|
// template <typename p1_type, ..., typename pk_type> |
|
// FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } |
|
// |
|
// In particular, you can provide the template type arguments |
|
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); |
|
// although usually you can rely on the compiler to infer the types |
|
// for you automatically. You can assign the result of expression |
|
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., |
|
// pk_type>. This can be useful when composing actions. |
|
// |
|
// You can also overload actions with different numbers of parameters: |
|
// |
|
// ACTION_P(Plus, a) { ... } |
|
// ACTION_P2(Plus, a, b) { ... } |
|
// |
|
// While it's tempting to always use the ACTION* macros when defining |
|
// a new action, you should also consider implementing ActionInterface |
|
// or using MakePolymorphicAction() instead, especially if you need to |
|
// use the action a lot. While these approaches require more work, |
|
// they give you more control on the types of the mock function |
|
// arguments and the action parameters, which in general leads to |
|
// better compiler error messages that pay off in the long run. They |
|
// also allow overloading actions based on parameter types (as opposed |
|
// to just based on the number of parameters). |
|
// |
|
// CAVEAT: |
|
// |
|
// ACTION*() can only be used in a namespace scope. The reason is |
|
// that C++ doesn't yet allow function-local types to be used to |
|
// instantiate templates. The up-coming C++0x standard will fix this. |
|
// Once that's done, we'll consider supporting using ACTION*() inside |
|
// a function. |
|
// |
|
// MORE INFORMATION: |
|
// |
|
// To learn more about using these macros, please search for 'ACTION' |
|
// on http://code.google.com/p/googlemock/wiki/CookBook. |
|
|
|
// An internal macro needed for implementing ACTION*(). |
|
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ |
|
const args_type& args GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg0_type arg0 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg1_type arg1 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg2_type arg2 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg3_type arg3 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg4_type arg4 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg5_type arg5 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg6_type arg6 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg7_type arg7 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg8_type arg8 GTEST_ATTRIBUTE_UNUSED_,\ |
|
arg9_type arg9 GTEST_ATTRIBUTE_UNUSED_ |
|
|
|
#define ACTION(name)\ |
|
class name##Action {\ |
|
public:\ |
|
name##Action() {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl() {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>());\ |
|
}\ |
|
};\ |
|
inline name##Action name() {\ |
|
return name##Action();\ |
|
}\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##Action::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P(name, p0)\ |
|
template <typename p0##_type>\ |
|
class name##ActionP {\ |
|
public:\ |
|
name##ActionP(p0##_type gmock_p0) : p0(gmock_p0) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
explicit gmock_Impl(p0##_type gmock_p0) : p0(gmock_p0) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0));\ |
|
}\ |
|
p0##_type p0;\ |
|
};\ |
|
template <typename p0##_type>\ |
|
inline name##ActionP<p0##_type> name(p0##_type p0) {\ |
|
return name##ActionP<p0##_type>(p0);\ |
|
}\ |
|
template <typename p0##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP<p0##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P2(name, p0, p1)\ |
|
template <typename p0##_type, typename p1##_type>\ |
|
class name##ActionP2 {\ |
|
public:\ |
|
name##ActionP2(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ |
|
p1(gmock_p1) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1) : p0(gmock_p0), \ |
|
p1(gmock_p1) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type>\ |
|
inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \ |
|
p1##_type p1) {\ |
|
return name##ActionP2<p0##_type, p1##_type>(p0, p1);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP2<p0##_type, p1##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P3(name, p0, p1, p2)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
|
class name##ActionP3 {\ |
|
public:\ |
|
name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
|
inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \ |
|
p1##_type p1, p2##_type p2) {\ |
|
return name##ActionP3<p0##_type, p1##_type, p2##_type>(p0, p1, p2);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP3<p0##_type, p1##_type, \ |
|
p2##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P4(name, p0, p1, p2, p3)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type>\ |
|
class name##ActionP4 {\ |
|
public:\ |
|
name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), \ |
|
p2(gmock_p2), p3(gmock_p3) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type>\ |
|
inline name##ActionP4<p0##_type, p1##_type, p2##_type, \ |
|
p3##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ |
|
p3##_type p3) {\ |
|
return name##ActionP4<p0##_type, p1##_type, p2##_type, p3##_type>(p0, p1, \ |
|
p2, p3);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP4<p0##_type, p1##_type, p2##_type, \ |
|
p3##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P5(name, p0, p1, p2, p3, p4)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type>\ |
|
class name##ActionP5 {\ |
|
public:\ |
|
name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, \ |
|
p4##_type gmock_p4) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4) : p0(gmock_p0), \ |
|
p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type>\ |
|
inline name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
|
p4##_type p4) {\ |
|
return name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type>(p0, p1, p2, p3, p4);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP5<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type>\ |
|
class name##ActionP6 {\ |
|
public:\ |
|
name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type>\ |
|
inline name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, \ |
|
p3##_type p3, p4##_type p4, p5##_type p5) {\ |
|
return name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type>(p0, p1, p2, p3, p4, p5);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP6<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
|
p5##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type>\ |
|
class name##ActionP7 {\ |
|
public:\ |
|
name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5, p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), \ |
|
p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), \ |
|
p6(gmock_p6) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
|
p6##_type gmock_p6) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ |
|
p6));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type>\ |
|
inline name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type> name(p0##_type p0, p1##_type p1, \ |
|
p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ |
|
p6##_type p6) {\ |
|
return name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type>(p0, p1, p2, p3, p4, p5, p6);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP7<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
|
p5##_type, p6##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type>\ |
|
class name##ActionP8 {\ |
|
public:\ |
|
name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5, p6##_type gmock_p6, \ |
|
p7##_type gmock_p7) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ |
|
p7(gmock_p7) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
|
p6##_type gmock_p6, p7##_type gmock_p7) : p0(gmock_p0), \ |
|
p1(gmock_p1), p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), \ |
|
p5(gmock_p5), p6(gmock_p6), p7(gmock_p7) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ |
|
p6, p7));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type>\ |
|
inline name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type> name(p0##_type p0, \ |
|
p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ |
|
p6##_type p6, p7##_type p7) {\ |
|
return name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type>(p0, p1, p2, p3, p4, p5, \ |
|
p6, p7);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP8<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
|
p5##_type, p6##_type, \ |
|
p7##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type>\ |
|
class name##ActionP9 {\ |
|
public:\ |
|
name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ |
|
p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), p7(gmock_p7), \ |
|
p8(gmock_p8) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
|
p6##_type gmock_p6, p7##_type gmock_p7, \ |
|
p8##_type gmock_p8) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ |
|
p7(gmock_p7), p8(gmock_p8) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
p8##_type p8;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ |
|
p6, p7, p8));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
p8##_type p8;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type>\ |
|
inline name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type, \ |
|
p8##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
|
p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ |
|
p8##_type p8) {\ |
|
return name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type>(p0, p1, p2, \ |
|
p3, p4, p5, p6, p7, p8);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP9<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
|
p5##_type, p6##_type, p7##_type, \ |
|
p8##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type, \ |
|
typename p9##_type>\ |
|
class name##ActionP10 {\ |
|
public:\ |
|
name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \ |
|
p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ |
|
p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ |
|
p8##_type gmock_p8, p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), \ |
|
p2(gmock_p2), p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ |
|
p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\ |
|
template <typename F>\ |
|
class gmock_Impl : public ::testing::ActionInterface<F> {\ |
|
public:\ |
|
typedef F function_type;\ |
|
typedef typename ::testing::internal::Function<F>::Result return_type;\ |
|
typedef typename ::testing::internal::Function<F>::ArgumentTuple\ |
|
args_type;\ |
|
gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ |
|
p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ |
|
p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ |
|
p9##_type gmock_p9) : p0(gmock_p0), p1(gmock_p1), p2(gmock_p2), \ |
|
p3(gmock_p3), p4(gmock_p4), p5(gmock_p5), p6(gmock_p6), \ |
|
p7(gmock_p7), p8(gmock_p8), p9(gmock_p9) {}\ |
|
virtual return_type Perform(const args_type& args) {\ |
|
return ::testing::internal::ActionHelper<return_type, gmock_Impl>::\ |
|
Perform(this, args);\ |
|
}\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
return_type gmock_PerformImpl(const args_type& args, arg0_type arg0, \ |
|
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \ |
|
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \ |
|
arg9_type arg9) const;\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
p8##_type p8;\ |
|
p9##_type p9;\ |
|
};\ |
|
template <typename F> operator ::testing::Action<F>() const {\ |
|
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \ |
|
p6, p7, p8, p9));\ |
|
}\ |
|
p0##_type p0;\ |
|
p1##_type p1;\ |
|
p2##_type p2;\ |
|
p3##_type p3;\ |
|
p4##_type p4;\ |
|
p5##_type p5;\ |
|
p6##_type p6;\ |
|
p7##_type p7;\ |
|
p8##_type p8;\ |
|
p9##_type p9;\ |
|
};\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type, \ |
|
typename p9##_type>\ |
|
inline name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, \ |
|
p9##_type> name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ |
|
p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ |
|
p9##_type p9) {\ |
|
return name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, \ |
|
p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type>(p0, \ |
|
p1, p2, p3, p4, p5, p6, p7, p8, p9);\ |
|
}\ |
|
template <typename p0##_type, typename p1##_type, typename p2##_type, \ |
|
typename p3##_type, typename p4##_type, typename p5##_type, \ |
|
typename p6##_type, typename p7##_type, typename p8##_type, \ |
|
typename p9##_type>\ |
|
template <typename F>\ |
|
template <typename arg0_type, typename arg1_type, typename arg2_type, \ |
|
typename arg3_type, typename arg4_type, typename arg5_type, \ |
|
typename arg6_type, typename arg7_type, typename arg8_type, \ |
|
typename arg9_type>\ |
|
typename ::testing::internal::Function<F>::Result\ |
|
name##ActionP10<p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ |
|
p5##_type, p6##_type, p7##_type, p8##_type, \ |
|
p9##_type>::gmock_Impl<F>::gmock_PerformImpl(\ |
|
GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const |
|
|
|
// TODO(wan@google.com): move the following to a different .h file |
|
// such that we don't have to run 'pump' every time the code is |
|
// updated. |
|
namespace testing { |
|
|
|
namespace internal { |
|
|
|
// Saves argument #0 to where the pointer points. |
|
ACTION_P(SaveArg0, pointer) { *pointer = arg0; } |
|
|
|
// Assigns 'value' to the variable referenced by argument #0. |
|
ACTION_P(SetArg0Referee, value) { |
|
// Ensures that argument #0 is a reference. If you get a compiler |
|
// error on the next line, you are using SetArgReferee<k>(value) in |
|
// a mock function whose k-th (0-based) argument is not a reference. |
|
GMOCK_COMPILE_ASSERT_(internal::is_reference<arg0_type>::value, |
|
SetArgReferee_must_be_used_with_a_reference_argument); |
|
arg0 = value; |
|
} |
|
|
|
// ReturnNewAction<T> creates and returns a new instance of an object each time |
|
// it is performed. It is overloaded to work with constructors that take |
|
// different numbers of arguments. |
|
// Returns a new instance of T using a nullary constructor with the given |
|
// arguments. |
|
template <typename T> |
|
class ReturnNewAction0 { |
|
public: |
|
ReturnNewAction0() {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(); |
|
} |
|
private: |
|
}; |
|
|
|
// Returns a new instance of T using a unary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1> |
|
class ReturnNewAction1 { |
|
public: |
|
explicit ReturnNewAction1(A1 a1) : arg1_(a1) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
}; |
|
|
|
// Returns a new instance of T using a binary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2> |
|
class ReturnNewAction2 { |
|
public: |
|
ReturnNewAction2(A1 a1, A2 a2) : arg1_(a1), arg2_(a2) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
}; |
|
|
|
// Returns a new instance of T using a ternary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3> |
|
class ReturnNewAction3 { |
|
public: |
|
ReturnNewAction3(A1 a1, A2 a2, A3 a3) : arg1_(a1), arg2_(a2), arg3_(a3) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
}; |
|
|
|
// Returns a new instance of T using a 4-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4> |
|
class ReturnNewAction4 { |
|
public: |
|
ReturnNewAction4(A1 a1, A2 a2, A3 a3, A4 a4) : arg1_(a1), arg2_(a2), |
|
arg3_(a3), arg4_(a4) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
}; |
|
|
|
// Returns a new instance of T using a 5-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
class ReturnNewAction5 { |
|
public: |
|
ReturnNewAction5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : arg1_(a1), arg2_(a2), |
|
arg3_(a3), arg4_(a4), arg5_(a5) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
}; |
|
|
|
// Returns a new instance of T using a 6-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
class ReturnNewAction6 { |
|
public: |
|
ReturnNewAction6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : arg1_(a1), |
|
arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), arg6_(a6) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
}; |
|
|
|
// Returns a new instance of T using a 7-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
class ReturnNewAction7 { |
|
public: |
|
ReturnNewAction7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, |
|
A7 a7) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), |
|
arg6_(a6), arg7_(a7) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
}; |
|
|
|
// Returns a new instance of T using a 8-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
class ReturnNewAction8 { |
|
public: |
|
ReturnNewAction8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, |
|
A8 a8) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), |
|
arg6_(a6), arg7_(a7), arg8_(a8) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
}; |
|
|
|
// Returns a new instance of T using a 9-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
class ReturnNewAction9 { |
|
public: |
|
ReturnNewAction9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, |
|
A9 a9) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), |
|
arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
const A9 arg9_; |
|
}; |
|
|
|
// Returns a new instance of T using a 10-ary constructor with the given |
|
// arguments. |
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9, |
|
typename A10> |
|
class ReturnNewAction10 { |
|
public: |
|
ReturnNewAction10(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, |
|
A9 a9, A10 a10) : arg1_(a1), arg2_(a2), arg3_(a3), arg4_(a4), arg5_(a5), |
|
arg6_(a6), arg7_(a7), arg8_(a8), arg9_(a9), arg10_(a10) {} |
|
|
|
template <typename Result, typename ArgumentTuple> |
|
Result Perform(const ArgumentTuple& /* args */) { |
|
return new T(arg1_, arg2_, arg3_, arg4_, arg5_, arg6_, arg7_, arg8_, arg9_, |
|
arg10_); |
|
} |
|
private: |
|
const A1 arg1_; |
|
const A2 arg2_; |
|
const A3 arg3_; |
|
const A4 arg4_; |
|
const A5 arg5_; |
|
const A6 arg6_; |
|
const A7 arg7_; |
|
const A8 arg8_; |
|
const A9 arg9_; |
|
const A10 arg10_; |
|
}; |
|
|
|
// Deletes the object pointed to by argument #0. |
|
ACTION(DeleteArg0) { delete arg0; } |
|
|
|
} // namespace internal |
|
|
|
// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the |
|
// mock function to *pointer. |
|
template <int k, typename Pointer> |
|
inline internal::WithArgsAction<internal::SaveArg0ActionP<Pointer>, k> |
|
SaveArg(const Pointer& pointer) { |
|
return WithArg<k>(internal::SaveArg0(pointer)); |
|
} |
|
|
|
// Action SetArgReferee<k>(value) assigns 'value' to the variable |
|
// referenced by the k-th (0-based) argument of the mock function. |
|
template <int k, typename Value> |
|
inline internal::WithArgsAction<internal::SetArg0RefereeActionP<Value>, k> |
|
SetArgReferee(const Value& value) { |
|
return WithArg<k>(internal::SetArg0Referee(value)); |
|
} |
|
|
|
// Various overloads for ReturnNew<T>(). |
|
// |
|
// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new |
|
// instance of type T, constructed on the heap with constructor arguments |
|
// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. |
|
template <typename T> |
|
inline PolymorphicAction<internal::ReturnNewAction0<T> > |
|
ReturnNew() { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction0<T>()); |
|
} |
|
|
|
template <typename T, typename A1> |
|
inline PolymorphicAction<internal::ReturnNewAction1<T, A1> > |
|
ReturnNew(A1 a1) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction1<T, A1>(a1)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2> |
|
inline PolymorphicAction<internal::ReturnNewAction2<T, A1, A2> > |
|
ReturnNew(A1 a1, A2 a2) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction2<T, A1, A2>(a1, a2)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3> |
|
inline PolymorphicAction<internal::ReturnNewAction3<T, A1, A2, A3> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction3<T, A1, A2, A3>(a1, a2, a3)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4> |
|
inline PolymorphicAction<internal::ReturnNewAction4<T, A1, A2, A3, A4> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction4<T, A1, A2, A3, A4>(a1, a2, a3, a4)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5> |
|
inline PolymorphicAction<internal::ReturnNewAction5<T, A1, A2, A3, A4, A5> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction5<T, A1, A2, A3, A4, A5>(a1, a2, a3, a4, a5)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6> |
|
inline PolymorphicAction<internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction6<T, A1, A2, A3, A4, A5, A6>(a1, a2, a3, a4, a5, |
|
a6)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7> |
|
inline PolymorphicAction<internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6, |
|
A7> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction7<T, A1, A2, A3, A4, A5, A6, A7>(a1, a2, a3, a4, |
|
a5, a6, a7)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8> |
|
inline PolymorphicAction<internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6, |
|
A7, A8> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction8<T, A1, A2, A3, A4, A5, A6, A7, A8>(a1, a2, a3, |
|
a4, a5, a6, a7, a8)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9> |
|
inline PolymorphicAction<internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6, |
|
A7, A8, A9> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction9<T, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a1, a2, |
|
a3, a4, a5, a6, a7, a8, a9)); |
|
} |
|
|
|
template <typename T, typename A1, typename A2, typename A3, typename A4, |
|
typename A5, typename A6, typename A7, typename A8, typename A9, |
|
typename A10> |
|
inline PolymorphicAction<internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6, |
|
A7, A8, A9, A10> > |
|
ReturnNew(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, |
|
A10 a10) { |
|
return MakePolymorphicAction( |
|
internal::ReturnNewAction10<T, A1, A2, A3, A4, A5, A6, A7, A8, A9, |
|
A10>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)); |
|
} |
|
|
|
// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock |
|
// function. |
|
template <int k> |
|
inline internal::WithArgsAction<internal::DeleteArg0Action, k> |
|
DeleteArg() { |
|
return WithArg<k>(internal::DeleteArg0()); |
|
} |
|
|
|
// Action Throw(exception) can be used in a mock function of any type |
|
// to throw the given exception. Any copyable value can be thrown. |
|
#if GTEST_HAS_EXCEPTIONS |
|
ACTION_P(Throw, exception) { throw exception; } |
|
#endif // GTEST_HAS_EXCEPTIONS |
|
|
|
} // namespace testing |
|
|
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
|
|
|