// Copyright 2007, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Google Mock - a framework for writing C++ mock classes.

//

// This file implements some commonly used actions.

// GOOGLETEST_CM0002 DO NOT DELETE

#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_

#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_

#ifndef _WIN32_WCE

# include <errno.h>

#endif

#include <algorithm>

#include <string>

#include "gmock/internal/gmock-internal-utils.h"

#include "gmock/internal/gmock-port.h"

#if GTEST_LANG_CXX11  // Defined by gtest-port.h via gmock-port.h.

#include <functional>

#include <type_traits>

#endif  // GTEST_LANG_CXX11

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 F1, typename F2>

class ActionAdaptor;

// BuiltInDefaultValueGetter<T, true>::Get() returns a

// default-constructed T value.  BuiltInDefaultValueGetter<T,

// false>::Get() crashes with an error.

//

// This primary template is used when kDefaultConstructible is true.

template <typename T, bool kDefaultConstructible>

struct BuiltInDefaultValueGetter {

  static T Get() { return T(); }

};

template <typename T>

struct BuiltInDefaultValueGetter<T, false> {

  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.

  }

};

// BuiltInDefaultValue<T>::Get() returns the "built-in" default value

// for type T, which is NULL when T is a raw pointer type, 0 when T is

// a numeric type, false when T is bool, or "" when T is string or

// std::string.  In addition, in C++11 and above, it turns a

// default-constructed T value if T is default constructible.  For any

// other type T, the built-in default T value is undefined, and the

// function will abort the process.

template <typename T>

class BuiltInDefaultValue {

 public:

#if GTEST_LANG_CXX11

  // This function returns true iff type T has a built-in default value.

  static bool Exists() {

    return ::std::is_default_constructible<T>::value;

  }

  static T Get() {

    return BuiltInDefaultValueGetter<

        T, ::std::is_default_constructible<T>::value>::Get();

  }

#else  // GTEST_LANG_CXX11

  // This function returns true iff type T has a built-in default value.

  static bool Exists() {

    return false;

  }

  static T Get() {

    return BuiltInDefaultValueGetter<T, false>::Get();

  }

#endif  // GTEST_LANG_CXX11

};

// 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 bool Exists() { return BuiltInDefaultValue<T>::Exists(); }

  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 bool Exists() { return true; }

  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 bool Exists() { return true; } \

    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

GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::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');

// 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 GMOCK_WCHAR_T_IS_NATIVE_

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 producer_;

    producer_ = new FixedValueProducer(x);

  }

  // Provides a factory function to be called to generate the default value.

  // This method can be used even if T is only move-constructible, but it is not

  // limited to that case.

  typedef T (*FactoryFunction)();

  static void SetFactory(FactoryFunction factory) {

    delete producer_;

    producer_ = new FactoryValueProducer(factory);

  }

  // Unsets the default value for type T.

  static void Clear() {

    delete producer_;

    producer_ = NULL;

  }

  // Returns true iff the user has set the default value for type T.

  static bool IsSet() { return producer_ != NULL; }

  // Returns true if T has a default return value set by the user or there

  // exists a built-in default value.

  static bool Exists() {

    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();

  }

  // Returns the default value for type T if the user has set one;

  // otherwise returns the built-in default value. Requires that Exists()

  // is true, which ensures that the return value is well-defined.

  static T Get() {

    return producer_ == NULL ?

        internal::BuiltInDefaultValue<T>::Get() : producer_->Produce();

  }

 private:

  class ValueProducer {

   public:

    virtual ~ValueProducer() {}

    virtual T Produce() = 0;

  };

  class FixedValueProducer : public ValueProducer {

   public:

    explicit FixedValueProducer(T value) : value_(value) {}

    virtual T Produce() { return value_; }

   private:

    const T value_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);

  };

  class FactoryValueProducer : public ValueProducer {

   public:

    explicit FactoryValueProducer(FactoryFunction factory)

        : factory_(factory) {}

    virtual T Produce() { return factory_(); }

   private:

    const FactoryFunction factory_;

    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);

  };

  static ValueProducer* producer_;

};

// 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 true if T has a default return value set by the user or there

  // exists a built-in default value.

  static bool Exists() {

    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();

  }

  // 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 bool Exists() { return true; }

  static void Get() {}

};

// Points to the user-set default value for type T.

template <typename T>

typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = 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() {}

  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;

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);

};

// 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() {}

#if GTEST_LANG_CXX11

  // Construct an Action from a specified callable.

  // This cannot take std::function directly, because then Action would not be

  // directly constructible from lambda (it would require two conversions).

  template <typename G,

            typename = typename ::std::enable_if<

                ::std::is_constructible<::std::function<F>, G>::value>::type>

  Action(G&& fun) : fun_(::std::forward<G>(fun)) {}  // NOLINT

#endif

  // Constructs an Action from its implementation.

  explicit Action(ActionInterface<F>* impl) : impl_(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 can 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 {

#if GTEST_LANG_CXX11

    return impl_ == nullptr && fun_ == nullptr;

#else

    return impl_ == NULL;

#endif

  }

  // 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(ArgumentTuple args) const {

    if (IsDoDefault()) {

      internal::IllegalDoDefault(__FILE__, __LINE__);

    }

#if GTEST_LANG_CXX11

    if (fun_ != nullptr) {

      return internal::Apply(fun_, ::std::move(args));

    }

#endif

    return impl_->Perform(args);

  }

 private:

  template <typename F1, typename F2>

  friend class internal::ActionAdaptor;

  template <typename G>

  friend class Action;

  // In C++11, Action can be implemented either as a generic functor (through

  // std::function), or legacy ActionInterface. In C++98, only ActionInterface

  // is available. The invariants are as follows:

  // * in C++98, impl_ is null iff this is the default action

  // * in C++11, at most one of fun_ & impl_ may be nonnull; both are null iff

  //   this is the default action

#if GTEST_LANG_CXX11

  ::std::function<F> fun_;

#endif

  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_;

    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);

  };

  Impl impl_;

  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);

};

// 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_;

  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);

};

// Helper struct to specialize ReturnAction to execute a move instead of a copy

// on return. Useful for move-only types, but could be used on any type.