diff options
author | Billy Donahue <billydonahue@google.com> | 2015-08-25 21:47:18 (GMT) |
---|---|---|
committer | Billy Donahue <billydonahue@google.com> | 2015-08-25 21:47:18 (GMT) |
commit | affb09edf0dfac4e8570f99ed5af09543a7ffe4f (patch) | |
tree | 064c85249da7e9b91178342b84a4a9a3487ce0b1 /googlemock/test/gmock-actions_test.cc | |
parent | 84b8863dd93401b9d02f782fb5c548cc51ff1701 (diff) | |
download | googletest-affb09edf0dfac4e8570f99ed5af09543a7ffe4f.zip googletest-affb09edf0dfac4e8570f99ed5af09543a7ffe4f.tar.gz googletest-affb09edf0dfac4e8570f99ed5af09543a7ffe4f.tar.bz2 |
move googlemock files into googlemock/ subdir
Diffstat (limited to 'googlemock/test/gmock-actions_test.cc')
-rw-r--r-- | googlemock/test/gmock-actions_test.cc | 1411 |
1 files changed, 1411 insertions, 0 deletions
diff --git a/googlemock/test/gmock-actions_test.cc b/googlemock/test/gmock-actions_test.cc new file mode 100644 index 0000000..a665fc5 --- /dev/null +++ b/googlemock/test/gmock-actions_test.cc @@ -0,0 +1,1411 @@ +// 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_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>>()); +#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 +} + +#if GTEST_HAS_PROTOBUF_ + +// Tests that SetArgPointee<N>(proto_buffer) sets the v1 protobuf +// variable pointed to by the N-th (0-based) argument to proto_buffer. +TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferType) { + TestMessage* const msg = new TestMessage; + msg->set_member("yes"); + TestMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, TestMessage*)> a = SetArgPointee<1>(*msg); + // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer + // s.t. the action works even when the original proto_buffer has + // died. We ensure this behavior by deleting msg before using the + // action. + delete msg; + + TestMessage dest; + EXPECT_FALSE(orig_msg.Equals(dest)); + a.Perform(make_tuple(true, &dest)); + EXPECT_TRUE(orig_msg.Equals(dest)); +} + +// Tests that SetArgPointee<N>(proto_buffer) sets the +// ::ProtocolMessage variable pointed to by the N-th (0-based) +// argument to proto_buffer. +TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) { + TestMessage* const msg = new TestMessage; + msg->set_member("yes"); + TestMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, ::ProtocolMessage*)> a = SetArgPointee<1>(*msg); + // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer + // s.t. the action works even when the original proto_buffer has + // died. We ensure this behavior by deleting msg before using the + // action. + delete msg; + + TestMessage dest; + ::ProtocolMessage* const dest_base = &dest; + EXPECT_FALSE(orig_msg.Equals(dest)); + a.Perform(make_tuple(true, dest_base)); + EXPECT_TRUE(orig_msg.Equals(dest)); +} + +// Tests that SetArgPointee<N>(proto2_buffer) sets the v2 +// protobuf variable pointed to by the N-th (0-based) argument to +// proto2_buffer. +TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferType) { + using testing::internal::FooMessage; + FooMessage* const msg = new FooMessage; + msg->set_int_field(2); + msg->set_string_field("hi"); + FooMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, FooMessage*)> a = SetArgPointee<1>(*msg); + // SetArgPointee<N>(proto2_buffer) makes a copy of + // proto2_buffer s.t. the action works even when the original + // proto2_buffer has died. We ensure this behavior by deleting msg + // before using the action. + delete msg; + + FooMessage dest; + dest.set_int_field(0); + a.Perform(make_tuple(true, &dest)); + EXPECT_EQ(2, dest.int_field()); + EXPECT_EQ("hi", dest.string_field()); +} + +// Tests that SetArgPointee<N>(proto2_buffer) sets the +// proto2::Message variable pointed to by the N-th (0-based) argument +// to proto2_buffer. +TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) { + using testing::internal::FooMessage; + FooMessage* const msg = new FooMessage; + msg->set_int_field(2); + msg->set_string_field("hi"); + FooMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, ::proto2::Message*)> a = SetArgPointee<1>(*msg); + // SetArgPointee<N>(proto2_buffer) makes a copy of + // proto2_buffer s.t. the action works even when the original + // proto2_buffer has died. We ensure this behavior by deleting msg + // before using the action. + delete msg; + + FooMessage dest; + dest.set_int_field(0); + ::proto2::Message* const dest_base = &dest; + a.Perform(make_tuple(true, dest_base)); + EXPECT_EQ(2, dest.int_field()); + EXPECT_EQ("hi", dest.string_field()); +} + +#endif // GTEST_HAS_PROTOBUF_ + +// 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); +} + +#if GTEST_HAS_PROTOBUF_ + +// Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf +// variable pointed to by the N-th (0-based) argument to proto_buffer. +TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) { + TestMessage* const msg = new TestMessage; + msg->set_member("yes"); + TestMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, TestMessage*)> a = SetArgumentPointee<1>(*msg); + // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer + // s.t. the action works even when the original proto_buffer has + // died. We ensure this behavior by deleting msg before using the + // action. + delete msg; + + TestMessage dest; + EXPECT_FALSE(orig_msg.Equals(dest)); + a.Perform(make_tuple(true, &dest)); + EXPECT_TRUE(orig_msg.Equals(dest)); +} + +// Tests that SetArgumentPointee<N>(proto_buffer) sets the +// ::ProtocolMessage variable pointed to by the N-th (0-based) +// argument to proto_buffer. +TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) { + TestMessage* const msg = new TestMessage; + msg->set_member("yes"); + TestMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, ::ProtocolMessage*)> a = SetArgumentPointee<1>(*msg); + // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer + // s.t. the action works even when the original proto_buffer has + // died. We ensure this behavior by deleting msg before using the + // action. + delete msg; + + TestMessage dest; + ::ProtocolMessage* const dest_base = &dest; + EXPECT_FALSE(orig_msg.Equals(dest)); + a.Perform(make_tuple(true, dest_base)); + EXPECT_TRUE(orig_msg.Equals(dest)); +} + +// Tests that SetArgumentPointee<N>(proto2_buffer) sets the v2 +// protobuf variable pointed to by the N-th (0-based) argument to +// proto2_buffer. +TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) { + using testing::internal::FooMessage; + FooMessage* const msg = new FooMessage; + msg->set_int_field(2); + msg->set_string_field("hi"); + FooMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, FooMessage*)> a = SetArgumentPointee<1>(*msg); + // SetArgumentPointee<N>(proto2_buffer) makes a copy of + // proto2_buffer s.t. the action works even when the original + // proto2_buffer has died. We ensure this behavior by deleting msg + // before using the action. + delete msg; + + FooMessage dest; + dest.set_int_field(0); + a.Perform(make_tuple(true, &dest)); + EXPECT_EQ(2, dest.int_field()); + EXPECT_EQ("hi", dest.string_field()); +} + +// Tests that SetArgumentPointee<N>(proto2_buffer) sets the +// proto2::Message variable pointed to by the N-th (0-based) argument +// to proto2_buffer. +TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) { + using testing::internal::FooMessage; + FooMessage* const msg = new FooMessage; + msg->set_int_field(2); + msg->set_string_field("hi"); + FooMessage orig_msg; + orig_msg.CopyFrom(*msg); + + Action<void(bool, ::proto2::Message*)> a = SetArgumentPointee<1>(*msg); + // SetArgumentPointee<N>(proto2_buffer) makes a copy of + // proto2_buffer s.t. the action works even when the original + // proto2_buffer has died. We ensure this behavior by deleting msg + // before using the action. + delete msg; + + FooMessage dest; + dest.set_int_field(0); + ::proto2::Message* const dest_base = &dest; + a.Perform(make_tuple(true, dest_base)); + EXPECT_EQ(2, dest.int_field()); + EXPECT_EQ("hi", dest.string_field()); +} + +#endif // GTEST_HAS_PROTOBUF_ + +// 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]); +} + +#endif // GTEST_HAS_STD_UNIQUE_PTR_ + +} // Unnamed namespace |