Home | History | Annotate | Download | only in test
      1 // Copyright 2007, Google Inc.
      2 // All rights reserved.
      3 //
      4 // Redistribution and use in source and binary forms, with or without
      5 // modification, are permitted provided that the following conditions are
      6 // met:
      7 //
      8 //     * Redistributions of source code must retain the above copyright
      9 // notice, this list of conditions and the following disclaimer.
     10 //     * Redistributions in binary form must reproduce the above
     11 // copyright notice, this list of conditions and the following disclaimer
     12 // in the documentation and/or other materials provided with the
     13 // distribution.
     14 //     * Neither the name of Google Inc. nor the names of its
     15 // contributors may be used to endorse or promote products derived from
     16 // this software without specific prior written permission.
     17 //
     18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29 //
     30 // Author: wan (at) google.com (Zhanyong Wan)
     31 
     32 // Google Mock - a framework for writing C++ mock classes.
     33 //
     34 // This file tests the built-in actions.
     35 
     36 #include "gmock/gmock-actions.h"
     37 #include <algorithm>
     38 #include <iterator>
     39 #include <memory>
     40 #include <string>
     41 #include "gmock/gmock.h"
     42 #include "gmock/internal/gmock-port.h"
     43 #include "gtest/gtest.h"
     44 #include "gtest/gtest-spi.h"
     45 
     46 namespace {
     47 
     48 // This list should be kept sorted.
     49 using testing::Action;
     50 using testing::ActionInterface;
     51 using testing::Assign;
     52 using testing::ByMove;
     53 using testing::ByRef;
     54 using testing::DefaultValue;
     55 using testing::DoDefault;
     56 using testing::IgnoreResult;
     57 using testing::Invoke;
     58 using testing::InvokeWithoutArgs;
     59 using testing::MakePolymorphicAction;
     60 using testing::Ne;
     61 using testing::PolymorphicAction;
     62 using testing::Return;
     63 using testing::ReturnNull;
     64 using testing::ReturnRef;
     65 using testing::ReturnRefOfCopy;
     66 using testing::SetArgPointee;
     67 using testing::SetArgumentPointee;
     68 using testing::_;
     69 using testing::get;
     70 using testing::internal::BuiltInDefaultValue;
     71 using testing::internal::Int64;
     72 using testing::internal::UInt64;
     73 using testing::make_tuple;
     74 using testing::tuple;
     75 using testing::tuple_element;
     76 
     77 #if !GTEST_OS_WINDOWS_MOBILE
     78 using testing::SetErrnoAndReturn;
     79 #endif
     80 
     81 #if GTEST_HAS_PROTOBUF_
     82 using testing::internal::TestMessage;
     83 #endif  // GTEST_HAS_PROTOBUF_
     84 
     85 // Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
     86 TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
     87   EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == NULL);
     88   EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == NULL);
     89   EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == NULL);
     90 }
     91 
     92 // Tests that BuiltInDefaultValue<T*>::Exists() return true.
     93 TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
     94   EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
     95   EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
     96   EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
     97 }
     98 
     99 // Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
    100 // built-in numeric type.
    101 TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
    102   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
    103   EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
    104   EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
    105 #if GMOCK_HAS_SIGNED_WCHAR_T_
    106   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
    107   EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
    108 #endif
    109 #if GMOCK_WCHAR_T_IS_NATIVE_
    110   EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
    111 #endif
    112   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
    113   EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
    114   EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
    115   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
    116   EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
    117   EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
    118   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
    119   EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
    120   EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
    121   EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
    122   EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
    123   EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
    124   EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
    125 }
    126 
    127 // Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
    128 // built-in numeric type.
    129 TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
    130   EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
    131   EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
    132   EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
    133 #if GMOCK_HAS_SIGNED_WCHAR_T_
    134   EXPECT_TRUE(BuiltInDefaultValue<unsigned wchar_t>::Exists());
    135   EXPECT_TRUE(BuiltInDefaultValue<signed wchar_t>::Exists());
    136 #endif
    137 #if GMOCK_WCHAR_T_IS_NATIVE_
    138   EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
    139 #endif
    140   EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
    141   EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
    142   EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
    143   EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
    144   EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
    145   EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
    146   EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
    147   EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
    148   EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
    149   EXPECT_TRUE(BuiltInDefaultValue<UInt64>::Exists());
    150   EXPECT_TRUE(BuiltInDefaultValue<Int64>::Exists());
    151   EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
    152   EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
    153 }
    154 
    155 // Tests that BuiltInDefaultValue<bool>::Get() returns false.
    156 TEST(BuiltInDefaultValueTest, IsFalseForBool) {
    157   EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
    158 }
    159 
    160 // Tests that BuiltInDefaultValue<bool>::Exists() returns true.
    161 TEST(BuiltInDefaultValueTest, BoolExists) {
    162   EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
    163 }
    164 
    165 // Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
    166 // string type.
    167 TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
    168 #if GTEST_HAS_GLOBAL_STRING
    169   EXPECT_EQ("", BuiltInDefaultValue< ::string>::Get());
    170 #endif  // GTEST_HAS_GLOBAL_STRING
    171 
    172   EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
    173 }
    174 
    175 // Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
    176 // string type.
    177 TEST(BuiltInDefaultValueTest, ExistsForString) {
    178 #if GTEST_HAS_GLOBAL_STRING
    179   EXPECT_TRUE(BuiltInDefaultValue< ::string>::Exists());
    180 #endif  // GTEST_HAS_GLOBAL_STRING
    181 
    182   EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
    183 }
    184 
    185 // Tests that BuiltInDefaultValue<const T>::Get() returns the same
    186 // value as BuiltInDefaultValue<T>::Get() does.
    187 TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
    188   EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
    189   EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
    190   EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == NULL);
    191   EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
    192 }
    193 
    194 // A type that's default constructible.
    195 class MyDefaultConstructible {
    196  public:
    197   MyDefaultConstructible() : value_(42) {}
    198 
    199   int value() const { return value_; }
    200 
    201  private:
    202   int value_;
    203 };
    204 
    205 // A type that's not default constructible.
    206 class MyNonDefaultConstructible {
    207  public:
    208   // Does not have a default ctor.
    209   explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
    210 
    211   int value() const { return value_; }
    212 
    213  private:
    214   int value_;
    215 };
    216 
    217 #if GTEST_LANG_CXX11
    218 
    219 TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
    220   EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
    221 }
    222 
    223 TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
    224   EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
    225 }
    226 
    227 #endif  // GTEST_LANG_CXX11
    228 
    229 TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
    230   EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
    231 }
    232 
    233 // Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
    234 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
    235   EXPECT_DEATH_IF_SUPPORTED({
    236     BuiltInDefaultValue<int&>::Get();
    237   }, "");
    238   EXPECT_DEATH_IF_SUPPORTED({
    239     BuiltInDefaultValue<const char&>::Get();
    240   }, "");
    241 }
    242 
    243 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
    244   EXPECT_DEATH_IF_SUPPORTED({
    245     BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
    246   }, "");
    247 }
    248 
    249 // Tests that DefaultValue<T>::IsSet() is false initially.
    250 TEST(DefaultValueTest, IsInitiallyUnset) {
    251   EXPECT_FALSE(DefaultValue<int>::IsSet());
    252   EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
    253   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
    254 }
    255 
    256 // Tests that DefaultValue<T> can be set and then unset.
    257 TEST(DefaultValueTest, CanBeSetAndUnset) {
    258   EXPECT_TRUE(DefaultValue<int>::Exists());
    259   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
    260 
    261   DefaultValue<int>::Set(1);
    262   DefaultValue<const MyNonDefaultConstructible>::Set(
    263       MyNonDefaultConstructible(42));
    264 
    265   EXPECT_EQ(1, DefaultValue<int>::Get());
    266   EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
    267 
    268   EXPECT_TRUE(DefaultValue<int>::Exists());
    269   EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
    270 
    271   DefaultValue<int>::Clear();
    272   DefaultValue<const MyNonDefaultConstructible>::Clear();
    273 
    274   EXPECT_FALSE(DefaultValue<int>::IsSet());
    275   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
    276 
    277   EXPECT_TRUE(DefaultValue<int>::Exists());
    278   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
    279 }
    280 
    281 // Tests that DefaultValue<T>::Get() returns the
    282 // BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
    283 // false.
    284 TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
    285   EXPECT_FALSE(DefaultValue<int>::IsSet());
    286   EXPECT_TRUE(DefaultValue<int>::Exists());
    287   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
    288   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
    289 
    290   EXPECT_EQ(0, DefaultValue<int>::Get());
    291 
    292   EXPECT_DEATH_IF_SUPPORTED({
    293     DefaultValue<MyNonDefaultConstructible>::Get();
    294   }, "");
    295 }
    296 
    297 #if GTEST_HAS_STD_UNIQUE_PTR_
    298 TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
    299   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
    300   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == NULL);
    301   DefaultValue<std::unique_ptr<int>>::SetFactory([] {
    302     return std::unique_ptr<int>(new int(42));
    303   });
    304   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
    305   std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
    306   EXPECT_EQ(42, *i);
    307 }
    308 #endif  // GTEST_HAS_STD_UNIQUE_PTR_
    309 
    310 // Tests that DefaultValue<void>::Get() returns void.
    311 TEST(DefaultValueTest, GetWorksForVoid) {
    312   return DefaultValue<void>::Get();
    313 }
    314 
    315 // Tests using DefaultValue with a reference type.
    316 
    317 // Tests that DefaultValue<T&>::IsSet() is false initially.
    318 TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
    319   EXPECT_FALSE(DefaultValue<int&>::IsSet());
    320   EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
    321   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
    322 }
    323 
    324 // Tests that DefaultValue<T&>::Exists is false initiallly.
    325 TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
    326   EXPECT_FALSE(DefaultValue<int&>::Exists());
    327   EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
    328   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
    329 }
    330 
    331 // Tests that DefaultValue<T&> can be set and then unset.
    332 TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
    333   int n = 1;
    334   DefaultValue<const int&>::Set(n);
    335   MyNonDefaultConstructible x(42);
    336   DefaultValue<MyNonDefaultConstructible&>::Set(x);
    337 
    338   EXPECT_TRUE(DefaultValue<const int&>::Exists());
    339   EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
    340 
    341   EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
    342   EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
    343 
    344   DefaultValue<const int&>::Clear();
    345   DefaultValue<MyNonDefaultConstructible&>::Clear();
    346 
    347   EXPECT_FALSE(DefaultValue<const int&>::Exists());
    348   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
    349 
    350   EXPECT_FALSE(DefaultValue<const int&>::IsSet());
    351   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
    352 }
    353 
    354 // Tests that DefaultValue<T&>::Get() returns the
    355 // BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
    356 // false.
    357 TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
    358   EXPECT_FALSE(DefaultValue<int&>::IsSet());
    359   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
    360 
    361   EXPECT_DEATH_IF_SUPPORTED({
    362     DefaultValue<int&>::Get();
    363   }, "");
    364   EXPECT_DEATH_IF_SUPPORTED({
    365     DefaultValue<MyNonDefaultConstructible>::Get();
    366   }, "");
    367 }
    368 
    369 // Tests that ActionInterface can be implemented by defining the
    370 // Perform method.
    371 
    372 typedef int MyGlobalFunction(bool, int);
    373 
    374 class MyActionImpl : public ActionInterface<MyGlobalFunction> {
    375  public:
    376   virtual int Perform(const tuple<bool, int>& args) {
    377     return get<0>(args) ? get<1>(args) : 0;
    378   }
    379 };
    380 
    381 TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
    382   MyActionImpl my_action_impl;
    383   (void)my_action_impl;
    384 }
    385 
    386 TEST(ActionInterfaceTest, MakeAction) {
    387   Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
    388 
    389   // When exercising the Perform() method of Action<F>, we must pass
    390   // it a tuple whose size and type are compatible with F's argument
    391   // types.  For example, if F is int(), then Perform() takes a
    392   // 0-tuple; if F is void(bool, int), then Perform() takes a
    393   // tuple<bool, int>, and so on.
    394   EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
    395 }
    396 
    397 // Tests that Action<F> can be contructed from a pointer to
    398 // ActionInterface<F>.
    399 TEST(ActionTest, CanBeConstructedFromActionInterface) {
    400   Action<MyGlobalFunction> action(new MyActionImpl);
    401 }
    402 
    403 // Tests that Action<F> delegates actual work to ActionInterface<F>.
    404 TEST(ActionTest, DelegatesWorkToActionInterface) {
    405   const Action<MyGlobalFunction> action(new MyActionImpl);
    406 
    407   EXPECT_EQ(5, action.Perform(make_tuple(true, 5)));
    408   EXPECT_EQ(0, action.Perform(make_tuple(false, 1)));
    409 }
    410 
    411 // Tests that Action<F> can be copied.
    412 TEST(ActionTest, IsCopyable) {
    413   Action<MyGlobalFunction> a1(new MyActionImpl);
    414   Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
    415 
    416   // a1 should continue to work after being copied from.
    417   EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
    418   EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
    419 
    420   // a2 should work like the action it was copied from.
    421   EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
    422   EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
    423 
    424   a2 = a1;  // Tests the assignment operator.
    425 
    426   // a1 should continue to work after being copied from.
    427   EXPECT_EQ(5, a1.Perform(make_tuple(true, 5)));
    428   EXPECT_EQ(0, a1.Perform(make_tuple(false, 1)));
    429 
    430   // a2 should work like the action it was copied from.
    431   EXPECT_EQ(5, a2.Perform(make_tuple(true, 5)));
    432   EXPECT_EQ(0, a2.Perform(make_tuple(false, 1)));
    433 }
    434 
    435 // Tests that an Action<From> object can be converted to a
    436 // compatible Action<To> object.
    437 
    438 class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
    439  public:
    440   virtual bool Perform(const tuple<int>& arg) {
    441     return get<0>(arg) != 0;
    442   }
    443 };
    444 
    445 #if !GTEST_OS_SYMBIAN
    446 // Compiling this test on Nokia's Symbian compiler fails with:
    447 //  'Result' is not a member of class 'testing::internal::Function<int>'
    448 //  (point of instantiation: '@unnamed@gmock_actions_test_cc@::
    449 //      ActionTest_CanBeConvertedToOtherActionType_Test::TestBody()')
    450 // with no obvious fix.
    451 TEST(ActionTest, CanBeConvertedToOtherActionType) {
    452   const Action<bool(int)> a1(new IsNotZero);  // NOLINT
    453   const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
    454   EXPECT_EQ(1, a2.Perform(make_tuple('a')));
    455   EXPECT_EQ(0, a2.Perform(make_tuple('\0')));
    456 }
    457 #endif  // !GTEST_OS_SYMBIAN
    458 
    459 // The following two classes are for testing MakePolymorphicAction().
    460 
    461 // Implements a polymorphic action that returns the second of the
    462 // arguments it receives.
    463 class ReturnSecondArgumentAction {
    464  public:
    465   // We want to verify that MakePolymorphicAction() can work with a
    466   // polymorphic action whose Perform() method template is either
    467   // const or not.  This lets us verify the non-const case.
    468   template <typename Result, typename ArgumentTuple>
    469   Result Perform(const ArgumentTuple& args) { return get<1>(args); }
    470 };
    471 
    472 // Implements a polymorphic action that can be used in a nullary
    473 // function to return 0.
    474 class ReturnZeroFromNullaryFunctionAction {
    475  public:
    476   // For testing that MakePolymorphicAction() works when the
    477   // implementation class' Perform() method template takes only one
    478   // template parameter.
    479   //
    480   // We want to verify that MakePolymorphicAction() can work with a
    481   // polymorphic action whose Perform() method template is either
    482   // const or not.  This lets us verify the const case.
    483   template <typename Result>
    484   Result Perform(const tuple<>&) const { return 0; }
    485 };
    486 
    487 // These functions verify that MakePolymorphicAction() returns a
    488 // PolymorphicAction<T> where T is the argument's type.
    489 
    490 PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
    491   return MakePolymorphicAction(ReturnSecondArgumentAction());
    492 }
    493 
    494 PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
    495 ReturnZeroFromNullaryFunction() {
    496   return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
    497 }
    498 
    499 // Tests that MakePolymorphicAction() turns a polymorphic action
    500 // implementation class into a polymorphic action.
    501 TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
    502   Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
    503   EXPECT_EQ(5, a1.Perform(make_tuple(false, 5, 2.0)));
    504 }
    505 
    506 // Tests that MakePolymorphicAction() works when the implementation
    507 // class' Perform() method template has only one template parameter.
    508 TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
    509   Action<int()> a1 = ReturnZeroFromNullaryFunction();
    510   EXPECT_EQ(0, a1.Perform(make_tuple()));
    511 
    512   Action<void*()> a2 = ReturnZeroFromNullaryFunction();
    513   EXPECT_TRUE(a2.Perform(make_tuple()) == NULL);
    514 }
    515 
    516 // Tests that Return() works as an action for void-returning
    517 // functions.
    518 TEST(ReturnTest, WorksForVoid) {
    519   const Action<void(int)> ret = Return();  // NOLINT
    520   return ret.Perform(make_tuple(1));
    521 }
    522 
    523 // Tests that Return(v) returns v.
    524 TEST(ReturnTest, ReturnsGivenValue) {
    525   Action<int()> ret = Return(1);  // NOLINT
    526   EXPECT_EQ(1, ret.Perform(make_tuple()));
    527 
    528   ret = Return(-5);
    529   EXPECT_EQ(-5, ret.Perform(make_tuple()));
    530 }
    531 
    532 // Tests that Return("string literal") works.
    533 TEST(ReturnTest, AcceptsStringLiteral) {
    534   Action<const char*()> a1 = Return("Hello");
    535   EXPECT_STREQ("Hello", a1.Perform(make_tuple()));
    536 
    537   Action<std::string()> a2 = Return("world");
    538   EXPECT_EQ("world", a2.Perform(make_tuple()));
    539 }
    540 
    541 // Test struct which wraps a vector of integers. Used in
    542 // 'SupportsWrapperReturnType' test.
    543 struct IntegerVectorWrapper {
    544   std::vector<int> * v;
    545   IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
    546 };
    547 
    548 // Tests that Return() works when return type is a wrapper type.
    549 TEST(ReturnTest, SupportsWrapperReturnType) {
    550   // Initialize vector of integers.
    551   std::vector<int> v;
    552   for (int i = 0; i < 5; ++i) v.push_back(i);
    553 
    554   // Return() called with 'v' as argument. The Action will return the same data
    555   // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
    556   Action<IntegerVectorWrapper()> a = Return(v);
    557   const std::vector<int>& result = *(a.Perform(make_tuple()).v);
    558   EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
    559 }
    560 
    561 // Tests that Return(v) is covaraint.
    562 
    563 struct Base {
    564   bool operator==(const Base&) { return true; }
    565 };
    566 
    567 struct Derived : public Base {
    568   bool operator==(const Derived&) { return true; }
    569 };
    570 
    571 TEST(ReturnTest, IsCovariant) {
    572   Base base;
    573   Derived derived;
    574   Action<Base*()> ret = Return(&base);
    575   EXPECT_EQ(&base, ret.Perform(make_tuple()));
    576 
    577   ret = Return(&derived);
    578   EXPECT_EQ(&derived, ret.Perform(make_tuple()));
    579 }
    580 
    581 // Tests that the type of the value passed into Return is converted into T
    582 // when the action is cast to Action<T(...)> rather than when the action is
    583 // performed. See comments on testing::internal::ReturnAction in
    584 // gmock-actions.h for more information.
    585 class FromType {
    586  public:
    587   explicit FromType(bool* is_converted) : converted_(is_converted) {}
    588   bool* converted() const { return converted_; }
    589 
    590  private:
    591   bool* const converted_;
    592 
    593   GTEST_DISALLOW_ASSIGN_(FromType);
    594 };
    595 
    596 class ToType {
    597  public:
    598   // Must allow implicit conversion due to use in ImplicitCast_<T>.
    599   ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
    600 };
    601 
    602 TEST(ReturnTest, ConvertsArgumentWhenConverted) {
    603   bool converted = false;
    604   FromType x(&converted);
    605   Action<ToType()> action(Return(x));
    606   EXPECT_TRUE(converted) << "Return must convert its argument in its own "
    607                          << "conversion operator.";
    608   converted = false;
    609   action.Perform(tuple<>());
    610   EXPECT_FALSE(converted) << "Action must NOT convert its argument "
    611                           << "when performed.";
    612 }
    613 
    614 class DestinationType {};
    615 
    616 class SourceType {
    617  public:
    618   // Note: a non-const typecast operator.
    619   operator DestinationType() { return DestinationType(); }
    620 };
    621 
    622 TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
    623   SourceType s;
    624   Action<DestinationType()> action(Return(s));
    625 }
    626 
    627 // Tests that ReturnNull() returns NULL in a pointer-returning function.
    628 TEST(ReturnNullTest, WorksInPointerReturningFunction) {
    629   const Action<int*()> a1 = ReturnNull();
    630   EXPECT_TRUE(a1.Perform(make_tuple()) == NULL);
    631 
    632   const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
    633   EXPECT_TRUE(a2.Perform(make_tuple(true)) == NULL);
    634 }
    635 
    636 #if GTEST_HAS_STD_UNIQUE_PTR_
    637 // Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
    638 // functions.
    639 TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
    640   const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
    641   EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr);
    642 
    643   const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
    644   EXPECT_TRUE(a2.Perform(make_tuple("foo")) == nullptr);
    645 }
    646 #endif  // GTEST_HAS_STD_UNIQUE_PTR_
    647 
    648 // Tests that ReturnRef(v) works for reference types.
    649 TEST(ReturnRefTest, WorksForReference) {
    650   const int n = 0;
    651   const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT
    652 
    653   EXPECT_EQ(&n, &ret.Perform(make_tuple(true)));
    654 }
    655 
    656 // Tests that ReturnRef(v) is covariant.
    657 TEST(ReturnRefTest, IsCovariant) {
    658   Base base;
    659   Derived derived;
    660   Action<Base&()> a = ReturnRef(base);
    661   EXPECT_EQ(&base, &a.Perform(make_tuple()));
    662 
    663   a = ReturnRef(derived);
    664   EXPECT_EQ(&derived, &a.Perform(make_tuple()));
    665 }
    666 
    667 // Tests that ReturnRefOfCopy(v) works for reference types.
    668 TEST(ReturnRefOfCopyTest, WorksForReference) {
    669   int n = 42;
    670   const Action<const int&()> ret = ReturnRefOfCopy(n);
    671 
    672   EXPECT_NE(&n, &ret.Perform(make_tuple()));
    673   EXPECT_EQ(42, ret.Perform(make_tuple()));
    674 
    675   n = 43;
    676   EXPECT_NE(&n, &ret.Perform(make_tuple()));
    677   EXPECT_EQ(42, ret.Perform(make_tuple()));
    678 }
    679 
    680 // Tests that ReturnRefOfCopy(v) is covariant.
    681 TEST(ReturnRefOfCopyTest, IsCovariant) {
    682   Base base;
    683   Derived derived;
    684   Action<Base&()> a = ReturnRefOfCopy(base);
    685   EXPECT_NE(&base, &a.Perform(make_tuple()));
    686 
    687   a = ReturnRefOfCopy(derived);
    688   EXPECT_NE(&derived, &a.Perform(make_tuple()));
    689 }
    690 
    691 // Tests that DoDefault() does the default action for the mock method.
    692 
    693 class MockClass {
    694  public:
    695   MockClass() {}
    696 
    697   MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
    698   MOCK_METHOD0(Foo, MyNonDefaultConstructible());
    699 #if GTEST_HAS_STD_UNIQUE_PTR_
    700   MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
    701   MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
    702   MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
    703 #endif
    704 
    705  private:
    706   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
    707 };
    708 
    709 // Tests that DoDefault() returns the built-in default value for the
    710 // return type by default.
    711 TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
    712   MockClass mock;
    713   EXPECT_CALL(mock, IntFunc(_))
    714       .WillOnce(DoDefault());
    715   EXPECT_EQ(0, mock.IntFunc(true));
    716 }
    717 
    718 // Tests that DoDefault() throws (when exceptions are enabled) or aborts
    719 // the process when there is no built-in default value for the return type.
    720 TEST(DoDefaultDeathTest, DiesForUnknowType) {
    721   MockClass mock;
    722   EXPECT_CALL(mock, Foo())
    723       .WillRepeatedly(DoDefault());
    724 #if GTEST_HAS_EXCEPTIONS
    725   EXPECT_ANY_THROW(mock.Foo());
    726 #else
    727   EXPECT_DEATH_IF_SUPPORTED({
    728     mock.Foo();
    729   }, "");
    730 #endif
    731 }
    732 
    733 // Tests that using DoDefault() inside a composite action leads to a
    734 // run-time error.
    735 
    736 void VoidFunc(bool /* flag */) {}
    737 
    738 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
    739   MockClass mock;
    740   EXPECT_CALL(mock, IntFunc(_))
    741       .WillRepeatedly(DoAll(Invoke(VoidFunc),
    742                             DoDefault()));
    743 
    744   // Ideally we should verify the error message as well.  Sadly,
    745   // EXPECT_DEATH() can only capture stderr, while Google Mock's
    746   // errors are printed on stdout.  Therefore we have to settle for
    747   // not verifying the message.
    748   EXPECT_DEATH_IF_SUPPORTED({
    749     mock.IntFunc(true);
    750   }, "");
    751 }
    752 
    753 // Tests that DoDefault() returns the default value set by
    754 // DefaultValue<T>::Set() when it's not overriden by an ON_CALL().
    755 TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
    756   DefaultValue<int>::Set(1);
    757   MockClass mock;
    758   EXPECT_CALL(mock, IntFunc(_))
    759       .WillOnce(DoDefault());
    760   EXPECT_EQ(1, mock.IntFunc(false));
    761   DefaultValue<int>::Clear();
    762 }
    763 
    764 // Tests that DoDefault() does the action specified by ON_CALL().
    765 TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
    766   MockClass mock;
    767   ON_CALL(mock, IntFunc(_))
    768       .WillByDefault(Return(2));
    769   EXPECT_CALL(mock, IntFunc(_))
    770       .WillOnce(DoDefault());
    771   EXPECT_EQ(2, mock.IntFunc(false));
    772 }
    773 
    774 // Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
    775 TEST(DoDefaultTest, CannotBeUsedInOnCall) {
    776   MockClass mock;
    777   EXPECT_NONFATAL_FAILURE({  // NOLINT
    778     ON_CALL(mock, IntFunc(_))
    779       .WillByDefault(DoDefault());
    780   }, "DoDefault() cannot be used in ON_CALL()");
    781 }
    782 
    783 // Tests that SetArgPointee<N>(v) sets the variable pointed to by
    784 // the N-th (0-based) argument to v.
    785 TEST(SetArgPointeeTest, SetsTheNthPointee) {
    786   typedef void MyFunction(bool, int*, char*);
    787   Action<MyFunction> a = SetArgPointee<1>(2);
    788 
    789   int n = 0;
    790   char ch = '\0';
    791   a.Perform(make_tuple(true, &n, &ch));
    792   EXPECT_EQ(2, n);
    793   EXPECT_EQ('\0', ch);
    794 
    795   a = SetArgPointee<2>('a');
    796   n = 0;
    797   ch = '\0';
    798   a.Perform(make_tuple(true, &n, &ch));
    799   EXPECT_EQ(0, n);
    800   EXPECT_EQ('a', ch);
    801 }
    802 
    803 #if !((GTEST_GCC_VER_ && GTEST_GCC_VER_ < 40000) || GTEST_OS_SYMBIAN)
    804 // Tests that SetArgPointee<N>() accepts a string literal.
    805 // GCC prior to v4.0 and the Symbian compiler do not support this.
    806 TEST(SetArgPointeeTest, AcceptsStringLiteral) {
    807   typedef void MyFunction(std::string*, const char**);
    808   Action<MyFunction> a = SetArgPointee<0>("hi");
    809   std::string str;
    810   const char* ptr = NULL;
    811   a.Perform(make_tuple(&str, &ptr));
    812   EXPECT_EQ("hi", str);
    813   EXPECT_TRUE(ptr == NULL);
    814 
    815   a = SetArgPointee<1>("world");
    816   str = "";
    817   a.Perform(make_tuple(&str, &ptr));
    818   EXPECT_EQ("", str);
    819   EXPECT_STREQ("world", ptr);
    820 }
    821 
    822 TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
    823   typedef void MyFunction(const wchar_t**);
    824   Action<MyFunction> a = SetArgPointee<0>(L"world");
    825   const wchar_t* ptr = NULL;
    826   a.Perform(make_tuple(&ptr));
    827   EXPECT_STREQ(L"world", ptr);
    828 
    829 # if GTEST_HAS_STD_WSTRING
    830 
    831   typedef void MyStringFunction(std::wstring*);
    832   Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
    833   std::wstring str = L"";
    834   a2.Perform(make_tuple(&str));
    835   EXPECT_EQ(L"world", str);
    836 
    837 # endif
    838 }
    839 #endif
    840 
    841 // Tests that SetArgPointee<N>() accepts a char pointer.
    842 TEST(SetArgPointeeTest, AcceptsCharPointer) {
    843   typedef void MyFunction(bool, std::string*, const char**);
    844   const char* const hi = "hi";
    845   Action<MyFunction> a = SetArgPointee<1>(hi);
    846   std::string str;
    847   const char* ptr = NULL;
    848   a.Perform(make_tuple(true, &str, &ptr));
    849   EXPECT_EQ("hi", str);
    850   EXPECT_TRUE(ptr == NULL);
    851 
    852   char world_array[] = "world";
    853   char* const world = world_array;
    854   a = SetArgPointee<2>(world);
    855   str = "";
    856   a.Perform(make_tuple(true, &str, &ptr));
    857   EXPECT_EQ("", str);
    858   EXPECT_EQ(world, ptr);
    859 }
    860 
    861 TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
    862   typedef void MyFunction(bool, const wchar_t**);
    863   const wchar_t* const hi = L"hi";
    864   Action<MyFunction> a = SetArgPointee<1>(hi);
    865   const wchar_t* ptr = NULL;
    866   a.Perform(make_tuple(true, &ptr));
    867   EXPECT_EQ(hi, ptr);
    868 
    869 # if GTEST_HAS_STD_WSTRING
    870 
    871   typedef void MyStringFunction(bool, std::wstring*);
    872   wchar_t world_array[] = L"world";
    873   wchar_t* const world = world_array;
    874   Action<MyStringFunction> a2 = SetArgPointee<1>(world);
    875   std::wstring str;
    876   a2.Perform(make_tuple(true, &str));
    877   EXPECT_EQ(world_array, str);
    878 # endif
    879 }
    880 
    881 #if GTEST_HAS_PROTOBUF_
    882 
    883 // Tests that SetArgPointee<N>(proto_buffer) sets the v1 protobuf
    884 // variable pointed to by the N-th (0-based) argument to proto_buffer.
    885 TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
    886   TestMessage* const msg = new TestMessage;
    887   msg->set_member("yes");
    888   TestMessage orig_msg;
    889   orig_msg.CopyFrom(*msg);
    890 
    891   Action<void(bool, TestMessage*)> a = SetArgPointee<1>(*msg);
    892   // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
    893   // s.t. the action works even when the original proto_buffer has
    894   // died.  We ensure this behavior by deleting msg before using the
    895   // action.
    896   delete msg;
    897 
    898   TestMessage dest;
    899   EXPECT_FALSE(orig_msg.Equals(dest));
    900   a.Perform(make_tuple(true, &dest));
    901   EXPECT_TRUE(orig_msg.Equals(dest));
    902 }
    903 
    904 // Tests that SetArgPointee<N>(proto_buffer) sets the
    905 // ::ProtocolMessage variable pointed to by the N-th (0-based)
    906 // argument to proto_buffer.
    907 TEST(SetArgPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
    908   TestMessage* const msg = new TestMessage;
    909   msg->set_member("yes");
    910   TestMessage orig_msg;
    911   orig_msg.CopyFrom(*msg);
    912 
    913   Action<void(bool, ::ProtocolMessage*)> a = SetArgPointee<1>(*msg);
    914   // SetArgPointee<N>(proto_buffer) makes a copy of proto_buffer
    915   // s.t. the action works even when the original proto_buffer has
    916   // died.  We ensure this behavior by deleting msg before using the
    917   // action.
    918   delete msg;
    919 
    920   TestMessage dest;
    921   ::ProtocolMessage* const dest_base = &dest;
    922   EXPECT_FALSE(orig_msg.Equals(dest));
    923   a.Perform(make_tuple(true, dest_base));
    924   EXPECT_TRUE(orig_msg.Equals(dest));
    925 }
    926 
    927 // Tests that SetArgPointee<N>(proto2_buffer) sets the v2
    928 // protobuf variable pointed to by the N-th (0-based) argument to
    929 // proto2_buffer.
    930 TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
    931   using testing::internal::FooMessage;
    932   FooMessage* const msg = new FooMessage;
    933   msg->set_int_field(2);
    934   msg->set_string_field("hi");
    935   FooMessage orig_msg;
    936   orig_msg.CopyFrom(*msg);
    937 
    938   Action<void(bool, FooMessage*)> a = SetArgPointee<1>(*msg);
    939   // SetArgPointee<N>(proto2_buffer) makes a copy of
    940   // proto2_buffer s.t. the action works even when the original
    941   // proto2_buffer has died.  We ensure this behavior by deleting msg
    942   // before using the action.
    943   delete msg;
    944 
    945   FooMessage dest;
    946   dest.set_int_field(0);
    947   a.Perform(make_tuple(true, &dest));
    948   EXPECT_EQ(2, dest.int_field());
    949   EXPECT_EQ("hi", dest.string_field());
    950 }
    951 
    952 // Tests that SetArgPointee<N>(proto2_buffer) sets the
    953 // proto2::Message variable pointed to by the N-th (0-based) argument
    954 // to proto2_buffer.
    955 TEST(SetArgPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
    956   using testing::internal::FooMessage;
    957   FooMessage* const msg = new FooMessage;
    958   msg->set_int_field(2);
    959   msg->set_string_field("hi");
    960   FooMessage orig_msg;
    961   orig_msg.CopyFrom(*msg);
    962 
    963   Action<void(bool, ::proto2::Message*)> a = SetArgPointee<1>(*msg);
    964   // SetArgPointee<N>(proto2_buffer) makes a copy of
    965   // proto2_buffer s.t. the action works even when the original
    966   // proto2_buffer has died.  We ensure this behavior by deleting msg
    967   // before using the action.
    968   delete msg;
    969 
    970   FooMessage dest;
    971   dest.set_int_field(0);
    972   ::proto2::Message* const dest_base = &dest;
    973   a.Perform(make_tuple(true, dest_base));
    974   EXPECT_EQ(2, dest.int_field());
    975   EXPECT_EQ("hi", dest.string_field());
    976 }
    977 
    978 #endif  // GTEST_HAS_PROTOBUF_
    979 
    980 // Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
    981 // the N-th (0-based) argument to v.
    982 TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
    983   typedef void MyFunction(bool, int*, char*);
    984   Action<MyFunction> a = SetArgumentPointee<1>(2);
    985 
    986   int n = 0;
    987   char ch = '\0';
    988   a.Perform(make_tuple(true, &n, &ch));
    989   EXPECT_EQ(2, n);
    990   EXPECT_EQ('\0', ch);
    991 
    992   a = SetArgumentPointee<2>('a');
    993   n = 0;
    994   ch = '\0';
    995   a.Perform(make_tuple(true, &n, &ch));
    996   EXPECT_EQ(0, n);
    997   EXPECT_EQ('a', ch);
    998 }
    999 
   1000 #if GTEST_HAS_PROTOBUF_
   1001 
   1002 // Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf
   1003 // variable pointed to by the N-th (0-based) argument to proto_buffer.
   1004 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferType) {
   1005   TestMessage* const msg = new TestMessage;
   1006   msg->set_member("yes");
   1007   TestMessage orig_msg;
   1008   orig_msg.CopyFrom(*msg);
   1009 
   1010   Action<void(bool, TestMessage*)> a = SetArgumentPointee<1>(*msg);
   1011   // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
   1012   // s.t. the action works even when the original proto_buffer has
   1013   // died.  We ensure this behavior by deleting msg before using the
   1014   // action.
   1015   delete msg;
   1016 
   1017   TestMessage dest;
   1018   EXPECT_FALSE(orig_msg.Equals(dest));
   1019   a.Perform(make_tuple(true, &dest));
   1020   EXPECT_TRUE(orig_msg.Equals(dest));
   1021 }
   1022 
   1023 // Tests that SetArgumentPointee<N>(proto_buffer) sets the
   1024 // ::ProtocolMessage variable pointed to by the N-th (0-based)
   1025 // argument to proto_buffer.
   1026 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProtoBufferBaseType) {
   1027   TestMessage* const msg = new TestMessage;
   1028   msg->set_member("yes");
   1029   TestMessage orig_msg;
   1030   orig_msg.CopyFrom(*msg);
   1031 
   1032   Action<void(bool, ::ProtocolMessage*)> a = SetArgumentPointee<1>(*msg);
   1033   // SetArgumentPointee<N>(proto_buffer) makes a copy of proto_buffer
   1034   // s.t. the action works even when the original proto_buffer has
   1035   // died.  We ensure this behavior by deleting msg before using the
   1036   // action.
   1037   delete msg;
   1038 
   1039   TestMessage dest;
   1040   ::ProtocolMessage* const dest_base = &dest;
   1041   EXPECT_FALSE(orig_msg.Equals(dest));
   1042   a.Perform(make_tuple(true, dest_base));
   1043   EXPECT_TRUE(orig_msg.Equals(dest));
   1044 }
   1045 
   1046 // Tests that SetArgumentPointee<N>(proto2_buffer) sets the v2
   1047 // protobuf variable pointed to by the N-th (0-based) argument to
   1048 // proto2_buffer.
   1049 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferType) {
   1050   using testing::internal::FooMessage;
   1051   FooMessage* const msg = new FooMessage;
   1052   msg->set_int_field(2);
   1053   msg->set_string_field("hi");
   1054   FooMessage orig_msg;
   1055   orig_msg.CopyFrom(*msg);
   1056 
   1057   Action<void(bool, FooMessage*)> a = SetArgumentPointee<1>(*msg);
   1058   // SetArgumentPointee<N>(proto2_buffer) makes a copy of
   1059   // proto2_buffer s.t. the action works even when the original
   1060   // proto2_buffer has died.  We ensure this behavior by deleting msg
   1061   // before using the action.
   1062   delete msg;
   1063 
   1064   FooMessage dest;
   1065   dest.set_int_field(0);
   1066   a.Perform(make_tuple(true, &dest));
   1067   EXPECT_EQ(2, dest.int_field());
   1068   EXPECT_EQ("hi", dest.string_field());
   1069 }
   1070 
   1071 // Tests that SetArgumentPointee<N>(proto2_buffer) sets the
   1072 // proto2::Message variable pointed to by the N-th (0-based) argument
   1073 // to proto2_buffer.
   1074 TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
   1075   using testing::internal::FooMessage;
   1076   FooMessage* const msg = new FooMessage;
   1077   msg->set_int_field(2);
   1078   msg->set_string_field("hi");
   1079   FooMessage orig_msg;
   1080   orig_msg.CopyFrom(*msg);
   1081 
   1082   Action<void(bool, ::proto2::Message*)> a = SetArgumentPointee<1>(*msg);
   1083   // SetArgumentPointee<N>(proto2_buffer) makes a copy of
   1084   // proto2_buffer s.t. the action works even when the original
   1085   // proto2_buffer has died.  We ensure this behavior by deleting msg
   1086   // before using the action.
   1087   delete msg;
   1088 
   1089   FooMessage dest;
   1090   dest.set_int_field(0);
   1091   ::proto2::Message* const dest_base = &dest;
   1092   a.Perform(make_tuple(true, dest_base));
   1093   EXPECT_EQ(2, dest.int_field());
   1094   EXPECT_EQ("hi", dest.string_field());
   1095 }
   1096 
   1097 #endif  // GTEST_HAS_PROTOBUF_
   1098 
   1099 // Sample functions and functors for testing Invoke() and etc.
   1100 int Nullary() { return 1; }
   1101 
   1102 class NullaryFunctor {
   1103  public:
   1104   int operator()() { return 2; }
   1105 };
   1106 
   1107 bool g_done = false;
   1108 void VoidNullary() { g_done = true; }
   1109 
   1110 class VoidNullaryFunctor {
   1111  public:
   1112   void operator()() { g_done = true; }
   1113 };
   1114 
   1115 class Foo {
   1116  public:
   1117   Foo() : value_(123) {}
   1118 
   1119   int Nullary() const { return value_; }
   1120 
   1121  private:
   1122   int value_;
   1123 };
   1124 
   1125 // Tests InvokeWithoutArgs(function).
   1126 TEST(InvokeWithoutArgsTest, Function) {
   1127   // As an action that takes one argument.
   1128   Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
   1129   EXPECT_EQ(1, a.Perform(make_tuple(2)));
   1130 
   1131   // As an action that takes two arguments.
   1132   Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
   1133   EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));
   1134 
   1135   // As an action that returns void.
   1136   Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
   1137   g_done = false;
   1138   a3.Perform(make_tuple(1));
   1139   EXPECT_TRUE(g_done);
   1140 }
   1141 
   1142 // Tests InvokeWithoutArgs(functor).
   1143 TEST(InvokeWithoutArgsTest, Functor) {
   1144   // As an action that takes no argument.
   1145   Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
   1146   EXPECT_EQ(2, a.Perform(make_tuple()));
   1147 
   1148   // As an action that takes three arguments.
   1149   Action<int(int, double, char)> a2 =  // NOLINT
   1150       InvokeWithoutArgs(NullaryFunctor());
   1151   EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));
   1152 
   1153   // As an action that returns void.
   1154   Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
   1155   g_done = false;
   1156   a3.Perform(make_tuple());
   1157   EXPECT_TRUE(g_done);
   1158 }
   1159 
   1160 // Tests InvokeWithoutArgs(obj_ptr, method).
   1161 TEST(InvokeWithoutArgsTest, Method) {
   1162   Foo foo;
   1163   Action<int(bool, char)> a =  // NOLINT
   1164       InvokeWithoutArgs(&foo, &Foo::Nullary);
   1165   EXPECT_EQ(123, a.Perform(make_tuple(true, 'a')));
   1166 }
   1167 
   1168 // Tests using IgnoreResult() on a polymorphic action.
   1169 TEST(IgnoreResultTest, PolymorphicAction) {
   1170   Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
   1171   a.Perform(make_tuple(1));
   1172 }
   1173 
   1174 // Tests using IgnoreResult() on a monomorphic action.
   1175 
   1176 int ReturnOne() {
   1177   g_done = true;
   1178   return 1;
   1179 }
   1180 
   1181 TEST(IgnoreResultTest, MonomorphicAction) {
   1182   g_done = false;
   1183   Action<void()> a = IgnoreResult(Invoke(ReturnOne));
   1184   a.Perform(make_tuple());
   1185   EXPECT_TRUE(g_done);
   1186 }
   1187 
   1188 // Tests using IgnoreResult() on an action that returns a class type.
   1189 
   1190 MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
   1191   g_done = true;
   1192   return MyNonDefaultConstructible(42);
   1193 }
   1194 
   1195 TEST(IgnoreResultTest, ActionReturningClass) {
   1196   g_done = false;
   1197   Action<void(int)> a =
   1198       IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
   1199   a.Perform(make_tuple(2));
   1200   EXPECT_TRUE(g_done);
   1201 }
   1202 
   1203 TEST(AssignTest, Int) {
   1204   int x = 0;
   1205   Action<void(int)> a = Assign(&x, 5);
   1206   a.Perform(make_tuple(0));
   1207   EXPECT_EQ(5, x);
   1208 }
   1209 
   1210 TEST(AssignTest, String) {
   1211   ::std::string x;
   1212   Action<void(void)> a = Assign(&x, "Hello, world");
   1213   a.Perform(make_tuple());
   1214   EXPECT_EQ("Hello, world", x);
   1215 }
   1216 
   1217 TEST(AssignTest, CompatibleTypes) {
   1218   double x = 0;
   1219   Action<void(int)> a = Assign(&x, 5);
   1220   a.Perform(make_tuple(0));
   1221   EXPECT_DOUBLE_EQ(5, x);
   1222 }
   1223 
   1224 #if !GTEST_OS_WINDOWS_MOBILE
   1225 
   1226 class SetErrnoAndReturnTest : public testing::Test {
   1227  protected:
   1228   virtual void SetUp() { errno = 0; }
   1229   virtual void TearDown() { errno = 0; }
   1230 };
   1231 
   1232 TEST_F(SetErrnoAndReturnTest, Int) {
   1233   Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
   1234   EXPECT_EQ(-5, a.Perform(make_tuple()));
   1235   EXPECT_EQ(ENOTTY, errno);
   1236 }
   1237 
   1238 TEST_F(SetErrnoAndReturnTest, Ptr) {
   1239   int x;
   1240   Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
   1241   EXPECT_EQ(&x, a.Perform(make_tuple()));
   1242   EXPECT_EQ(ENOTTY, errno);
   1243 }
   1244 
   1245 TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
   1246   Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
   1247   EXPECT_DOUBLE_EQ(5.0, a.Perform(make_tuple()));
   1248   EXPECT_EQ(EINVAL, errno);
   1249 }
   1250 
   1251 #endif  // !GTEST_OS_WINDOWS_MOBILE
   1252 
   1253 // Tests ByRef().
   1254 
   1255 // Tests that ReferenceWrapper<T> is copyable.
   1256 TEST(ByRefTest, IsCopyable) {
   1257   const std::string s1 = "Hi";
   1258   const std::string s2 = "Hello";
   1259 
   1260   ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper =
   1261       ByRef(s1);
   1262   const std::string& r1 = ref_wrapper;
   1263   EXPECT_EQ(&s1, &r1);
   1264 
   1265   // Assigns a new value to ref_wrapper.
   1266   ref_wrapper = ByRef(s2);
   1267   const std::string& r2 = ref_wrapper;
   1268   EXPECT_EQ(&s2, &r2);
   1269 
   1270   ::testing::internal::ReferenceWrapper<const std::string> ref_wrapper1 =
   1271       ByRef(s1);
   1272   // Copies ref_wrapper1 to ref_wrapper.
   1273   ref_wrapper = ref_wrapper1;
   1274   const std::string& r3 = ref_wrapper;
   1275   EXPECT_EQ(&s1, &r3);
   1276 }
   1277 
   1278 // Tests using ByRef() on a const value.
   1279 TEST(ByRefTest, ConstValue) {
   1280   const int n = 0;
   1281   // int& ref = ByRef(n);  // This shouldn't compile - we have a
   1282                            // negative compilation test to catch it.
   1283   const int& const_ref = ByRef(n);
   1284   EXPECT_EQ(&n, &const_ref);
   1285 }
   1286 
   1287 // Tests using ByRef() on a non-const value.
   1288 TEST(ByRefTest, NonConstValue) {
   1289   int n = 0;
   1290 
   1291   // ByRef(n) can be used as either an int&,
   1292   int& ref = ByRef(n);
   1293   EXPECT_EQ(&n, &ref);
   1294 
   1295   // or a const int&.
   1296   const int& const_ref = ByRef(n);
   1297   EXPECT_EQ(&n, &const_ref);
   1298 }
   1299 
   1300 // Tests explicitly specifying the type when using ByRef().
   1301 TEST(ByRefTest, ExplicitType) {
   1302   int n = 0;
   1303   const int& r1 = ByRef<const int>(n);
   1304   EXPECT_EQ(&n, &r1);
   1305 
   1306   // ByRef<char>(n);  // This shouldn't compile - we have a negative
   1307                       // compilation test to catch it.
   1308 
   1309   Derived d;
   1310   Derived& r2 = ByRef<Derived>(d);
   1311   EXPECT_EQ(&d, &r2);
   1312 
   1313   const Derived& r3 = ByRef<const Derived>(d);
   1314   EXPECT_EQ(&d, &r3);
   1315 
   1316   Base& r4 = ByRef<Base>(d);
   1317   EXPECT_EQ(&d, &r4);
   1318 
   1319   const Base& r5 = ByRef<const Base>(d);
   1320   EXPECT_EQ(&d, &r5);
   1321 
   1322   // The following shouldn't compile - we have a negative compilation
   1323   // test for it.
   1324   //
   1325   // Base b;
   1326   // ByRef<Derived>(b);
   1327 }
   1328 
   1329 // Tests that Google Mock prints expression ByRef(x) as a reference to x.
   1330 TEST(ByRefTest, PrintsCorrectly) {
   1331   int n = 42;
   1332   ::std::stringstream expected, actual;
   1333   testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
   1334   testing::internal::UniversalPrint(ByRef(n), &actual);
   1335   EXPECT_EQ(expected.str(), actual.str());
   1336 }
   1337 
   1338 #if GTEST_HAS_STD_UNIQUE_PTR_
   1339 
   1340 std::unique_ptr<int> UniquePtrSource() {
   1341   return std::unique_ptr<int>(new int(19));
   1342 }
   1343 
   1344 std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
   1345   std::vector<std::unique_ptr<int>> out;
   1346   out.emplace_back(new int(7));
   1347   return out;
   1348 }
   1349 
   1350 TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
   1351   MockClass mock;
   1352   std::unique_ptr<int> i(new int(19));
   1353   EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
   1354   EXPECT_CALL(mock, MakeVectorUnique())
   1355       .WillOnce(Return(ByMove(VectorUniquePtrSource())));
   1356   Derived* d = new Derived;
   1357   EXPECT_CALL(mock, MakeUniqueBase())
   1358       .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));
   1359 
   1360   std::unique_ptr<int> result1 = mock.MakeUnique();
   1361   EXPECT_EQ(19, *result1);
   1362 
   1363   std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
   1364   EXPECT_EQ(1u, vresult.size());
   1365   EXPECT_NE(nullptr, vresult[0]);
   1366   EXPECT_EQ(7, *vresult[0]);
   1367 
   1368   std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
   1369   EXPECT_EQ(d, result2.get());
   1370 }
   1371 
   1372 TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
   1373   testing::MockFunction<void()> mock_function;
   1374   MockClass mock;
   1375   std::unique_ptr<int> i(new int(19));
   1376   EXPECT_CALL(mock_function, Call());
   1377   EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
   1378       InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
   1379       Return(ByMove(std::move(i)))));
   1380 
   1381   std::unique_ptr<int> result1 = mock.MakeUnique();
   1382   EXPECT_EQ(19, *result1);
   1383 }
   1384 
   1385 TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
   1386   MockClass mock;
   1387 
   1388   // Check default value
   1389   DefaultValue<std::unique_ptr<int>>::SetFactory([] {
   1390     return std::unique_ptr<int>(new int(42));
   1391   });
   1392   EXPECT_EQ(42, *mock.MakeUnique());
   1393 
   1394   EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
   1395   EXPECT_CALL(mock, MakeVectorUnique())
   1396       .WillRepeatedly(Invoke(VectorUniquePtrSource));
   1397   std::unique_ptr<int> result1 = mock.MakeUnique();
   1398   EXPECT_EQ(19, *result1);
   1399   std::unique_ptr<int> result2 = mock.MakeUnique();
   1400   EXPECT_EQ(19, *result2);
   1401   EXPECT_NE(result1, result2);
   1402 
   1403   std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
   1404   EXPECT_EQ(1u, vresult.size());
   1405   EXPECT_NE(nullptr, vresult[0]);
   1406   EXPECT_EQ(7, *vresult[0]);
   1407 }
   1408 
   1409 #endif  // GTEST_HAS_STD_UNIQUE_PTR_
   1410 
   1411 }  // Unnamed namespace
   1412