// 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 tests the built-in actions.

#include "gmock/gmock-actions.h"

#include <algorithm>

#include <iterator>

#include <memory>

#include <string>

#include "gmock/gmock.h"

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

#include "gtest/gtest.h"

#include "gtest/gtest-spi.h"

namespace {

// This list should be kept sorted.

using testing::Action;

using testing::ActionInterface;

using testing::Assign;

using testing::ByMove;

using testing::ByRef;

using testing::DefaultValue;

using testing::DoDefault;

using testing::IgnoreResult;

using testing::Invoke;

using testing::InvokeWithoutArgs;

using testing::MakePolymorphicAction;

using testing::Ne;

using testing::PolymorphicAction;

using testing::Return;

using testing::ReturnNull;

using testing::ReturnRef;

using testing::ReturnRefOfCopy;

using testing::SetArgPointee;

using testing::SetArgumentPointee;

using testing::_;

using testing::get;

using testing::internal::BuiltInDefaultValue;

using testing::internal::Int64;

using testing::internal::UInt64;

using testing::make_tuple;

using testing::tuple;

using testing::tuple_element;

#if !GTEST_OS_WINDOWS_MOBILE

using testing::SetErrnoAndReturn;

#endif

#if GTEST_HAS_PROTOBUF_

using testing::internal::TestMessage;

#endif  // GTEST_HAS_PROTOBUF_

// Tests that BuiltInDefaultValue<T*>::Get() returns NULL.

TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {

  EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == NULL);

  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == NULL);

  EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == NULL);

}

// Tests that BuiltInDefaultValue<T*>::Exists() return true.

TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {

  EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());

}

// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a

// built-in numeric type.

TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {

  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());

#if GMOCK_HAS_SIGNED_WCHAR_T_

  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());

#endif

#if GMOCK_WCHAR_T_IS_NATIVE_

  EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());

#endif

  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT

  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT

  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT

  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());

  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT

  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT

  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT

  EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());

}

// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a

// built-in numeric type.

TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {

  EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());

#if GMOCK_HAS_SIGNED_WCHAR_T_

  EXPECT_TRUE(BuiltInDefaultValue<unsigned wchar_t>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<signed wchar_t>::Exists());

#endif

#if GMOCK_WCHAR_T_IS_NATIVE_

  EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());

#endif

  EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT

  EXPECT_TRUE(BuiltInDefaultValue<UInt64>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<Int64>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());

  EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());

}

// Tests that BuiltInDefaultValue<bool>::Get() returns false.

TEST(BuiltInDefaultValueTest, IsFalseForBool) {

  EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());

}

// Tests that BuiltInDefaultValue<bool>::Exists() returns true.

TEST(BuiltInDefaultValueTest, BoolExists) {

  EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());

}

// Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a

// string type.

TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {

#if GTEST_HAS_GLOBAL_STRING

  EXPECT_EQ("", BuiltInDefaultValue< ::string>::Get());

#endif  // GTEST_HAS_GLOBAL_STRING

  EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());

}

// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a

// string type.

TEST(BuiltInDefaultValueTest, ExistsForString) {

#if GTEST_HAS_GLOBAL_STRING

  EXPECT_TRUE(BuiltInDefaultValue< ::string>::Exists());

#endif  // GTEST_HAS_GLOBAL_STRING

  EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());

}

// Tests that BuiltInDefaultValue<const T>::Get() returns the same

// value as BuiltInDefaultValue<T>::Get() does.

TEST(BuiltInDefaultValueTest, WorksForConstTypes) {

  EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());

  EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());

  EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == NULL);

  EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());

}

// A type that's default constructible.

class MyDefaultConstructible {

 public:

  MyDefaultConstructible() : value_(42) {}

  int value() const { return value_; }

 private:

  int value_;

};

// A type that's not default constructible.

class MyNonDefaultConstructible {

 public:

  // Does not have a default ctor.

  explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}

  int value() const { return value_; }

 private:

  int value_;

};

#if GTEST_HAS_STD_TYPE_TRAITS_

TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {

  EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());

}

TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {

  EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());

}

#endif  // GTEST_HAS_STD_TYPE_TRAITS_

TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {

  EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());

}

// Tests that BuiltInDefaultValue<T&>::Get() aborts the program.

TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {

  EXPECT_DEATH_IF_SUPPORTED({

    BuiltInDefaultValue<int&>::Get();

  }, "");

  EXPECT_DEATH_IF_SUPPORTED({

    BuiltInDefaultValue<const char&>::Get();

  }, "");

}

TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {

  EXPECT_DEATH_IF_SUPPORTED({

    BuiltInDefaultValue<MyNonDefaultConstructible>::Get();

  }, "");

}

// Tests that DefaultValue<T>::IsSet() is false initially.

TEST(DefaultValueTest, IsInitiallyUnset) {

  EXPECT_FALSE(DefaultValue<int>::IsSet());

  EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());

  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());

}

// Tests that DefaultValue<T> can be set and then unset.

TEST(DefaultValueTest, CanBeSetAndUnset) {

  EXPECT_TRUE(DefaultValue<int>::Exists());

  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());

  DefaultValue<int>::Set(1);

  DefaultValue<const MyNonDefaultConstructible>::Set(

      MyNonDefaultConstructible(42));

  EXPECT_EQ(1, DefaultValue<int>::Get());

  EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());

  EXPECT_TRUE(DefaultValue<int>::Exists());

  EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());

  DefaultValue<int>::Clear();

  DefaultValue<const MyNonDefaultConstructible>::Clear();

  EXPECT_FALSE(DefaultValue<int>::IsSet());

  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());

  EXPECT_TRUE(DefaultValue<int>::Exists());

  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());

}

// Tests that DefaultValue<T>::Get() returns the

// BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is

// false.

TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {

  EXPECT_FALSE(DefaultValue<int>::IsSet());

  EXPECT_TRUE(DefaultValue<int>::Exists());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());

  EXPECT_EQ(0, DefaultValue<int>::Get());

  EXPECT_DEATH_IF_SUPPORTED({

    DefaultValue<MyNonDefaultConstructible>::Get();

  }, "");

}

#if GTEST_HAS_STD_UNIQUE_PTR_

TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {

  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());

  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == NULL);

  DefaultValue<std::unique_ptr<int>>::SetFactory([] {

    return std::unique_ptr<int>(new int(42));

  });

  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());

  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();

  EXPECT_EQ(42, *i);

}

#endif  // GTEST_HAS_STD_UNIQUE_PTR_

// Tests that DefaultValue<void>::Get() returns void.

TEST(DefaultValueTest, GetWorksForVoid) {

  return DefaultValue<void>::Get();

}

// Tests using DefaultValue with a reference type.

// Tests that DefaultValue<T&>::IsSet() is false initially.

TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {

  EXPECT_FALSE(DefaultValue<int&>::IsSet());

  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());

}

// Tests that DefaultValue<T&>::Exists is false initiallly.

TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {

  EXPECT_FALSE(DefaultValue<int&>::Exists());

  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());

}

// Tests that DefaultValue<T&> can be set and then unset.

TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {

  int n = 1;

  DefaultValue<const int&>::Set(n);

  MyNonDefaultConstructible x(42);

  DefaultValue<MyNonDefaultConstructible&>::Set(x);

  EXPECT_TRUE(DefaultValue<const int&>::Exists());

  EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());

  EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));

  EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));

  DefaultValue<const int&>::Clear();

  DefaultValue<MyNonDefaultConstructible&>::Clear();

  EXPECT_FALSE(DefaultValue<const int&>::Exists());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());

  EXPECT_FALSE(DefaultValue<const int&>::IsSet());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());

}

// Tests that DefaultValue<T&>::Get() returns the

// BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is

// false.

TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {

  EXPECT_FALSE(DefaultValue<int&>::IsSet());

  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());

  EXPECT_DEATH_IF_SUPPORTED({

    DefaultValue<int&>::Get();

  }, "");

  EXPECT_DEATH_IF_SUPPORTED({

    DefaultValue<MyNonDefaultConstructible>::Get();

  }, "");

}

// Tests that ActionInterface can be implemented by defining the

// Perform method.

typedef int MyGlobalFunction(bool, int);

