901 lines
31 KiB
C
901 lines
31 KiB
C
|
// 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 actions.
|
||
|
|
||
|
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
|
||
|
#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
|
||
|
|
||
|
#include <algorithm>
|
||
|
#include <string>
|
||
|
#include <errno.h>
|
||
|
#include <gmock/internal/gmock-internal-utils.h>
|
||
|
#include <gmock/internal/gmock-port.h>
|
||
|
|
||
|
namespace testing {
|
||
|
|
||
|
// To implement an action Foo, define:
|
||
|
// 1. a class FooAction that implements the ActionInterface interface, and
|
||
|
// 2. a factory function that creates an Action object from a
|
||
|
// const FooAction*.
|
||
|
//
|
||
|
// The two-level delegation design follows that of Matcher, providing
|
||
|
// consistency for extension developers. It also eases ownership
|
||
|
// management as Action objects can now be copied like plain values.
|
||
|
|
||
|
namespace internal {
|
||
|
|
||
|
template <typename F>
|
||
|
class MonomorphicDoDefaultActionImpl;
|
||
|
|
||
|
template <typename F1, typename F2>
|
||
|
class ActionAdaptor;
|
||
|
|
||
|
// BuiltInDefaultValue<T>::Get() returns the "built-in" default
|
||
|
// value for type T, which is NULL when T is a pointer type, 0 when T
|
||
|
// is a numeric type, false when T is bool, or "" when T is string or
|
||
|
// std::string. For any other type T, this value is undefined and the
|
||
|
// function will abort the process.
|
||
|
template <typename T>
|
||
|
class BuiltInDefaultValue {
|
||
|
public:
|
||
|
static T Get() {
|
||
|
Assert(false, __FILE__, __LINE__,
|
||
|
"Default action undefined for the function return type.");
|
||
|
return internal::Invalid<T>();
|
||
|
// The above statement will never be reached, but is required in
|
||
|
// order for this function to compile.
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// This partial specialization says that we use the same built-in
|
||
|
// default value for T and const T.
|
||
|
template <typename T>
|
||
|
class BuiltInDefaultValue<const T> {
|
||
|
public:
|
||
|
static T Get() { return BuiltInDefaultValue<T>::Get(); }
|
||
|
};
|
||
|
|
||
|
// This partial specialization defines the default values for pointer
|
||
|
// types.
|
||
|
template <typename T>
|
||
|
class BuiltInDefaultValue<T*> {
|
||
|
public:
|
||
|
static T* Get() { return NULL; }
|
||
|
};
|
||
|
|
||
|
// The following specializations define the default values for
|
||
|
// specific types we care about.
|
||
|
#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(type, value) \
|
||
|
template <> \
|
||
|
class BuiltInDefaultValue<type> { \
|
||
|
public: \
|
||
|
static type Get() { return value; } \
|
||
|
}
|
||
|
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(void, ); // NOLINT
|
||
|
#if GTEST_HAS_GLOBAL_STRING
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(::string, "");
|
||
|
#endif // GTEST_HAS_GLOBAL_STRING
|
||
|
#if GTEST_HAS_STD_STRING
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(::std::string, "");
|
||
|
#endif // GTEST_HAS_STD_STRING
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(bool, false);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(unsigned char, '\0');
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(signed char, '\0');
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(char, '\0');
|
||
|
|
||
|
// signed wchar_t and unsigned wchar_t are NOT in the C++ standard.
|
||
|
// Using them is a bad practice and not portable. So don't use them.
|
||
|
//
|
||
|
// Still, Google Mock is designed to work even if the user uses signed
|
||
|
// wchar_t or unsigned wchar_t (obviously, assuming the compiler
|
||
|
// supports them).
|
||
|
//
|
||
|
// To gcc,
|
||
|
//
|
||
|
// wchar_t == signed wchar_t != unsigned wchar_t == unsigned int
|
||
|
//
|
||
|
// MSVC does not recognize signed wchar_t or unsigned wchar_t. It
|
||
|
// treats wchar_t as a native type usually, but treats it as the same
|
||
|
// as unsigned short when the compiler option /Zc:wchar_t- is
|
||
|
// specified.
|
||
|
//
|
||
|
// Therefore we provide a default action for wchar_t when compiled
|
||
|
// with gcc or _NATIVE_WCHAR_T_DEFINED is defined.
|
||
|
//
|
||
|
// There's no need for a default action for signed wchar_t, as that
|
||
|
// type is the same as wchar_t for gcc, and invalid for MSVC.
|
||
|
//
|
||
|
// There's also no need for a default action for unsigned wchar_t, as
|
||
|
// that type is the same as unsigned int for gcc, and invalid for
|
||
|
// MSVC.
|
||
|
#if defined(__GNUC__) || defined(_NATIVE_WCHAR_T_DEFINED)
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(wchar_t, 0U); // NOLINT
|
||
|
#endif
|
||
|
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(unsigned short, 0U); // NOLINT
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(signed short, 0); // NOLINT
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(unsigned int, 0U);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(signed int, 0);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(unsigned long, 0UL); // NOLINT
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(signed long, 0L); // NOLINT
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(UInt64, 0);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(Int64, 0);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(float, 0);
|
||
|
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE(double, 0);
|
||
|
|
||
|
#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE
|
||
|
|
||
|
} // namespace internal
|
||
|
|
||
|
// When an unexpected function call is encountered, Google Mock will
|
||
|
// let it return a default value if the user has specified one for its
|
||
|
// return type, or if the return type has a built-in default value;
|
||
|
// otherwise Google Mock won't know what value to return and will have
|
||
|
// to abort the process.
|
||
|
//
|
||
|
// The DefaultValue<T> class allows a user to specify the
|
||
|
// default value for a type T that is both copyable and publicly
|
||
|
// destructible (i.e. anything that can be used as a function return
|
||
|
// type). The usage is:
|
||
|
//
|
||
|
// // Sets the default value for type T to be foo.
|
||
|
// DefaultValue<T>::Set(foo);
|
||
|
template <typename T>
|
||
|
class DefaultValue {
|
||
|
public:
|
||
|
// Sets the default value for type T; requires T to be
|
||
|
// copy-constructable and have a public destructor.
|
||
|
static void Set(T x) {
|
||
|
delete value_;
|
||
|
value_ = new T(x);
|
||
|
}
|
||
|
|
||
|
// Unsets the default value for type T.
|
||
|
static void Clear() {
|
||
|
delete value_;
|
||
|
value_ = NULL;
|
||
|
}
|
||
|
|
||
|
// Returns true iff the user has set the default value for type T.
|
||
|
static bool IsSet() { return value_ != NULL; }
|
||
|
|
||
|
// Returns the default value for type T if the user has set one;
|
||
|
// otherwise returns the built-in default value if there is one;
|
||
|
// otherwise aborts the process.
|
||
|
static T Get() {
|
||
|
return value_ == NULL ?
|
||
|
internal::BuiltInDefaultValue<T>::Get() : *value_;
|
||
|
}
|
||
|
private:
|
||
|
static const T* value_;
|
||
|
};
|
||
|
|
||
|
// This partial specialization allows a user to set default values for
|
||
|
// reference types.
|
||
|
template <typename T>
|
||
|
class DefaultValue<T&> {
|
||
|
public:
|
||
|
// Sets the default value for type T&.
|
||
|
static void Set(T& x) { // NOLINT
|
||
|
address_ = &x;
|
||
|
}
|
||
|
|
||
|
// Unsets the default value for type T&.
|
||
|
static void Clear() {
|
||
|
address_ = NULL;
|
||
|
}
|
||
|
|
||
|
// Returns true iff the user has set the default value for type T&.
|
||
|
static bool IsSet() { return address_ != NULL; }
|
||
|
|
||
|
// Returns the default value for type T& if the user has set one;
|
||
|
// otherwise returns the built-in default value if there is one;
|
||
|
// otherwise aborts the process.
|
||
|
static T& Get() {
|
||
|
return address_ == NULL ?
|
||
|
internal::BuiltInDefaultValue<T&>::Get() : *address_;
|
||
|
}
|
||
|
private:
|
||
|
static T* address_;
|
||
|
};
|
||
|
|
||
|
// This specialization allows DefaultValue<void>::Get() to
|
||
|
// compile.
|
||
|
template <>
|
||
|
class DefaultValue<void> {
|
||
|
public:
|
||
|
static void Get() {}
|
||
|
};
|
||
|
|
||
|
// Points to the user-set default value for type T.
|
||
|
template <typename T>
|
||
|
const T* DefaultValue<T>::value_ = NULL;
|
||
|
|
||
|
// Points to the user-set default value for type T&.
|
||
|
template <typename T>
|
||
|
T* DefaultValue<T&>::address_ = NULL;
|
||
|
|
||
|
// Implement this interface to define an action for function type F.
|
||
|
template <typename F>
|
||
|
class ActionInterface {
|
||
|
public:
|
||
|
typedef typename internal::Function<F>::Result Result;
|
||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
ActionInterface() : is_do_default_(false) {}
|
||
|
|
||
|
virtual ~ActionInterface() {}
|
||
|
|
||
|
// Performs the action. This method is not const, as in general an
|
||
|
// action can have side effects and be stateful. For example, a
|
||
|
// get-the-next-element-from-the-collection action will need to
|
||
|
// remember the current element.
|
||
|
virtual Result Perform(const ArgumentTuple& args) = 0;
|
||
|
|
||
|
// Returns true iff this is the DoDefault() action.
|
||
|
bool IsDoDefault() const { return is_do_default_; }
|
||
|
private:
|
||
|
template <typename Function>
|
||
|
friend class internal::MonomorphicDoDefaultActionImpl;
|
||
|
|
||
|
// This private constructor is reserved for implementing
|
||
|
// DoDefault(), the default action for a given mock function.
|
||
|
explicit ActionInterface(bool is_do_default)
|
||
|
: is_do_default_(is_do_default) {}
|
||
|
|
||
|
// True iff this action is DoDefault().
|
||
|
const bool is_do_default_;
|
||
|
};
|
||
|
|
||
|
// An Action<F> is a copyable and IMMUTABLE (except by assignment)
|
||
|
// object that represents an action to be taken when a mock function
|
||
|
// of type F is called. The implementation of Action<T> is just a
|
||
|
// linked_ptr to const ActionInterface<T>, so copying is fairly cheap.
|
||
|
// Don't inherit from Action!
|
||
|
//
|
||
|
// You can view an object implementing ActionInterface<F> as a
|
||
|
// concrete action (including its current state), and an Action<F>
|
||
|
// object as a handle to it.
|
||
|
template <typename F>
|
||
|
class Action {
|
||
|
public:
|
||
|
typedef typename internal::Function<F>::Result Result;
|
||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
// Constructs a null Action. Needed for storing Action objects in
|
||
|
// STL containers.
|
||
|
Action() : impl_(NULL) {}
|
||
|
|
||
|
// Constructs an Action from its implementation.
|
||
|
explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
|
||
|
|
||
|
// Copy constructor.
|
||
|
Action(const Action& action) : impl_(action.impl_) {}
|
||
|
|
||
|
// This constructor allows us to turn an Action<Func> object into an
|
||
|
// Action<F>, as long as F's arguments can be implicitly converted
|
||
|
// to Func's and Func's return type cann be implicitly converted to
|
||
|
// F's.
|
||
|
template <typename Func>
|
||
|
explicit Action(const Action<Func>& action);
|
||
|
|
||
|
// Returns true iff this is the DoDefault() action.
|
||
|
bool IsDoDefault() const { return impl_->IsDoDefault(); }
|
||
|
|
||
|
// Performs the action. Note that this method is const even though
|
||
|
// the corresponding method in ActionInterface is not. The reason
|
||
|
// is that a const Action<F> means that it cannot be re-bound to
|
||
|
// another concrete action, not that the concrete action it binds to
|
||
|
// cannot change state. (Think of the difference between a const
|
||
|
// pointer and a pointer to const.)
|
||
|
Result Perform(const ArgumentTuple& args) const {
|
||
|
return impl_->Perform(args);
|
||
|
}
|
||
|
private:
|
||
|
template <typename F1, typename F2>
|
||
|
friend class internal::ActionAdaptor;
|
||
|
|
||
|
internal::linked_ptr<ActionInterface<F> > impl_;
|
||
|
};
|
||
|
|
||
|
// The PolymorphicAction class template makes it easy to implement a
|
||
|
// polymorphic action (i.e. an action that can be used in mock
|
||
|
// functions of than one type, e.g. Return()).
|
||
|
//
|
||
|
// To define a polymorphic action, a user first provides a COPYABLE
|
||
|
// implementation class that has a Perform() method template:
|
||
|
//
|
||
|
// class FooAction {
|
||
|
// public:
|
||
|
// template <typename Result, typename ArgumentTuple>
|
||
|
// Result Perform(const ArgumentTuple& args) const {
|
||
|
// // Processes the arguments and returns a result, using
|
||
|
// // tr1::get<N>(args) to get the N-th (0-based) argument in the tuple.
|
||
|
// }
|
||
|
// ...
|
||
|
// };
|
||
|
//
|
||
|
// Then the user creates the polymorphic action using
|
||
|
// MakePolymorphicAction(object) where object has type FooAction. See
|
||
|
// the definition of Return(void) and SetArgumentPointee<N>(value) for
|
||
|
// complete examples.
|
||
|
template <typename Impl>
|
||
|
class PolymorphicAction {
|
||
|
public:
|
||
|
explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
|
||
|
|
||
|
template <typename F>
|
||
|
operator Action<F>() const {
|
||
|
return Action<F>(new MonomorphicImpl<F>(impl_));
|
||
|
}
|
||
|
private:
|
||
|
template <typename F>
|
||
|
class MonomorphicImpl : public ActionInterface<F> {
|
||
|
public:
|
||
|
typedef typename internal::Function<F>::Result Result;
|
||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
|
||
|
|
||
|
virtual Result Perform(const ArgumentTuple& args) {
|
||
|
return impl_.template Perform<Result>(args);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
Impl impl_;
|
||
|
};
|
||
|
|
||
|
Impl impl_;
|
||
|
};
|
||
|
|
||
|
// Creates an Action from its implementation and returns it. The
|
||
|
// created Action object owns the implementation.
|
||
|
template <typename F>
|
||
|
Action<F> MakeAction(ActionInterface<F>* impl) {
|
||
|
return Action<F>(impl);
|
||
|
}
|
||
|
|
||
|
// Creates a polymorphic action from its implementation. This is
|
||
|
// easier to use than the PolymorphicAction<Impl> constructor as it
|
||
|
// doesn't require you to explicitly write the template argument, e.g.
|
||
|
//
|
||
|
// MakePolymorphicAction(foo);
|
||
|
// vs
|
||
|
// PolymorphicAction<TypeOfFoo>(foo);
|
||
|
template <typename Impl>
|
||
|
inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
|
||
|
return PolymorphicAction<Impl>(impl);
|
||
|
}
|
||
|
|
||
|
namespace internal {
|
||
|
|
||
|
// Allows an Action<F2> object to pose as an Action<F1>, as long as F2
|
||
|
// and F1 are compatible.
|
||
|
template <typename F1, typename F2>
|
||
|
class ActionAdaptor : public ActionInterface<F1> {
|
||
|
public:
|
||
|
typedef typename internal::Function<F1>::Result Result;
|
||
|
typedef typename internal::Function<F1>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
explicit ActionAdaptor(const Action<F2>& from) : impl_(from.impl_) {}
|
||
|
|
||
|
virtual Result Perform(const ArgumentTuple& args) {
|
||
|
return impl_->Perform(args);
|
||
|
}
|
||
|
private:
|
||
|
const internal::linked_ptr<ActionInterface<F2> > impl_;
|
||
|
};
|
||
|
|
||
|
// Implements the polymorphic Return(x) action, which can be used in
|
||
|
// any function that returns the type of x, regardless of the argument
|
||
|
// types.
|
||
|
template <typename R>
|
||
|
class ReturnAction {
|
||
|
public:
|
||
|
// Constructs a ReturnAction object from the value to be returned.
|
||
|
// 'value' is passed by value instead of by const reference in order
|
||
|
// to allow Return("string literal") to compile.
|
||
|
explicit ReturnAction(R value) : value_(value) {}
|
||
|
|
||
|
// This template type conversion operator allows Return(x) to be
|
||
|
// used in ANY function that returns x's type.
|
||
|
template <typename F>
|
||
|
operator Action<F>() const {
|
||
|
// Assert statement belongs here because this is the best place to verify
|
||
|
// conditions on F. It produces the clearest error messages
|
||
|
// in most compilers.
|
||
|
// Impl really belongs in this scope as a local class but can't
|
||
|
// because MSVC produces duplicate symbols in different translation units
|
||
|
// in this case. Until MS fixes that bug we put Impl into the class scope
|
||
|
// and put the typedef both here (for use in assert statement) and
|
||
|
// in the Impl class. But both definitions must be the same.
|
||
|
typedef typename Function<F>::Result Result;
|
||
|
GMOCK_COMPILE_ASSERT(!internal::is_reference<Result>::value,
|
||
|
use_ReturnRef_instead_of_Return_to_return_a_reference);
|
||
|
return Action<F>(new Impl<F>(value_));
|
||
|
}
|
||
|
private:
|
||
|
// Implements the Return(x) 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;
|
||
|
|
||
|
explicit Impl(R value) : value_(value) {}
|
||
|
|
||
|
virtual Result Perform(const ArgumentTuple&) { return value_; }
|
||
|
|
||
|
private:
|
||
|
R value_;
|
||
|
};
|
||
|
|
||
|
R value_;
|
||
|
};
|
||
|
|
||
|
// Implements the ReturnNull() action.
|
||
|
class ReturnNullAction {
|
||
|
public:
|
||
|
// Allows ReturnNull() to be used in any pointer-returning function.
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
static Result Perform(const ArgumentTuple&) {
|
||
|
GMOCK_COMPILE_ASSERT(internal::is_pointer<Result>::value,
|
||
|
ReturnNull_can_be_used_to_return_a_pointer_only);
|
||
|
return NULL;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Implements the Return() action.
|
||
|
class ReturnVoidAction {
|
||
|
public:
|
||
|
// Allows Return() to be used in any void-returning function.
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
static void Perform(const ArgumentTuple&) {
|
||
|
CompileAssertTypesEqual<void, Result>();
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Implements the polymorphic ReturnRef(x) action, which can be used
|
||
|
// in any function that returns a reference to the type of x,
|
||
|
// regardless of the argument types.
|
||
|
template <typename T>
|
||
|
class ReturnRefAction {
|
||
|
public:
|
||
|
// Constructs a ReturnRefAction object from the reference to be returned.
|
||
|
explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT
|
||
|
|
||
|
// This template type conversion operator allows ReturnRef(x) to be
|
||
|
// used in ANY function that returns a reference to x's type.
|
||
|
template <typename F>
|
||
|
operator Action<F>() const {
|
||
|
typedef typename Function<F>::Result Result;
|
||
|
// Asserts that the function return type is a reference. This
|
||
|
// catches the user error of using ReturnRef(x) when Return(x)
|
||
|
// should be used, and generates some helpful error message.
|
||
|
GMOCK_COMPILE_ASSERT(internal::is_reference<Result>::value,
|
||
|
use_Return_instead_of_ReturnRef_to_return_a_value);
|
||
|
return Action<F>(new Impl<F>(ref_));
|
||
|
}
|
||
|
private:
|
||
|
// Implements the ReturnRef(x) 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;
|
||
|
|
||
|
explicit Impl(T& ref) : ref_(ref) {} // NOLINT
|
||
|
|
||
|
virtual Result Perform(const ArgumentTuple&) {
|
||
|
return ref_;
|
||
|
}
|
||
|
private:
|
||
|
T& ref_;
|
||
|
};
|
||
|
|
||
|
T& ref_;
|
||
|
};
|
||
|
|
||
|
// Implements the DoDefault() action for a particular function type F.
|
||
|
template <typename F>
|
||
|
class MonomorphicDoDefaultActionImpl : public ActionInterface<F> {
|
||
|
public:
|
||
|
typedef typename Function<F>::Result Result;
|
||
|
typedef typename Function<F>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
MonomorphicDoDefaultActionImpl() : ActionInterface<F>(true) {}
|
||
|
|
||
|
// For technical reasons, DoDefault() cannot be used inside a
|
||
|
// composite action (e.g. DoAll(...)). It can only be used at the
|
||
|
// top level in an EXPECT_CALL(). If this function is called, the
|
||
|
// user must be using DoDefault() inside a composite action, and we
|
||
|
// have to generate a run-time error.
|
||
|
virtual Result Perform(const ArgumentTuple&) {
|
||
|
Assert(false, __FILE__, __LINE__,
|
||
|
"You are using DoDefault() inside a composite action like "
|
||
|
"DoAll() or WithArgs(). This is not supported for technical "
|
||
|
"reasons. Please instead spell out the default action, or "
|
||
|
"assign the default action to an Action variable and use "
|
||
|
"the variable in various places.");
|
||
|
return internal::Invalid<Result>();
|
||
|
// The above statement will never be reached, but is required in
|
||
|
// order for this function to compile.
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Implements the polymorphic DoDefault() action.
|
||
|
class DoDefaultAction {
|
||
|
public:
|
||
|
// This template type conversion operator allows DoDefault() to be
|
||
|
// used in any function.
|
||
|
template <typename F>
|
||
|
operator Action<F>() const {
|
||
|
return Action<F>(new MonomorphicDoDefaultActionImpl<F>);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Implements the Assign action to set a given pointer referent to a
|
||
|
// particular value.
|
||
|
template <typename T1, typename T2>
|
||
|
class AssignAction {
|
||
|
public:
|
||
|
AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
|
||
|
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
void Perform(const ArgumentTuple &args) const {
|
||
|
*ptr_ = value_;
|
||
|
}
|
||
|
private:
|
||
|
T1* const ptr_;
|
||
|
const T2 value_;
|
||
|
};
|
||
|
|
||
|
// Implements the SetErrnoAndReturn action to simulate return from
|
||
|
// various system calls and libc functions.
|
||
|
template <typename T>
|
||
|
class SetErrnoAndReturnAction {
|
||
|
public:
|
||
|
SetErrnoAndReturnAction(int errno_value, T result)
|
||
|
: errno_(errno_value),
|
||
|
result_(result) {}
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
Result Perform(const ArgumentTuple &args) const {
|
||
|
errno = errno_;
|
||
|
return result_;
|
||
|
}
|
||
|
private:
|
||
|
const int errno_;
|
||
|
const T result_;
|
||
|
};
|
||
|
|
||
|
// Implements the SetArgumentPointee<N>(x) action for any function
|
||
|
// whose N-th argument (0-based) is a pointer to x's type. The
|
||
|
// template parameter kIsProto is true iff type A is ProtocolMessage,
|
||
|
// proto2::Message, or a sub-class of those.
|
||
|
template <size_t N, typename A, bool kIsProto>
|
||
|
class SetArgumentPointeeAction {
|
||
|
public:
|
||
|
// Constructs an action that sets the variable pointed to by the
|
||
|
// N-th function argument to 'value'.
|
||
|
explicit SetArgumentPointeeAction(const A& value) : value_(value) {}
|
||
|
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
void Perform(const ArgumentTuple& args) const {
|
||
|
CompileAssertTypesEqual<void, Result>();
|
||
|
*::std::tr1::get<N>(args) = value_;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
const A value_;
|
||
|
};
|
||
|
|
||
|
template <size_t N, typename Proto>
|
||
|
class SetArgumentPointeeAction<N, Proto, true> {
|
||
|
public:
|
||
|
// Constructs an action that sets the variable pointed to by the
|
||
|
// N-th function argument to 'proto'. Both ProtocolMessage and
|
||
|
// proto2::Message have the CopyFrom() method, so the same
|
||
|
// implementation works for both.
|
||
|
explicit SetArgumentPointeeAction(const Proto& proto) : proto_(new Proto) {
|
||
|
proto_->CopyFrom(proto);
|
||
|
}
|
||
|
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
void Perform(const ArgumentTuple& args) const {
|
||
|
CompileAssertTypesEqual<void, Result>();
|
||
|
::std::tr1::get<N>(args)->CopyFrom(*proto_);
|
||
|
}
|
||
|
private:
|
||
|
const internal::linked_ptr<Proto> proto_;
|
||
|
};
|
||
|
|
||
|
// Implements the SetArrayArgument<N>(first, last) action for any function
|
||
|
// whose N-th argument (0-based) is a pointer or iterator to a type that can be
|
||
|
// implicitly converted from *first.
|
||
|
template <size_t N, typename InputIterator>
|
||
|
class SetArrayArgumentAction {
|
||
|
public:
|
||
|
// Constructs an action that sets the variable pointed to by the
|
||
|
// N-th function argument to 'value'.
|
||
|
explicit SetArrayArgumentAction(InputIterator first, InputIterator last)
|
||
|
: first_(first), last_(last) {
|
||
|
}
|
||
|
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
void Perform(const ArgumentTuple& args) const {
|
||
|
CompileAssertTypesEqual<void, Result>();
|
||
|
|
||
|
// Microsoft compiler deprecates ::std::copy, so we want to suppress warning
|
||
|
// 4996 (Function call with parameters that may be unsafe) there.
|
||
|
#ifdef GTEST_OS_WINDOWS
|
||
|
#pragma warning(push) // Saves the current warning state.
|
||
|
#pragma warning(disable:4996) // Temporarily disables warning 4996.
|
||
|
#endif // GTEST_OS_WINDOWS
|
||
|
::std::copy(first_, last_, ::std::tr1::get<N>(args));
|
||
|
#ifdef GTEST_OS_WINDOWS
|
||
|
#pragma warning(pop) // Restores the warning state.
|
||
|
#endif // GTEST_OS_WINDOWS
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
const InputIterator first_;
|
||
|
const InputIterator last_;
|
||
|
};
|
||
|
|
||
|
// Implements the InvokeWithoutArgs(f) action. The template argument
|
||
|
// FunctionImpl is the implementation type of f, which can be either a
|
||
|
// function pointer or a functor. InvokeWithoutArgs(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 InvokeWithoutArgsAction {
|
||
|
public:
|
||
|
// The c'tor makes a copy of function_impl (either a function
|
||
|
// pointer or a functor).
|
||
|
explicit InvokeWithoutArgsAction(FunctionImpl function_impl)
|
||
|
: function_impl_(function_impl) {}
|
||
|
|
||
|
// Allows InvokeWithoutArgs(f) to be used as any action whose type is
|
||
|
// compatible with f.
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
Result Perform(const ArgumentTuple&) { return function_impl_(); }
|
||
|
private:
|
||
|
FunctionImpl function_impl_;
|
||
|
};
|
||
|
|
||
|
// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
|
||
|
template <class Class, typename MethodPtr>
|
||
|
class InvokeMethodWithoutArgsAction {
|
||
|
public:
|
||
|
InvokeMethodWithoutArgsAction(Class* obj_ptr, MethodPtr method_ptr)
|
||
|
: obj_ptr_(obj_ptr), method_ptr_(method_ptr) {}
|
||
|
|
||
|
template <typename Result, typename ArgumentTuple>
|
||
|
Result Perform(const ArgumentTuple&) const {
|
||
|
return (obj_ptr_->*method_ptr_)();
|
||
|
}
|
||
|
private:
|
||
|
Class* const obj_ptr_;
|
||
|
const MethodPtr method_ptr_;
|
||
|
};
|
||
|
|
||
|
// Implements the IgnoreResult(action) action.
|
||
|
template <typename A>
|
||
|
class IgnoreResultAction {
|
||
|
public:
|
||
|
explicit IgnoreResultAction(const A& action) : action_(action) {}
|
||
|
|
||
|
template <typename F>
|
||
|
operator Action<F>() const {
|
||
|
// Assert statement belongs here because this is the best place to verify
|
||
|
// conditions on F. It produces the clearest error messages
|
||
|
// in most compilers.
|
||
|
// Impl really belongs in this scope as a local class but can't
|
||
|
// because MSVC produces duplicate symbols in different translation units
|
||
|
// in this case. Until MS fixes that bug we put Impl into the class scope
|
||
|
// and put the typedef both here (for use in assert statement) and
|
||
|
// in the Impl class. But both definitions must be the same.
|
||
|
typedef typename internal::Function<F>::Result Result;
|
||
|
|
||
|
// Asserts at compile time that F returns void.
|
||
|
CompileAssertTypesEqual<void, Result>();
|
||
|
|
||
|
return Action<F>(new Impl<F>(action_));
|
||
|
}
|
||
|
private:
|
||
|
template <typename F>
|
||
|
class Impl : public ActionInterface<F> {
|
||
|
public:
|
||
|
typedef typename internal::Function<F>::Result Result;
|
||
|
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
|
||
|
|
||
|
explicit Impl(const A& action) : action_(action) {}
|
||
|
|
||
|
virtual void Perform(const ArgumentTuple& args) {
|
||
|
// Performs the action and ignores its result.
|
||
|
action_.Perform(args);
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
// Type OriginalFunction is the same as F except that its return
|
||
|
// type is IgnoredValue.
|
||
|
typedef typename internal::Function<F>::MakeResultIgnoredValue
|
||
|
OriginalFunction;
|
||
|
|
||
|
const Action<OriginalFunction> action_;
|
||
|
};
|
||
|
|
||
|
const A action_;
|
||
|
};
|
||
|
|
||
|
} // namespace internal
|
||
|
|
||
|
// An Unused object can be implicitly constructed from ANY value.
|
||
|
// This is handy when defining actions that ignore some or all of the
|
||
|
// mock function arguments. For example, given
|
||
|
//
|
||
|
// MOCK_METHOD3(Foo, double(const string& label, double x, double y));
|
||
|
// MOCK_METHOD3(Bar, double(int index, double x, double y));
|
||
|
//
|
||
|
// instead of
|
||
|
//
|
||
|
// double DistanceToOriginWithLabel(const string& label, double x, double y) {
|
||
|
// return sqrt(x*x + y*y);
|
||
|
// }
|
||
|
// double DistanceToOriginWithIndex(int index, double x, double y) {
|
||
|
// return sqrt(x*x + y*y);
|
||
|
// }
|
||
|
// ...
|
||
|
// EXEPCT_CALL(mock, Foo("abc", _, _))
|
||
|
// .WillOnce(Invoke(DistanceToOriginWithLabel));
|
||
|
// EXEPCT_CALL(mock, Bar(5, _, _))
|
||
|
// .WillOnce(Invoke(DistanceToOriginWithIndex));
|
||
|
//
|
||
|
// you could write
|
||
|
//
|
||
|
// // We can declare any uninteresting argument as Unused.
|
||
|
// double DistanceToOrigin(Unused, double x, double y) {
|
||
|
// return sqrt(x*x + y*y);
|
||
|
// }
|
||
|
// ...
|
||
|
// EXEPCT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
|
||
|
// EXEPCT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
|
||
|
typedef internal::IgnoredValue Unused;
|
||
|
|
||
|
// This constructor allows us to turn an Action<From> object into an
|
||
|
// Action<To>, as long as To's arguments can be implicitly converted
|
||
|
// to From's and From's return type cann be implicitly converted to
|
||
|
// To's.
|
||
|
template <typename To>
|
||
|
template <typename From>
|
||
|
Action<To>::Action(const Action<From>& from)
|
||
|
: impl_(new internal::ActionAdaptor<To, From>(from)) {}
|
||
|
|
||
|
// Creates an action that returns 'value'. 'value' is passed by value
|
||
|
// instead of const reference - otherwise Return("string literal")
|
||
|
// will trigger a compiler error about using array as initializer.
|
||
|
template <typename R>
|
||
|
internal::ReturnAction<R> Return(R value) {
|
||
|
return internal::ReturnAction<R>(value);
|
||
|
}
|
||
|
|
||
|
// Creates an action that returns NULL.
|
||
|
inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
|
||
|
return MakePolymorphicAction(internal::ReturnNullAction());
|
||
|
}
|
||
|
|
||
|
// Creates an action that returns from a void function.
|
||
|
inline PolymorphicAction<internal::ReturnVoidAction> Return() {
|
||
|
return MakePolymorphicAction(internal::ReturnVoidAction());
|
||
|
}
|
||
|
|
||
|
// Creates an action that returns the reference to a variable.
|
||
|
template <typename R>
|
||
|
inline internal::ReturnRefAction<R> ReturnRef(R& x) { // NOLINT
|
||
|
return internal::ReturnRefAction<R>(x);
|
||
|
}
|
||
|
|
||
|
// Creates an action that does the default action for the give mock function.
|
||
|
inline internal::DoDefaultAction DoDefault() {
|
||
|
return internal::DoDefaultAction();
|
||
|
}
|
||
|
|
||
|
// Creates an action that sets the variable pointed by the N-th
|
||
|
// (0-based) function argument to 'value'.
|
||
|
template <size_t N, typename T>
|
||
|
PolymorphicAction<
|
||
|
internal::SetArgumentPointeeAction<
|
||
|
N, T, internal::IsAProtocolMessage<T>::value> >
|
||
|
SetArgumentPointee(const T& x) {
|
||
|
return MakePolymorphicAction(internal::SetArgumentPointeeAction<
|
||
|
N, T, internal::IsAProtocolMessage<T>::value>(x));
|
||
|
}
|
||
|
|
||
|
// Creates an action that sets the elements of the array pointed to by the N-th
|
||
|
// (0-based) function argument, which can be either a pointer or an iterator,
|
||
|
// to the values of the elements in the source range [first, last).
|
||
|
template <size_t N, typename InputIterator>
|
||
|
PolymorphicAction<internal::SetArrayArgumentAction<N, InputIterator> >
|
||
|
SetArrayArgument(InputIterator first, InputIterator last) {
|
||
|
return MakePolymorphicAction(internal::SetArrayArgumentAction<
|
||
|
N, InputIterator>(first, last));
|
||
|
}
|
||
|
|
||
|
// Creates an action that sets a pointer referent to a given value.
|
||
|
template <typename T1, typename T2>
|
||
|
PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
|
||
|
return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
|
||
|
}
|
||
|
|
||
|
// Creates an action that sets errno and returns the appropriate error.
|
||
|
template <typename T>
|
||
|
PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
|
||
|
SetErrnoAndReturn(int errval, T result) {
|
||
|
return MakePolymorphicAction(
|
||
|
internal::SetErrnoAndReturnAction<T>(errval, result));
|
||
|
}
|
||
|
|
||
|
// Various overloads for InvokeWithoutArgs().
|
||
|
|
||
|
// Creates an action that invokes 'function_impl' with no argument.
|
||
|
template <typename FunctionImpl>
|
||
|
PolymorphicAction<internal::InvokeWithoutArgsAction<FunctionImpl> >
|
||
|
InvokeWithoutArgs(FunctionImpl function_impl) {
|
||
|
return MakePolymorphicAction(
|
||
|
internal::InvokeWithoutArgsAction<FunctionImpl>(function_impl));
|
||
|
}
|
||
|
|
||
|
// Creates an action that invokes the given method on the given object
|
||
|
// with no argument.
|
||
|
template <class Class, typename MethodPtr>
|
||
|
PolymorphicAction<internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> >
|
||
|
InvokeWithoutArgs(Class* obj_ptr, MethodPtr method_ptr) {
|
||
|
return MakePolymorphicAction(
|
||
|
internal::InvokeMethodWithoutArgsAction<Class, MethodPtr>(
|
||
|
obj_ptr, method_ptr));
|
||
|
}
|
||
|
|
||
|
// Creates an action that performs an_action and throws away its
|
||
|
// result. In other words, it changes the return type of an_action to
|
||
|
// void. an_action MUST NOT return void, or the code won't compile.
|
||
|
template <typename A>
|
||
|
inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
|
||
|
return internal::IgnoreResultAction<A>(an_action);
|
||
|
}
|
||
|
|
||
|
} // namespace testing
|
||
|
|
||
|
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
|