From 6b50058889099e4287f683b97a86ca74607172c4 Mon Sep 17 00:00:00 2001 From: Jeff McGlynn Date: Thu, 26 Jul 2018 13:08:01 -0700 Subject: Remove third_party/googletest and reference git repo instead Use a Bazel git_repository rule to reference the git repository instead of bundling the source. Change-Id: I32a0970178cb87fbf0e381db2e2d51fcccab542f --- .../googlemock/test/gmock-actions_test.cc | 1575 -------------------- 1 file changed, 1575 deletions(-) delete mode 100644 third_party/googletest/googlemock/test/gmock-actions_test.cc (limited to 'third_party/googletest/googlemock/test/gmock-actions_test.cc') diff --git a/third_party/googletest/googlemock/test/gmock-actions_test.cc b/third_party/googletest/googlemock/test/gmock-actions_test.cc deleted file mode 100644 index 7fbb50d..0000000 --- a/third_party/googletest/googlemock/test/gmock-actions_test.cc +++ /dev/null @@ -1,1575 +0,0 @@ -// 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. - -// 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 -#include -#include -#include -#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 - -#if GTEST_HAS_PROTOBUF_ -using testing::internal::TestMessage; -#endif // GTEST_HAS_PROTOBUF_ - -// Tests that BuiltInDefaultValue::Get() returns NULL. -TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) { - EXPECT_TRUE(BuiltInDefaultValue::Get() == NULL); - EXPECT_TRUE(BuiltInDefaultValue::Get() == NULL); - EXPECT_TRUE(BuiltInDefaultValue::Get() == NULL); -} - -// Tests that BuiltInDefaultValue::Exists() return true. -TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) { - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -} - -// Tests that BuiltInDefaultValue::Get() returns 0 when T is a -// built-in numeric type. -TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) { - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); -#if GMOCK_HAS_SIGNED_WCHAR_T_ - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); -#endif -#if GMOCK_WCHAR_T_IS_NATIVE_ -#if !defined(__WCHAR_UNSIGNED__) - EXPECT_EQ(0, BuiltInDefaultValue::Get()); -#else - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); -#endif -#endif - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0U, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); -} - -// Tests that BuiltInDefaultValue::Exists() returns true when T is a -// built-in numeric type. -TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) { - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -#if GMOCK_HAS_SIGNED_WCHAR_T_ - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -#endif -#if GMOCK_WCHAR_T_IS_NATIVE_ - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -#endif - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); // NOLINT - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -} - -// Tests that BuiltInDefaultValue::Get() returns false. -TEST(BuiltInDefaultValueTest, IsFalseForBool) { - EXPECT_FALSE(BuiltInDefaultValue::Get()); -} - -// Tests that BuiltInDefaultValue::Exists() returns true. -TEST(BuiltInDefaultValueTest, BoolExists) { - EXPECT_TRUE(BuiltInDefaultValue::Exists()); -} - -// Tests that BuiltInDefaultValue::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::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::Get() returns the same -// value as BuiltInDefaultValue::Get() does. -TEST(BuiltInDefaultValueTest, WorksForConstTypes) { - EXPECT_EQ("", BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_TRUE(BuiltInDefaultValue::Get() == NULL); - EXPECT_FALSE(BuiltInDefaultValue::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::Exists()); -} - -TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) { - EXPECT_EQ(42, BuiltInDefaultValue::Get().value()); -} - -#endif // GTEST_LANG_CXX11 - -TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) { - EXPECT_FALSE(BuiltInDefaultValue::Exists()); -} - -// Tests that BuiltInDefaultValue::Get() aborts the program. -TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) { - EXPECT_DEATH_IF_SUPPORTED({ - BuiltInDefaultValue::Get(); - }, ""); - EXPECT_DEATH_IF_SUPPORTED({ - BuiltInDefaultValue::Get(); - }, ""); -} - -TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) { - EXPECT_DEATH_IF_SUPPORTED({ - BuiltInDefaultValue::Get(); - }, ""); -} - -// Tests that DefaultValue::IsSet() is false initially. -TEST(DefaultValueTest, IsInitiallyUnset) { - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); -} - -// Tests that DefaultValue can be set and then unset. -TEST(DefaultValueTest, CanBeSetAndUnset) { - EXPECT_TRUE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::Exists()); - - DefaultValue::Set(1); - DefaultValue::Set( - MyNonDefaultConstructible(42)); - - EXPECT_EQ(1, DefaultValue::Get()); - EXPECT_EQ(42, DefaultValue::Get().value()); - - EXPECT_TRUE(DefaultValue::Exists()); - EXPECT_TRUE(DefaultValue::Exists()); - - DefaultValue::Clear(); - DefaultValue::Clear(); - - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); - - EXPECT_TRUE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::Exists()); -} - -// Tests that DefaultValue::Get() returns the -// BuiltInDefaultValue::Get() when DefaultValue::IsSet() is -// false. -TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) { - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_TRUE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::Exists()); - - EXPECT_EQ(0, DefaultValue::Get()); - - EXPECT_DEATH_IF_SUPPORTED({ - DefaultValue::Get(); - }, ""); -} - -#if GTEST_HAS_STD_UNIQUE_PTR_ -TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) { - EXPECT_TRUE(DefaultValue>::Exists()); - EXPECT_TRUE(DefaultValue>::Get() == NULL); - DefaultValue>::SetFactory([] { - return std::unique_ptr(new int(42)); - }); - EXPECT_TRUE(DefaultValue>::Exists()); - std::unique_ptr i = DefaultValue>::Get(); - EXPECT_EQ(42, *i); -} -#endif // GTEST_HAS_STD_UNIQUE_PTR_ - -// Tests that DefaultValue::Get() returns void. -TEST(DefaultValueTest, GetWorksForVoid) { - return DefaultValue::Get(); -} - -// Tests using DefaultValue with a reference type. - -// Tests that DefaultValue::IsSet() is false initially. -TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) { - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); -} - -// Tests that DefaultValue::Exists is false initiallly. -TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) { - EXPECT_FALSE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::Exists()); -} - -// Tests that DefaultValue can be set and then unset. -TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) { - int n = 1; - DefaultValue::Set(n); - MyNonDefaultConstructible x(42); - DefaultValue::Set(x); - - EXPECT_TRUE(DefaultValue::Exists()); - EXPECT_TRUE(DefaultValue::Exists()); - - EXPECT_EQ(&n, &(DefaultValue::Get())); - EXPECT_EQ(&x, &(DefaultValue::Get())); - - DefaultValue::Clear(); - DefaultValue::Clear(); - - EXPECT_FALSE(DefaultValue::Exists()); - EXPECT_FALSE(DefaultValue::Exists()); - - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); -} - -// Tests that DefaultValue::Get() returns the -// BuiltInDefaultValue::Get() when DefaultValue::IsSet() is -// false. -TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) { - EXPECT_FALSE(DefaultValue::IsSet()); - EXPECT_FALSE(DefaultValue::IsSet()); - - EXPECT_DEATH_IF_SUPPORTED({ - DefaultValue::Get(); - }, ""); - EXPECT_DEATH_IF_SUPPORTED({ - DefaultValue::Get(); - }, ""); -} - -// Tests that ActionInterface can be implemented by defining the -// Perform method. - -typedef int MyGlobalFunction(bool, int); - -class MyActionImpl : public ActionInterface { - public: - virtual int Perform(const tuple& args) { - return get<0>(args) ? get<1>(args) : 0; - } -}; - -TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) { - MyActionImpl my_action_impl; - (void)my_action_impl; -} - -TEST(ActionInterfaceTest, MakeAction) { - Action action = MakeAction(new MyActionImpl); - - // When exercising the Perform() method of Action, 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, and so on. - EXPECT_EQ(5, action.Perform(make_tuple(true, 5))); -} - -// Tests that Action can be contructed from a pointer to -// ActionInterface. -TEST(ActionTest, CanBeConstructedFromActionInterface) { - Action action(new MyActionImpl); -} - -// Tests that Action delegates actual work to ActionInterface. -TEST(ActionTest, DelegatesWorkToActionInterface) { - const Action action(new MyActionImpl); - - EXPECT_EQ(5, action.Perform(make_tuple(true, 5))); - EXPECT_EQ(0, action.Perform(make_tuple(false, 1))); -} - -// Tests that Action can be copied. -TEST(ActionTest, IsCopyable) { - Action a1(new MyActionImpl); - Action 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 object can be converted to a -// compatible Action object. - -class IsNotZero : public ActionInterface { // NOLINT - public: - virtual bool Perform(const tuple& 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' -// (point of instantiation: '@unnamed@gmock_actions_test_cc@:: -// ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()') -// with no obvious fix. -TEST(ActionTest, CanBeConvertedToOtherActionType) { - const Action a1(new IsNotZero); // NOLINT - const Action a2 = Action(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 - 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 - Result Perform(const tuple<>&) const { return 0; } -}; - -// These functions verify that MakePolymorphicAction() returns a -// PolymorphicAction where T is the argument's type. - -PolymorphicAction ReturnSecondArgument() { - return MakePolymorphicAction(ReturnSecondArgumentAction()); -} - -PolymorphicAction -ReturnZeroFromNullaryFunction() { - return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction()); -} - -// Tests that MakePolymorphicAction() turns a polymorphic action -// implementation class into a polymorphic action. -TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) { - Action 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 a1 = ReturnZeroFromNullaryFunction(); - EXPECT_EQ(0, a1.Perform(make_tuple())); - - Action 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 ret = Return(); // NOLINT - return ret.Perform(make_tuple(1)); -} - -// Tests that Return(v) returns v. -TEST(ReturnTest, ReturnsGivenValue) { - Action 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 a1 = Return("Hello"); - EXPECT_STREQ("Hello", a1.Perform(make_tuple())); - - Action 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 * v; - IntegerVectorWrapper(std::vector& _v) : v(&_v) {} // NOLINT -}; - -// Tests that Return() works when return type is a wrapper type. -TEST(ReturnTest, SupportsWrapperReturnType) { - // Initialize vector of integers. - std::vector 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 a = Return(v); - const std::vector& 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 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 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_. - ToType(const FromType& x) { *x.converted() = true; } // NOLINT -}; - -TEST(ReturnTest, ConvertsArgumentWhenConverted) { - bool converted = false; - FromType x(&converted); - Action 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 action(Return(s)); -} - -// Tests that ReturnNull() returns NULL in a pointer-returning function. -TEST(ReturnNullTest, WorksInPointerReturningFunction) { - const Action a1 = ReturnNull(); - EXPECT_TRUE(a1.Perform(make_tuple()) == NULL); - - const Action 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()> a1 = ReturnNull(); - EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr); - - const Action(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 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 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 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 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()); - MOCK_METHOD0(MakeUniqueBase, std::unique_ptr()); - MOCK_METHOD0(MakeVectorUnique, std::vector>()); - MOCK_METHOD1(TakeUnique, int(std::unique_ptr)); - MOCK_METHOD2(TakeUnique, - int(const std::unique_ptr&, std::unique_ptr)); -#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::Set() when it's not overriden by an ON_CALL(). -TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) { - DefaultValue::Set(1); - MockClass mock; - EXPECT_CALL(mock, IntFunc(_)) - .WillOnce(DoDefault()); - EXPECT_EQ(1, mock.IntFunc(false)); - DefaultValue::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(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 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() 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 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 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 a2 = SetArgPointee<0>(L"world"); - std::wstring str = L""; - a2.Perform(make_tuple(&str)); - EXPECT_EQ(L"world", str); - -# endif -} -#endif - -// Tests that SetArgPointee() accepts a char pointer. -TEST(SetArgPointeeTest, AcceptsCharPointer) { - typedef void MyFunction(bool, std::string*, const char**); - const char* const hi = "hi"; - Action 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 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 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(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 a = SetArgPointee<1>(*msg); - // SetArgPointee(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(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 a = SetArgPointee<1>(*msg); - // SetArgPointee(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(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 a = SetArgPointee<1>(*msg); - // SetArgPointee(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(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 a = SetArgPointee<1>(*msg); - // SetArgPointee(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(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 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(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 a = SetArgumentPointee<1>(*msg); - // SetArgumentPointee(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(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 a = SetArgumentPointee<1>(*msg); - // SetArgumentPointee(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(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 a = SetArgumentPointee<1>(*msg); - // SetArgumentPointee(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(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 a = SetArgumentPointee<1>(*msg); - // SetArgumentPointee(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 a = InvokeWithoutArgs(Nullary); // NOLINT - EXPECT_EQ(1, a.Perform(make_tuple(2))); - - // As an action that takes two arguments. - Action a2 = InvokeWithoutArgs(Nullary); // NOLINT - EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5))); - - // As an action that returns void. - Action 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 a = InvokeWithoutArgs(NullaryFunctor()); // NOLINT - EXPECT_EQ(2, a.Perform(make_tuple())); - - // As an action that takes three arguments. - Action a2 = // NOLINT - InvokeWithoutArgs(NullaryFunctor()); - EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a'))); - - // As an action that returns void. - Action 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 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 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 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 a = - IgnoreResult(Invoke(ReturnMyNonDefaultConstructible)); // NOLINT - a.Perform(make_tuple(2)); - EXPECT_TRUE(g_done); -} - -TEST(AssignTest, Int) { - int x = 0; - Action a = Assign(&x, 5); - a.Perform(make_tuple(0)); - EXPECT_EQ(5, x); -} - -TEST(AssignTest, String) { - ::std::string x; - Action a = Assign(&x, "Hello, world"); - a.Perform(make_tuple()); - EXPECT_EQ("Hello, world", x); -} - -TEST(AssignTest, CompatibleTypes) { - double x = 0; - Action 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 a = SetErrnoAndReturn(ENOTTY, -5); - EXPECT_EQ(-5, a.Perform(make_tuple())); - EXPECT_EQ(ENOTTY, errno); -} - -TEST_F(SetErrnoAndReturnTest, Ptr) { - int x; - Action a = SetErrnoAndReturn(ENOTTY, &x); - EXPECT_EQ(&x, a.Perform(make_tuple())); - EXPECT_EQ(ENOTTY, errno); -} - -TEST_F(SetErrnoAndReturnTest, CompatibleTypes) { - Action 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 is copyable. -TEST(ByRefTest, IsCopyable) { - const std::string s1 = "Hi"; - const std::string s2 = "Hello"; - - ::testing::internal::ReferenceWrapper 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 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(n); - EXPECT_EQ(&n, &r1); - - // ByRef(n); // This shouldn't compile - we have a negative - // compilation test to catch it. - - Derived d; - Derived& r2 = ByRef(d); - EXPECT_EQ(&d, &r2); - - const Derived& r3 = ByRef(d); - EXPECT_EQ(&d, &r3); - - Base& r4 = ByRef(d); - EXPECT_EQ(&d, &r4); - - const Base& r5 = ByRef(d); - EXPECT_EQ(&d, &r5); - - // The following shouldn't compile - we have a negative compilation - // test for it. - // - // Base b; - // ByRef(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::Print(n, &expected); - testing::internal::UniversalPrint(ByRef(n), &actual); - EXPECT_EQ(expected.str(), actual.str()); -} - -#if GTEST_HAS_STD_UNIQUE_PTR_ - -std::unique_ptr UniquePtrSource() { - return std::unique_ptr(new int(19)); -} - -std::vector> VectorUniquePtrSource() { - std::vector> out; - out.emplace_back(new int(7)); - return out; -} - -TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) { - MockClass mock; - std::unique_ptr 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(d)))); - - std::unique_ptr result1 = mock.MakeUnique(); - EXPECT_EQ(19, *result1); - - std::vector> vresult = mock.MakeVectorUnique(); - EXPECT_EQ(1u, vresult.size()); - EXPECT_NE(nullptr, vresult[0]); - EXPECT_EQ(7, *vresult[0]); - - std::unique_ptr result2 = mock.MakeUniqueBase(); - EXPECT_EQ(d, result2.get()); -} - -TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) { - testing::MockFunction mock_function; - MockClass mock; - std::unique_ptr i(new int(19)); - EXPECT_CALL(mock_function, Call()); - EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll( - InvokeWithoutArgs(&mock_function, &testing::MockFunction::Call), - Return(ByMove(std::move(i))))); - - std::unique_ptr result1 = mock.MakeUnique(); - EXPECT_EQ(19, *result1); -} - -TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) { - MockClass mock; - - // Check default value - DefaultValue>::SetFactory([] { - return std::unique_ptr(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 result1 = mock.MakeUnique(); - EXPECT_EQ(19, *result1); - std::unique_ptr result2 = mock.MakeUnique(); - EXPECT_EQ(19, *result2); - EXPECT_NE(result1, result2); - - std::vector> 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(new int(i)); }; - - EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr 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 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& i, std::unique_ptr j) { - return *i * *j; - }); - EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7))); - - // The unique_ptr can be saved by the action. - std::unique_ptr saved; - EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr 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 ptr) { return *ptr; } - -struct Double { - template - T operator()(T t) { return 2 * t; } -}; - -std::unique_ptr UniqueInt(int i) { - return std::unique_ptr(new int(i)); -} - -TEST(FunctorActionTest, ActionFromFunction) { - Action 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)> a1 = &Deref; - EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7)))); -} - -TEST(FunctorActionTest, ActionFromLambda) { - Action 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 saved; - Action)> a2 = [&saved](std::unique_ptr p) { - saved = std::move(p); - }; - a2.Perform(make_tuple(UniqueInt(5))); - EXPECT_EQ(5, *saved); -} - -TEST(FunctorActionTest, PolymorphicFunctor) { - Action ai = Double(); - EXPECT_EQ(2, ai.Perform(make_tuple(1))); - Action ad = Double(); // Double? Double double! - EXPECT_EQ(3.0, ad.Perform(make_tuple(1.5))); -} - -TEST(FunctorActionTest, TypeConversion) { - // Numeric promotions are allowed. - const Action a1 = [](int i) { return i > 1; }; - const Action a2 = Action(a1); - EXPECT_EQ(1, a1.Perform(make_tuple(42))); - EXPECT_EQ(0, a2.Perform(make_tuple(42))); - - // Implicit constructors are allowed. - const Action s1 = [](std::string s) { return !s.empty(); }; - const Action s2 = Action(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 x = [](Unused) { return 42; }; - EXPECT_TRUE(x.Perform(make_tuple("hello"))); -} - -TEST(FunctorActionTest, UnusedArguments) { - // Verify that users can ignore uninteresting arguments. - Action a = - [](int i, Unused, Unused) { return 2 * i; }; - tuple 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. -// TODO(rburny): 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)> 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, 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 - -- cgit v1.2.3