class MyActionImpl : public ActionInterface<MyGlobalFunction> {

 public:

  virtual int Perform(const tuple<bool, int>& args) {

    return get<0>(args) ? get<1>(args) : 0;

  }

};

TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {

  MyActionImpl my_action_impl;

  (void)my_action_impl;

}

TEST(ActionInterfaceTest, MakeAction) {

  Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);

  // When exercising the Perform() method of Action<F>, we must pass

  // it a tuple whose size and type are compatible with F's argument

  // types.  For example, if F is int(), then Perform() takes a

  // 0-tuple; if F is void(bool, int), then Perform() takes a

  // tuple<bool, int>, and so on.

  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));

}

// Tests that Action<F> can be contructed from a pointer to

// ActionInterface<F>.

TEST(ActionTest, CanBeConstructedFromActionInterface) {

  Action<MyGlobalFunction> action(new MyActionImpl);

}

// Tests that Action<F> delegates actual work to ActionInterface<F>.

TEST(ActionTest, DelegatesWorkToActionInterface) {

  const Action<MyGlobalFunction> action(new MyActionImpl);

  EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));

  EXPECT_EQ(0, action.Perform(make_tuple(false, 1)));

}

// Tests that Action<F> can be copied.

TEST(ActionTest, IsCopyable) {

  Action<MyGlobalFunction> a1(new MyActionImpl);

  Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.

  // a1 should continue to work after being copied from.

  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));

  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));

  // a2 should work like the action it was copied from.

  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));

  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));

  a2 = a1;  // Tests the assignment operator.

  // a1 should continue to work after being copied from.

  EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));

  EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));

  // a2 should work like the action it was copied from.

  EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));

  EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));

}

// Tests that an Action<From> object can be converted to a

// compatible Action<To> object.

class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT

 public:

  virtual bool Perform(const tuple<int>& arg) {

    return get<0>(arg) != 0;

  }

};

#if !GTEST_OS_SYMBIAN

// Compiling this test on Nokia's Symbian compiler fails with:

//  'Result' is not a member of class 'testing::internal::Function<int>'

//  (point of instantiation: '@unnamed@gmock_actions_test_cc@::

//      ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()')

// with no obvious fix.

TEST(ActionTest, CanBeConvertedToOtherActionType) {

  const Action<bool(int)> a1(new IsNotZero);  // NOLINT

  const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT

  EXPECT_EQ(1, a2.Perform(make_tuple('a')));

  EXPECT_EQ(0, a2.Perform(make_tuple('\0')));

}

#endif  // !GTEST_OS_SYMBIAN

// The following two classes are for testing MakePolymorphicAction().

// Implements a polymorphic action that returns the second of the

// arguments it receives.

class ReturnSecondArgumentAction {

 public:

  // We want to verify that MakePolymorphicAction() can work with a

  // polymorphic action whose Perform() method template is either

  // const or not.  This lets us verify the non-const case.

  template <typename Result, typename ArgumentTuple>

  Result Perform(const ArgumentTuple& args) { return get<1>(args); }

};

// Implements a polymorphic action that can be used in a nullary

// function to return 0.

class ReturnZeroFromNullaryFunctionAction {

 public:

  // For testing that MakePolymorphicAction() works when the

  // implementation class' Perform() method template takes only one

  // template parameter.

  //

  // We want to verify that MakePolymorphicAction() can work with a

  // polymorphic action whose Perform() method template is either

  // const or not.  This lets us verify the const case.

  template <typename Result>

  Result Perform(const tuple<>&) const { return 0; }

};

// These functions verify that MakePolymorphicAction() returns a

// PolymorphicAction<T> where T is the argument's type.

PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {

  return MakePolymorphicAction(ReturnSecondArgumentAction());

}

PolymorphicAction<ReturnZeroFromNullaryFunctionAction>

ReturnZeroFromNullaryFunction() {

  return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());

}

// Tests that MakePolymorphicAction() turns a polymorphic action

// implementation class into a polymorphic action.

TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {

  Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT

  EXPECT_EQ(5, a1.Perform(make_tuple(false, 5, 2.0)));

}

// Tests that MakePolymorphicAction() works when the implementation

// class' Perform() method template has only one template parameter.

TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {

  Action<int()> a1 = ReturnZeroFromNullaryFunction();

  EXPECT_EQ(0, a1.Perform(make_tuple()));

  Action<void*()> a2 = ReturnZeroFromNullaryFunction();

  EXPECT_TRUE(a2.Perform(make_tuple()) == NULL);

}

// Tests that Return() works as an action for void-returning

// functions.

TEST(ReturnTest, WorksForVoid) {

  const Action<void(int)> ret = Return();  // NOLINT

  return ret.Perform(make_tuple(1));

}

// Tests that Return(v) returns v.

TEST(ReturnTest, ReturnsGivenValue) {

  Action<int()> ret = Return(1);  // NOLINT

  EXPECT_EQ(1, ret.Perform(make_tuple()));

  ret = Return(-5);

  EXPECT_EQ(-5, ret.Perform(make_tuple()));

}

// Tests that Return("string literal") works.

TEST(ReturnTest, AcceptsStringLiteral) {

  Action<const char*()> a1 = Return("Hello");

  EXPECT_STREQ("Hello", a1.Perform(make_tuple()));

  Action<std::string()> a2 = Return("world");

  EXPECT_EQ("world", a2.Perform(make_tuple()));

}

// Test struct which wraps a vector of integers. Used in

// 'SupportsWrapperReturnType' test.

struct IntegerVectorWrapper {

  std::vector<int> * v;

  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT

};

// Tests that Return() works when return type is a wrapper type.

TEST(ReturnTest, SupportsWrapperReturnType) {

  // Initialize vector of integers.

  std::vector<int> v;

  for (int i = 0; i < 5; ++i) v.push_back(i);

  // Return() called with 'v' as argument. The Action will return the same data

  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.

  Action<IntegerVectorWrapper()> a = Return(v);

  const std::vector<int>& result = *(a.Perform(make_tuple()).v);

  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));

}

// Tests that Return(v) is covaraint.

struct Base {

  bool operator==(const Base&) { return true; }

};

struct Derived : public Base {

  bool operator==(const Derived&) { return true; }

};

TEST(ReturnTest, IsCovariant) {

  Base base;

  Derived derived;

  Action<Base*()> ret = Return(&base);

  EXPECT_EQ(&base, ret.Perform(make_tuple()));

  ret = Return(&derived);

  EXPECT_EQ(&derived, ret.Perform(make_tuple()));

}

// Tests that the type of the value passed into Return is converted into T

// when the action is cast to Action<T(...)> rather than when the action is

// performed. See comments on testing::internal::ReturnAction in

// gmock-actions.h for more information.

class FromType {

 public:

  explicit FromType(bool* is_converted) : converted_(is_converted) {}

  bool* converted() const { return converted_; }

 private:

  bool* const converted_;

  GTEST_DISALLOW_ASSIGN_(FromType);

};

class ToType {

 public:

  // Must allow implicit conversion due to use in ImplicitCast_<T>.

  ToType(const FromType& x) { *x.converted() = true; }  // NOLINT

};

TEST(ReturnTest, ConvertsArgumentWhenConverted) {

  bool converted = false;

  FromType x(&converted);

  Action<ToType()> action(Return(x));

  EXPECT_TRUE(converted) << "Return must convert its argument in its own "

                         << "conversion operator.";

  converted = false;

  action.Perform(tuple<>());

  EXPECT_FALSE(converted) << "Action must NOT convert its argument "

                          << "when performed.";

}

class DestinationType {};

class SourceType {

 public:

  // Note: a non-const typecast operator.

  operator DestinationType() { return DestinationType(); }

};

TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {

  SourceType s;

  Action<DestinationType()> action(Return(s));

}

// Tests that ReturnNull() returns NULL in a pointer-returning function.

TEST(ReturnNullTest, WorksInPointerReturningFunction) {

  const Action<int*()> a1 = ReturnNull();

  EXPECT_TRUE(a1.Perform(make_tuple()) == NULL);

  const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT

  EXPECT_TRUE(a2.Perform(make_tuple(true)) == NULL);

}

#if GTEST_HAS_STD_UNIQUE_PTR_

// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning

// functions.

TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {

  const Action<std::unique_ptr<const int>()> a1 = ReturnNull();

  EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr);

  const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();

  EXPECT_TRUE(a2.Perform(make_tuple("foo")) == nullptr);

}

#endif  // GTEST_HAS_STD_UNIQUE_PTR_

// Tests that ReturnRef(v) works for reference types.

TEST(ReturnRefTest, WorksForReference) {

  const int n = 0;

  const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT

  EXPECT_EQ(&n, &ret.Perform(make_tuple(true)));

}

// Tests that ReturnRef(v) is covariant.

TEST(ReturnRefTest, IsCovariant) {

  Base base;

  Derived derived;

  Action<Base&()> a = ReturnRef(base);

  EXPECT_EQ(&base, &a.Perform(make_tuple()));

  a = ReturnRef(derived);

  EXPECT_EQ(&derived, &a.Perform(make_tuple()));

}

// Tests that ReturnRefOfCopy(v) works for reference types.

TEST(ReturnRefOfCopyTest, WorksForReference) {

  int n = 42;

  const Action<const int&()> ret = ReturnRefOfCopy(n);

  EXPECT_NE(&n, &ret.Perform(make_tuple()));

  EXPECT_EQ(42, ret.Perform(make_tuple()));

  n = 43;

  EXPECT_NE(&n, &ret.Perform(make_tuple()));

  EXPECT_EQ(42, ret.Perform(make_tuple()));

}

// Tests that ReturnRefOfCopy(v) is covariant.

TEST(ReturnRefOfCopyTest, IsCovariant) {

  Base base;

  Derived derived;

  Action<Base&()> a = ReturnRefOfCopy(base);

  EXPECT_NE(&base, &a.Perform(make_tuple()));

  a = ReturnRefOfCopy(derived);

  EXPECT_NE(&derived, &a.Perform(make_tuple()));

}

// Tests that DoDefault() does the default action for the mock method.

class MockClass {

 public:

  MockClass() {}

  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT

  MOCK_METHOD0(Foo, MyNonDefaultConstructible());

#if GTEST_HAS_STD_UNIQUE_PTR_

  MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());

  MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());

  MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());

#endif

 private:

  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);

};

// Tests that DoDefault() returns the built-in default value for the

// return type by default.

TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {

  MockClass mock;

  EXPECT_CALL(mock, IntFunc(_))

      .WillOnce(DoDefault());

  EXPECT_EQ(0, mock.IntFunc(true));

}

// Tests that DoDefault() throws (when exceptions are enabled) or aborts

// the process when there is no built-in default value for the return type.

TEST(DoDefaultDeathTest, DiesForUnknowType) {

  MockClass mock;

  EXPECT_CALL(mock, Foo())

      .WillRepeatedly(DoDefault());

#if GTEST_HAS_EXCEPTIONS

  EXPECT_ANY_THROW(mock.Foo());

#else

  EXPECT_DEATH_IF_SUPPORTED({

    mock.Foo();

  }, "");

#endif

}

// Tests that using DoDefault() inside a composite action leads to a

// run-time error.

void VoidFunc(bool /* flag */) {}

TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {

  MockClass mock;

  EXPECT_CALL(mock, IntFunc(_))

      .WillRepeatedly(DoAll(Invoke(VoidFunc),

                            DoDefault()));

  // Ideally we should verify the error message as well.  Sadly,

  // EXPECT_DEATH() can only capture stderr, while Google Mock's

  // errors are printed on stdout.  Therefore we have to settle for

  // not verifying the message.

  EXPECT_DEATH_IF_SUPPORTED({

    mock.IntFunc(true);

  }, "");

}

// Tests that DoDefault() returns the default value set by

// DefaultValue<T>::Set() when it's not overriden by an ON_CALL().

TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {

  DefaultValue<int>::Set(1);

  MockClass mock;

  EXPECT_CALL(mock, IntFunc(_))

      .WillOnce(DoDefault());

  EXPECT_EQ(1, mock.IntFunc(false));

  DefaultValue<int>::Clear();

}

// Tests that DoDefault() does the action specified by ON_CALL().

TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {

  MockClass mock;

  ON_CALL(mock, IntFunc(_))

      .WillByDefault(Return(2));

  EXPECT_CALL(mock, IntFunc(_))

      .WillOnce(DoDefault());

  EXPECT_EQ(2, mock.IntFunc(false));

}

// Tests that using DoDefault() in ON_CALL() leads to a run-time failure.

TEST(DoDefaultTest, CannotBeUsedInOnCall) {

  MockClass mock;

  EXPECT_NONFATAL_FAILURE({  // NOLINT

    ON_CALL(mock, IntFunc(_))

      .WillByDefault(DoDefault());

  }, "DoDefault() cannot be used in ON_CALL()");

}

// Tests that SetArgPointee<N>(v) sets the variable pointed to by

// the N-th (0-based) argument to v.

TEST(SetArgPointeeTest, SetsTheNthPointee) {

  typedef void MyFunction(bool, int*, char*);

  Action<MyFunction> a = SetArgPointee<1>(2);

  int n = 0;

  char ch = '\0';

  a.Perform(make_tuple(true, &n, &ch);;

  EXPECT_EQ(2, n);

  EXPECT_EQ('\0', ch);

  a = SetArgPointee<2>('a');

  n = 0;

  ch = '\0';

  a.Perform(make_tuple(true, &n, &ch);;

  EXPECT_EQ(0, n);

  EXPECT_EQ('a', ch);

}

#if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)

// Tests that SetArgPointee<N>() accepts a string literal.

// GCC prior to v4.0 and the Symbian compiler do not support this.

TEST(SetArgPointeeTest, AcceptsStringLiteral) {

  typedef void MyFunction(std::string*, const char**);

  Action<MyFunction> a = SetArgPointee<0>("hi");

  std::string str;

  const char* ptr = NULL;

  a.Perform(make_tuple(&str, &ptr));

  EXPECT_EQ("hi", str);

  EXPECT_TRUE(ptr == NULL);

  a = SetArgPointee<1>("world");

  str = "";

  a.Perform(make_tuple(&str, &ptr));

  EXPECT_EQ("", str);

  EXPECT_STREQ("world", ptr);

}

TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {

  typedef void MyFunction(const wchar_t**);

  Action<MyFunction> a = SetArgPointee<0>(L"world");

  const wchar_t* ptr = NULL;

  a.Perform(make_tuple(&ptr));

  EXPECT_STREQ(L"world", ptr);

# if GTEST_HAS_STD_WSTRING

  typedef void MyStringFunction(std::wstring*);

  Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");

  std::wstring str = L"";

  a2.Perform(make_tuple(&str);;

  EXPECT_EQ(L"world", str);

# endif

}

#endif

// Tests that SetArgPointee<N>() accepts a char pointer.

TEST(SetArgPointeeTest, AcceptsCharPointer) {

  typedef void MyFunction(bool, std::string*, const char**);

  const char* const hi = "hi";

  Action<MyFunction> a = SetArgPointee<1>(hi);

  std::string str;

  const char* ptr = NULL;

  a.Perform(make_tuple(true, &str, &ptr));

  EXPECT_EQ("hi", str);

  EXPECT_TRUE(ptr == NULL);

  char world_array[] = "world";

  char* const world = world_array;

  a = SetArgPointee<2>(world);

  str = "";

  a.Perform(make_tuple(true, &str, &ptr));

  EXPECT_EQ("", str);

  EXPECT_EQ(world, ptr);

}

TEST(SetArgPointeeTest, AcceptsWideCharPointer) {

  typedef void MyFunction(bool, const wchar_t**);

  const wchar_t* const hi = L"hi";

  Action<MyFunction> a = SetArgPointee<1>(hi);

  const wchar_t* ptr = NULL;

  a.Perform(make_tuple(true, &ptr));

  EXPECT_EQ(hi, ptr);

# if GTEST_HAS_STD_WSTRING

  typedef void MyStringFunction(bool, std::wstring*);

  wchar_t world_array[] = L"world";

  wchar_t* const world = world_array;

  Action<MyStringFunction> a2 = SetArgPointee<1>(world);

  std::wstring str;

  a2.Perform(make_tuple(true, &str);;

  EXPECT_EQ(world_array, str);

# endif

}