gmock-actions_test.cc
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Tue, Nov 19, 07:39

gmock-actions_test.cc
View Options

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

	// Silence C4800 (C4800: 'int *const ': forcing value
	// to bool 'true' or 'false') for MSVC 14,15
	#ifdef _MSC_VER
	#if _MSC_VER <= 1900
	# pragma warning(push)
	# pragma warning(disable:4800)
	#endif
	#endif

	#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::Unused;
	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

	// 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_
	#if !defined(__WCHAR_UNSIGNED__)
	EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
	#else
	EXPECT_EQ(0U, BuiltInDefaultValue<wchar_t>::Get());
	#endif
	#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_LANG_CXX11

	TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
	EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
	}

	TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
	EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
	}

	#endif // GTEST_LANG_CXX11

	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>>());
	MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
	MOCK_METHOD2(TakeUnique,
	int(const std::unique_ptr<int>&, 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
	}

	// Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
	// the N-th (0-based) argument to v.
	TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
	typedef void MyFunction(bool, int, char);
	Action<MyFunction> a = SetArgumentPointee<1>(2);

	int n = 0;
	char ch = '\0';
	a.Perform(make_tuple(true, &n, &ch));
	EXPECT_EQ(2, n);
	EXPECT_EQ('\0', ch);

	a = SetArgumentPointee<2>('a');
	n = 0;
	ch = '\0';
	a.Perform(make_tuple(true, &n, &ch));
	EXPECT_EQ(0, n);
	EXPECT_EQ('a', ch);
	}

	// Sample functions and functors for testing Invoke() and etc.
	int Nullary() { return 1; }

	class NullaryFunctor {
	public:
	int operator()() { return 2; }
	};

	bool g_done = false;
	void VoidNullary() { g_done = true; }

	class VoidNullaryFunctor {
	public:
	void operator()() { g_done = true; }
	};

	class Foo {
	public:
	Foo() : value_(123) {}

	int Nullary() const { return value_; }

	private:
	int value_;
	};

	// Tests InvokeWithoutArgs(function).
	TEST(InvokeWithoutArgsTest, Function) {
	// As an action that takes one argument.
	Action<int(int)> a = InvokeWithoutArgs(Nullary); // NOLINT
	EXPECT_EQ(1, a.Perform(make_tuple(2)));

	// As an action that takes two arguments.
	Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary); // NOLINT
	EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));

	// As an action that returns void.
	Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary); // NOLINT
	g_done = false;
	a3.Perform(make_tuple(1));
	EXPECT_TRUE(g_done);
	}

	// Tests InvokeWithoutArgs(functor).
	TEST(InvokeWithoutArgsTest, Functor) {
	// As an action that takes no argument.
	Action<int()> a = InvokeWithoutArgs(NullaryFunctor()); // NOLINT
	EXPECT_EQ(2, a.Perform(make_tuple()));

	// As an action that takes three arguments.
	Action<int(int, double, char)> a2 = // NOLINT
	InvokeWithoutArgs(NullaryFunctor());
	EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));

	// As an action that returns void.
	Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
	g_done = false;
	a3.Perform(make_tuple());
	EXPECT_TRUE(g_done);
	}

	// Tests InvokeWithoutArgs(obj_ptr, method).
	TEST(InvokeWithoutArgsTest, Method) {
	Foo foo;
	Action<int(bool, char)> a = // NOLINT
	InvokeWithoutArgs(&foo, &Foo::Nullary);
	EXPECT_EQ(123, a.Perform(make_tuple(true, 'a')));
	}

	// Tests using IgnoreResult() on a polymorphic action.
	TEST(IgnoreResultTest, PolymorphicAction) {
	Action<void(int)> a = IgnoreResult(Return(5)); // NOLINT
	a.Perform(make_tuple(1));
	}

	// Tests using IgnoreResult() on a monomorphic action.

	int ReturnOne() {
	g_done = true;
	return 1;
	}

	TEST(IgnoreResultTest, MonomorphicAction) {
	g_done = false;
	Action<void()> a = IgnoreResult(Invoke(ReturnOne));
	a.Perform(make_tuple());
	EXPECT_TRUE(g_done);
	}

	// Tests using IgnoreResult() on an action that returns a class type.

	MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
	g_done = true;
	return MyNonDefaultConstructible(42);
	}

	TEST(IgnoreResultTest, ActionReturningClass) {
	g_done = false;
	Action<void(int)> a =
	IgnoreResult(Invoke(ReturnMyNonDefaultConstructible)); // NOLINT
	a.Perform(make_tuple(2));
	EXPECT_TRUE(g_done);
	}

	TEST(AssignTest, Int) {
	int x = 0;
	Action<void(int)> a = Assign(&x, 5);
	a.Perform(make_tuple(0));
	EXPECT_EQ(5, x);
	}

	TEST(AssignTest, String) {
	::std::string x;
	Action<void(void)> a = Assign(&x, "Hello, world");
	a.Perform(make_tuple());
	EXPECT_EQ("Hello, world", x);
	}

	TEST(AssignTest, CompatibleTypes) {
	double x = 0;
	Action<void(int)> a = Assign(&x, 5);
	a.Perform(make_tuple(0));
	EXPECT_DOUBLE_EQ(5, x);
	}

	#if !GTEST_OS_WINDOWS_MOBILE

	class SetErrnoAndReturnTest : public testing::Test {
	protected:
	virtual void SetUp() { errno = 0; }
	virtual void TearDown() { errno = 0; }
	};

	TEST_F(SetErrnoAndReturnTest, Int) {
	Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
	EXPECT_EQ(-5, a.Perform(make_tuple()));
	EXPECT_EQ(ENOTTY, errno);
	}

	TEST_F(SetErrnoAndReturnTest, Ptr) {
	int x;
	Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
	EXPECT_EQ(&x, a.Perform(make_tuple()));
	EXPECT_EQ(ENOTTY, errno);
	}

	TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
	Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
	EXPECT_DOUBLE_EQ(5.0, a.Perform(make_tuple()));
	EXPECT_EQ(EINVAL, errno);
	}

	#endif // !GTEST_OS_WINDOWS_MOBILE

	// Tests ByRef().

	// Tests that ReferenceWrapper<T> is copyable.
	TEST(ByRefTest, IsCopyable) {
	const std::string s1 = "Hi";
	const std::string s2 = "Hello";

	::testing::internal::ReferenceWrapper<const std::string> ref_wrapper =
	ByRef(s1);
	const std::string& r1 = ref_wrapper;
	EXPECT_EQ(&s1, &r1);

	// Assigns a new value to ref_wrapper.
	ref_wrapper = ByRef(s2);
	const std::string& r2 = ref_wrapper;
	EXPECT_EQ(&s2, &r2);

	::testing::internal::ReferenceWrapper<const std::string> ref_wrapper1 =
	ByRef(s1);
	// Copies ref_wrapper1 to ref_wrapper.
	ref_wrapper = ref_wrapper1;
	const std::string& r3 = ref_wrapper;
	EXPECT_EQ(&s1, &r3);
	}

	// Tests using ByRef() on a const value.
	TEST(ByRefTest, ConstValue) {
	const int n = 0;
	// int& ref = ByRef(n); // This shouldn't compile - we have a
	// negative compilation test to catch it.
	const int& const_ref = ByRef(n);
	EXPECT_EQ(&n, &const_ref);
	}

	// Tests using ByRef() on a non-const value.
	TEST(ByRefTest, NonConstValue) {
	int n = 0;

	// ByRef(n) can be used as either an int&,
	int& ref = ByRef(n);
	EXPECT_EQ(&n, &ref);

	// or a const int&.
	const int& const_ref = ByRef(n);
	EXPECT_EQ(&n, &const_ref);
	}

	// Tests explicitly specifying the type when using ByRef().
	TEST(ByRefTest, ExplicitType) {
	int n = 0;
	const int& r1 = ByRef<const int>(n);
	EXPECT_EQ(&n, &r1);

	// ByRef<char>(n); // This shouldn't compile - we have a negative
	// compilation test to catch it.

	Derived d;
	Derived& r2 = ByRef<Derived>(d);
	EXPECT_EQ(&d, &r2);

	const Derived& r3 = ByRef<const Derived>(d);
	EXPECT_EQ(&d, &r3);

	Base& r4 = ByRef<Base>(d);
	EXPECT_EQ(&d, &r4);

	const Base& r5 = ByRef<const Base>(d);
	EXPECT_EQ(&d, &r5);

	// The following shouldn't compile - we have a negative compilation
	// test for it.
	//
	// Base b;
	// ByRef<Derived>(b);
	}

	// Tests that Google Mock prints expression ByRef(x) as a reference to x.
	TEST(ByRefTest, PrintsCorrectly) {
	int n = 42;
	::std::stringstream expected, actual;
	testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
	testing::internal::UniversalPrint(ByRef(n), &actual);
	EXPECT_EQ(expected.str(), actual.str());
	}

	#if GTEST_HAS_STD_UNIQUE_PTR_

	std::unique_ptr<int> UniquePtrSource() {
	return std::unique_ptr<int>(new int(19));
	}

	std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
	std::vector<std::unique_ptr<int>> out;
	out.emplace_back(new int(7));
	return out;
	}

	TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
	MockClass mock;
	std::unique_ptr<int> i(new int(19));
	EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
	EXPECT_CALL(mock, MakeVectorUnique())
	.WillOnce(Return(ByMove(VectorUniquePtrSource())));
	Derived* d = new Derived;
	EXPECT_CALL(mock, MakeUniqueBase())
	.WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));

	std::unique_ptr<int> result1 = mock.MakeUnique();
	EXPECT_EQ(19, *result1);

	std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
	EXPECT_EQ(1u, vresult.size());
	EXPECT_NE(nullptr, vresult[0]);
	EXPECT_EQ(7, *vresult[0]);

	std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
	EXPECT_EQ(d, result2.get());
	}

	TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
	testing::MockFunction<void()> mock_function;
	MockClass mock;
	std::unique_ptr<int> i(new int(19));
	EXPECT_CALL(mock_function, Call());
	EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
	InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
	Return(ByMove(std::move(i)))));

	std::unique_ptr<int> result1 = mock.MakeUnique();
	EXPECT_EQ(19, *result1);
	}

	TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
	MockClass mock;

	// Check default value
	DefaultValue<std::unique_ptr<int>>::SetFactory([] {
	return std::unique_ptr<int>(new int(42));
	});
	EXPECT_EQ(42, *mock.MakeUnique());

	EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
	EXPECT_CALL(mock, MakeVectorUnique())
	.WillRepeatedly(Invoke(VectorUniquePtrSource));
	std::unique_ptr<int> result1 = mock.MakeUnique();
	EXPECT_EQ(19, *result1);
	std::unique_ptr<int> result2 = mock.MakeUnique();
	EXPECT_EQ(19, *result2);
	EXPECT_NE(result1, result2);

	std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
	EXPECT_EQ(1u, vresult.size());
	EXPECT_NE(nullptr, vresult[0]);
	EXPECT_EQ(7, *vresult[0]);
	}

	TEST(MockMethodTest, CanTakeMoveOnlyValue) {
	MockClass mock;
	auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };

	EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
	return *i;
	});
	// DoAll() does not compile, since it would move from its arguments twice.
	// EXPECT_CALL(mock, TakeUnique(_, _))
	// .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
	// Return(1)));
	EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
	.WillOnce(Return(-7))
	.RetiresOnSaturation();
	EXPECT_CALL(mock, TakeUnique(testing::IsNull()))
	.WillOnce(Return(-1))
	.RetiresOnSaturation();

	EXPECT_EQ(5, mock.TakeUnique(make(5)));
	EXPECT_EQ(-7, mock.TakeUnique(make(7)));
	EXPECT_EQ(7, mock.TakeUnique(make(7)));
	EXPECT_EQ(7, mock.TakeUnique(make(7)));
	EXPECT_EQ(-1, mock.TakeUnique({}));

	// Some arguments are moved, some passed by reference.
	auto lvalue = make(6);
	EXPECT_CALL(mock, TakeUnique(_, _))
	.WillOnce([](const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
	return i *j;
	});
	EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7)));

	// The unique_ptr can be saved by the action.
	std::unique_ptr<int> saved;
	EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
	saved = std::move(i);
	return 0;
	});
	EXPECT_EQ(0, mock.TakeUnique(make(42)));
	EXPECT_EQ(42, *saved);
	}

	#endif // GTEST_HAS_STD_UNIQUE_PTR_

	#if GTEST_LANG_CXX11
	// Tests for std::function based action.

	int Add(int val, int& ref, int* ptr) { // NOLINT
	int result = val + ref + *ptr;
	ref = 42;
	*ptr = 43;
	return result;
	}

	int Deref(std::unique_ptr<int> ptr) { return *ptr; }

	struct Double {
	template <typename T>
	T operator()(T t) { return 2 * t; }
	};

	std::unique_ptr<int> UniqueInt(int i) {
	return std::unique_ptr<int>(new int(i));
	}

	TEST(FunctorActionTest, ActionFromFunction) {
	Action<int(int, int&, int*)> a = &Add;
	int x = 1, y = 2, z = 3;
	EXPECT_EQ(6, a.Perform(std::forward_as_tuple(x, y, &z)));
	EXPECT_EQ(42, y);
	EXPECT_EQ(43, z);

	Action<int(std::unique_ptr<int>)> a1 = &Deref;
	EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
	}

	TEST(FunctorActionTest, ActionFromLambda) {
	Action<int(bool, int)> a1 = [](bool b, int i) { return b ? i : 0; };
	EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
	EXPECT_EQ(0, a1.Perform(make_tuple(false, 5)));

	std::unique_ptr<int> saved;
	Action<void(std::unique_ptr<int>)> a2 = [&saved](std::unique_ptr<int> p) {
	saved = std::move(p);
	};
	a2.Perform(make_tuple(UniqueInt(5)));
	EXPECT_EQ(5, *saved);
	}

	TEST(FunctorActionTest, PolymorphicFunctor) {
	Action<int(int)> ai = Double();
	EXPECT_EQ(2, ai.Perform(make_tuple(1)));
	Action<double(double)> ad = Double(); // Double? Double double!
	EXPECT_EQ(3.0, ad.Perform(make_tuple(1.5)));
	}

	TEST(FunctorActionTest, TypeConversion) {
	// Numeric promotions are allowed.
	const Action<bool(int)> a1 = [](int i) { return i > 1; };
	const Action<int(bool)> a2 = Action<int(bool)>(a1);
	EXPECT_EQ(1, a1.Perform(make_tuple(42)));
	EXPECT_EQ(0, a2.Perform(make_tuple(42)));

	// Implicit constructors are allowed.
	const Action<bool(std::string)> s1 = [](std::string s) { return !s.empty(); };
	const Action<int(const char)> s2 = Action<int(const char)>(s1);
	EXPECT_EQ(0, s2.Perform(make_tuple("")));
	EXPECT_EQ(1, s2.Perform(make_tuple("hello")));

	// Also between the lambda and the action itself.
	const Action<bool(std::string)> x = [](Unused) { return 42; };
	EXPECT_TRUE(x.Perform(make_tuple("hello")));
	}

	TEST(FunctorActionTest, UnusedArguments) {
	// Verify that users can ignore uninteresting arguments.
	Action<int(int, double y, double z)> a =
	[](int i, Unused, Unused) { return 2 * i; };
	tuple<int, double, double> dummy = make_tuple(3, 7.3, 9.44);
	EXPECT_EQ(6, a.Perform(dummy));
	}

	// Test that basic built-in actions work with move-only arguments.
	// FIXME: Currently, almost all ActionInterface-based actions will not
	// work, even if they only try to use other, copyable arguments. Implement them
	// if necessary (but note that DoAll cannot work on non-copyable types anyway -
	// so maybe it's better to make users use lambdas instead.
	TEST(MoveOnlyArgumentsTest, ReturningActions) {
	Action<int(std::unique_ptr<int>)> a = Return(1);
	EXPECT_EQ(1, a.Perform(make_tuple(nullptr)));

	a = testing::WithoutArgs([]() { return 7; });
	EXPECT_EQ(7, a.Perform(make_tuple(nullptr)));

	Action<void(std::unique_ptr<int>, int*)> a2 = testing::SetArgPointee<1>(3);
	int x = 0;
	a2.Perform(make_tuple(nullptr, &x));
	EXPECT_EQ(x, 3);
	}

	#endif // GTEST_LANG_CXX11

	} // Unnamed namespace

	#ifdef _MSC_VER
	#if _MSC_VER == 1900
	# pragma warning(pop)
	#endif
	#endif

gmock-actions_test.ccNo OneTemporaryActions

File Metadata

gmock-actions_test.ccView Options

Event Timeline

gmock-actions_test.cc
No OneTemporary
Actions

gmock-actions_test.cc
View Options