googlemock/test/gmock-actions_test.cc

   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
  31 // Google Mock - a framework for writing C++ mock classes.
  32 //
  33 // This file tests the built-in actions.
  34
  35 // Silence C4100 (unreferenced formal parameter) for MSVC
  36 #ifdef _MSC_VER
  37 #  pragma warning(push)
  38 #  pragma warning(disable:4100)
  39 #if _MSC_VER == 1900
  40 // and silence C4800 (C4800: 'int *const ': forcing value
  41 // to bool 'true' or 'false') for MSVC 15
  42 #  pragma warning(disable:4800)
  43 #endif
  44 #endif
  45
  46 #include "gmock/gmock-actions.h"
  47 #include <algorithm>
  48 #include <iterator>
  49 #include <memory>
  50 #include <string>
  51 #include <type_traits>
  52 #include "gmock/gmock.h"
  53 #include "gmock/internal/gmock-port.h"
  54 #include "gtest/gtest.h"
  55 #include "gtest/gtest-spi.h"
  56
  57 namespace {
  58
  59 using ::testing::_;
  60 using ::testing::Action;
  61 using ::testing::ActionInterface;
  62 using ::testing::Assign;
  63 using ::testing::ByMove;
  64 using ::testing::ByRef;
  65 using ::testing::DefaultValue;
  66 using ::testing::DoAll;
  67 using ::testing::DoDefault;
  68 using ::testing::IgnoreResult;
  69 using ::testing::Invoke;
  70 using ::testing::InvokeWithoutArgs;
  71 using ::testing::MakePolymorphicAction;
  72 using ::testing::PolymorphicAction;
  73 using ::testing::Return;
  74 using ::testing::ReturnNew;
  75 using ::testing::ReturnNull;
  76 using ::testing::ReturnRef;
  77 using ::testing::ReturnRefOfCopy;
  78 using ::testing::ReturnRoundRobin;
  79 using ::testing::SetArgPointee;
  80 using ::testing::SetArgumentPointee;
  81 using ::testing::Unused;
  82 using ::testing::WithArgs;
  83 using ::testing::internal::BuiltInDefaultValue;
  84
  85 #if !GTEST_OS_WINDOWS_MOBILE
  86 using ::testing::SetErrnoAndReturn;
  87 #endif
  88
  89 // Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
  90 TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
  91   EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == nullptr);
  92   EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == nullptr);
  93   EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == nullptr);
  94 }
  95
  96 // Tests that BuiltInDefaultValue<T*>::Exists() return true.
  97 TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
  98   EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
  99   EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
 100   EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
 101 }
 102
 103 // Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
 104 // built-in numeric type.
 105 TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
 106   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
 107   EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
 108   EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
 109 #if GMOCK_WCHAR_T_IS_NATIVE_
 110 #if !defined(__WCHAR_UNSIGNED__)
 111   EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
 112 #else
 113   EXPECT_EQ(0U, BuiltInDefaultValue<wchar_t>::Get());
 114 #endif
 115 #endif
 116   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
 117   EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
 118   EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
 119   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
 120   EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
 121   EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
 122   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
 123   EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
 124   EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
 125   EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long long>::Get());  // NOLINT
 126   EXPECT_EQ(0, BuiltInDefaultValue<signed long long>::Get());  // NOLINT
 127   EXPECT_EQ(0, BuiltInDefaultValue<long long>::Get());  // NOLINT
 128   EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
 129   EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
 130 }
 131
 132 // Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
 133 // built-in numeric type.
 134 TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
 135   EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
 136   EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
 137   EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
 138 #if GMOCK_WCHAR_T_IS_NATIVE_
 139   EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
 140 #endif
 141   EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
 142   EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());  // NOLINT
 143   EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());  // NOLINT
 144   EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
 145   EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
 146   EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
 147   EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());  // NOLINT
 148   EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());  // NOLINT
 149   EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());  // NOLINT
 150   EXPECT_TRUE(BuiltInDefaultValue<unsigned long long>::Exists());  // NOLINT
 151   EXPECT_TRUE(BuiltInDefaultValue<signed long long>::Exists());  // NOLINT
 152   EXPECT_TRUE(BuiltInDefaultValue<long long>::Exists());  // NOLINT
 153   EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
 154   EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
 155 }
 156
 157 // Tests that BuiltInDefaultValue<bool>::Get() returns false.
 158 TEST(BuiltInDefaultValueTest, IsFalseForBool) {
 159   EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
 160 }
 161
 162 // Tests that BuiltInDefaultValue<bool>::Exists() returns true.
 163 TEST(BuiltInDefaultValueTest, BoolExists) {
 164   EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
 165 }
 166
 167 // Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
 168 // string type.
 169 TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
 170   EXPECT_EQ("", BuiltInDefaultValue< ::std::string>::Get());
 171 }
 172
 173 // Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
 174 // string type.
 175 TEST(BuiltInDefaultValueTest, ExistsForString) {
 176   EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
 177 }
 178
 179 // Tests that BuiltInDefaultValue<const T>::Get() returns the same
 180 // value as BuiltInDefaultValue<T>::Get() does.
 181 TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
 182   EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
 183   EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
 184   EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == nullptr);
 185   EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
 186 }
 187
 188 // A type that's default constructible.
 189 class MyDefaultConstructible {
 190  public:
 191   MyDefaultConstructible() : value_(42) {}
 192
 193   int value() const { return value_; }
 194
 195  private:
 196   int value_;
 197 };
 198
 199 // A type that's not default constructible.
 200 class MyNonDefaultConstructible {
 201  public:
 202   // Does not have a default ctor.
 203   explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
 204
 205   int value() const { return value_; }
 206
 207  private:
 208   int value_;
 209 };
 210
 211
 212 TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
 213   EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
 214 }
 215
 216 TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
 217   EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
 218 }
 219
 220
 221 TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
 222   EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
 223 }
 224
 225 // Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
 226 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
 227   EXPECT_DEATH_IF_SUPPORTED({
 228     BuiltInDefaultValue<int&>::Get();
 229   }, "");
 230   EXPECT_DEATH_IF_SUPPORTED({
 231     BuiltInDefaultValue<const char&>::Get();
 232   }, "");
 233 }
 234
 235 TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
 236   EXPECT_DEATH_IF_SUPPORTED({
 237     BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
 238   }, "");
 239 }
 240
 241 // Tests that DefaultValue<T>::IsSet() is false initially.
 242 TEST(DefaultValueTest, IsInitiallyUnset) {
 243   EXPECT_FALSE(DefaultValue<int>::IsSet());
 244   EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
 245   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
 246 }
 247
 248 // Tests that DefaultValue<T> can be set and then unset.
 249 TEST(DefaultValueTest, CanBeSetAndUnset) {
 250   EXPECT_TRUE(DefaultValue<int>::Exists());
 251   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
 252
 253   DefaultValue<int>::Set(1);
 254   DefaultValue<const MyNonDefaultConstructible>::Set(
 255       MyNonDefaultConstructible(42));
 256
 257   EXPECT_EQ(1, DefaultValue<int>::Get());
 258   EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
 259
 260   EXPECT_TRUE(DefaultValue<int>::Exists());
 261   EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
 262
 263   DefaultValue<int>::Clear();
 264   DefaultValue<const MyNonDefaultConstructible>::Clear();
 265
 266   EXPECT_FALSE(DefaultValue<int>::IsSet());
 267   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
 268
 269   EXPECT_TRUE(DefaultValue<int>::Exists());
 270   EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
 271 }
 272
 273 // Tests that DefaultValue<T>::Get() returns the
 274 // BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
 275 // false.
 276 TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
 277   EXPECT_FALSE(DefaultValue<int>::IsSet());
 278   EXPECT_TRUE(DefaultValue<int>::Exists());
 279   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
 280   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
 281
 282   EXPECT_EQ(0, DefaultValue<int>::Get());
 283
 284   EXPECT_DEATH_IF_SUPPORTED({
 285     DefaultValue<MyNonDefaultConstructible>::Get();
 286   }, "");
 287 }
 288
 289 TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
 290   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
 291   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
 292   DefaultValue<std::unique_ptr<int>>::SetFactory([] {
 293     return std::unique_ptr<int>(new int(42));
 294   });
 295   EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
 296   std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
 297   EXPECT_EQ(42, *i);
 298 }
 299
 300 // Tests that DefaultValue<void>::Get() returns void.
 301 TEST(DefaultValueTest, GetWorksForVoid) {
 302   return DefaultValue<void>::Get();
 303 }
 304
 305 // Tests using DefaultValue with a reference type.
 306
 307 // Tests that DefaultValue<T&>::IsSet() is false initially.
 308 TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
 309   EXPECT_FALSE(DefaultValue<int&>::IsSet());
 310   EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
 311   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
 312 }
 313
 314 // Tests that DefaultValue<T&>::Exists is false initiallly.
 315 TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
 316   EXPECT_FALSE(DefaultValue<int&>::Exists());
 317   EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
 318   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
 319 }
 320
 321 // Tests that DefaultValue<T&> can be set and then unset.
 322 TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
 323   int n = 1;
 324   DefaultValue<const int&>::Set(n);
 325   MyNonDefaultConstructible x(42);
 326   DefaultValue<MyNonDefaultConstructible&>::Set(x);
 327
 328   EXPECT_TRUE(DefaultValue<const int&>::Exists());
 329   EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
 330
 331   EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
 332   EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
 333
 334   DefaultValue<const int&>::Clear();
 335   DefaultValue<MyNonDefaultConstructible&>::Clear();
 336
 337   EXPECT_FALSE(DefaultValue<const int&>::Exists());
 338   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
 339
 340   EXPECT_FALSE(DefaultValue<const int&>::IsSet());
 341   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
 342 }
 343
 344 // Tests that DefaultValue<T&>::Get() returns the
 345 // BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
 346 // false.
 347 TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
 348   EXPECT_FALSE(DefaultValue<int&>::IsSet());
 349   EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
 350
 351   EXPECT_DEATH_IF_SUPPORTED({
 352     DefaultValue<int&>::Get();
 353   }, "");
 354   EXPECT_DEATH_IF_SUPPORTED({
 355     DefaultValue<MyNonDefaultConstructible>::Get();
 356   }, "");
 357 }
 358
 359 // Tests that ActionInterface can be implemented by defining the
 360 // Perform method.
 361
 362 typedef int MyGlobalFunction(bool, int);
 363
 364 class MyActionImpl : public ActionInterface<MyGlobalFunction> {
 365  public:
 366   int Perform(const std::tuple<bool, int>& args) override {
 367     return std::get<0>(args) ? std::get<1>(args) : 0;
 368   }
 369 };
 370
 371 TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
 372   MyActionImpl my_action_impl;
 373   (void)my_action_impl;
 374 }
 375
 376 TEST(ActionInterfaceTest, MakeAction) {
 377   Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
 378
 379   // When exercising the Perform() method of Action<F>, we must pass
 380   // it a tuple whose size and type are compatible with F's argument
 381   // types.  For example, if F is int(), then Perform() takes a
 382   // 0-tuple; if F is void(bool, int), then Perform() takes a
 383   // std::tuple<bool, int>, and so on.
 384   EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
 385 }
 386
 387 // Tests that Action<F> can be contructed from a pointer to
 388 // ActionInterface<F>.
 389 TEST(ActionTest, CanBeConstructedFromActionInterface) {
 390   Action<MyGlobalFunction> action(new MyActionImpl);
 391 }
 392
 393 // Tests that Action<F> delegates actual work to ActionInterface<F>.
 394 TEST(ActionTest, DelegatesWorkToActionInterface) {
 395   const Action<MyGlobalFunction> action(new MyActionImpl);
 396
 397   EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
 398   EXPECT_EQ(0, action.Perform(std::make_tuple(false, 1)));
 399 }
 400
 401 // Tests that Action<F> can be copied.
 402 TEST(ActionTest, IsCopyable) {
 403   Action<MyGlobalFunction> a1(new MyActionImpl);
 404   Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
 405
 406   // a1 should continue to work after being copied from.
 407   EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
 408   EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
 409
 410   // a2 should work like the action it was copied from.
 411   EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
 412   EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
 413
 414   a2 = a1;  // Tests the assignment operator.
 415
 416   // a1 should continue to work after being copied from.
 417   EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
 418   EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
 419
 420   // a2 should work like the action it was copied from.
 421   EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
 422   EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
 423 }
 424
 425 // Tests that an Action<From> object can be converted to a
 426 // compatible Action<To> object.
 427
 428 class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
 429  public:
 430   bool Perform(const std::tuple<int>& arg) override {
 431     return std::get<0>(arg) != 0;
 432   }
 433 };
 434
 435 TEST(ActionTest, CanBeConvertedToOtherActionType) {
 436   const Action<bool(int)> a1(new IsNotZero);  // NOLINT
 437   const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
 438   EXPECT_EQ(1, a2.Perform(std::make_tuple('a')));
 439   EXPECT_EQ(0, a2.Perform(std::make_tuple('\0')));
 440 }
 441
 442 // The following two classes are for testing MakePolymorphicAction().
 443
 444 // Implements a polymorphic action that returns the second of the
 445 // arguments it receives.
 446 class ReturnSecondArgumentAction {
 447  public:
 448   // We want to verify that MakePolymorphicAction() can work with a
 449   // polymorphic action whose Perform() method template is either
 450   // const or not.  This lets us verify the non-const case.
 451   template <typename Result, typename ArgumentTuple>
 452   Result Perform(const ArgumentTuple& args) {
 453     return std::get<1>(args);
 454   }
 455 };
 456
 457 // Implements a polymorphic action that can be used in a nullary
 458 // function to return 0.
 459 class ReturnZeroFromNullaryFunctionAction {
 460  public:
 461   // For testing that MakePolymorphicAction() works when the
 462   // implementation class' Perform() method template takes only one
 463   // template parameter.
 464   //
 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 const case.
 468   template <typename Result>
 469   Result Perform(const std::tuple<>&) const {
 470     return 0;
 471   }
 472 };
 473
 474 // These functions verify that MakePolymorphicAction() returns a
 475 // PolymorphicAction<T> where T is the argument's type.
 476
 477 PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
 478   return MakePolymorphicAction(ReturnSecondArgumentAction());
 479 }
 480
 481 PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
 482 ReturnZeroFromNullaryFunction() {
 483   return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
 484 }
 485
 486 // Tests that MakePolymorphicAction() turns a polymorphic action
 487 // implementation class into a polymorphic action.
 488 TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
 489   Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
 490   EXPECT_EQ(5, a1.Perform(std::make_tuple(false, 5, 2.0)));
 491 }
 492
 493 // Tests that MakePolymorphicAction() works when the implementation
 494 // class' Perform() method template has only one template parameter.
 495 TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
 496   Action<int()> a1 = ReturnZeroFromNullaryFunction();
 497   EXPECT_EQ(0, a1.Perform(std::make_tuple()));
 498
 499   Action<void*()> a2 = ReturnZeroFromNullaryFunction();
 500   EXPECT_TRUE(a2.Perform(std::make_tuple()) == nullptr);
 501 }
 502
 503 // Tests that Return() works as an action for void-returning
 504 // functions.
 505 TEST(ReturnTest, WorksForVoid) {
 506   const Action<void(int)> ret = Return();  // NOLINT
 507   return ret.Perform(std::make_tuple(1));
 508 }
 509
 510 // Tests that Return(v) returns v.
 511 TEST(ReturnTest, ReturnsGivenValue) {
 512   Action<int()> ret = Return(1);  // NOLINT
 513   EXPECT_EQ(1, ret.Perform(std::make_tuple()));
 514
 515   ret = Return(-5);
 516   EXPECT_EQ(-5, ret.Perform(std::make_tuple()));
 517 }
 518
 519 // Tests that Return("string literal") works.
 520 TEST(ReturnTest, AcceptsStringLiteral) {
 521   Action<const char*()> a1 = Return("Hello");
 522   EXPECT_STREQ("Hello", a1.Perform(std::make_tuple()));
 523
 524   Action<std::string()> a2 = Return("world");
 525   EXPECT_EQ("world", a2.Perform(std::make_tuple()));
 526 }
 527
 528 // Test struct which wraps a vector of integers. Used in
 529 // 'SupportsWrapperReturnType' test.
 530 struct IntegerVectorWrapper {
 531   std::vector<int> * v;
 532   IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
 533 };
 534
 535 // Tests that Return() works when return type is a wrapper type.
 536 TEST(ReturnTest, SupportsWrapperReturnType) {
 537   // Initialize vector of integers.
 538   std::vector<int> v;
 539   for (int i = 0; i < 5; ++i) v.push_back(i);
 540
 541   // Return() called with 'v' as argument. The Action will return the same data
 542   // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
 543   Action<IntegerVectorWrapper()> a = Return(v);
 544   const std::vector<int>& result = *(a.Perform(std::make_tuple()).v);
 545   EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
 546 }
 547
 548 // Tests that Return(v) is covaraint.
 549
 550 struct Base {
 551   bool operator==(const Base&) { return true; }
 552 };
 553
 554 struct Derived : public Base {
 555   bool operator==(const Derived&) { return true; }
 556 };
 557
 558 TEST(ReturnTest, IsCovariant) {
 559   Base base;
 560   Derived derived;
 561   Action<Base*()> ret = Return(&base);
 562   EXPECT_EQ(&base, ret.Perform(std::make_tuple()));
 563
 564   ret = Return(&derived);
 565   EXPECT_EQ(&derived, ret.Perform(std::make_tuple()));
 566 }
 567
 568 // Tests that the type of the value passed into Return is converted into T
 569 // when the action is cast to Action<T(...)> rather than when the action is
 570 // performed. See comments on testing::internal::ReturnAction in
 571 // gmock-actions.h for more information.
 572 class FromType {
 573  public:
 574   explicit FromType(bool* is_converted) : converted_(is_converted) {}
 575   bool* converted() const { return converted_; }
 576
 577  private:
 578   bool* const converted_;
 579 };
 580
 581 class ToType {
 582  public:
 583   // Must allow implicit conversion due to use in ImplicitCast_<T>.
 584   ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
 585 };
 586
 587 TEST(ReturnTest, ConvertsArgumentWhenConverted) {
 588   bool converted = false;
 589   FromType x(&converted);
 590   Action<ToType()> action(Return(x));
 591   EXPECT_TRUE(converted) << "Return must convert its argument in its own "
 592                          << "conversion operator.";
 593   converted = false;
 594   action.Perform(std::tuple<>());
 595   EXPECT_FALSE(converted) << "Action must NOT convert its argument "
 596                           << "when performed.";
 597 }
 598
 599 class DestinationType {};
 600
 601 class SourceType {
 602  public:
 603   // Note: a non-const typecast operator.
 604   operator DestinationType() { return DestinationType(); }
 605 };
 606
 607 TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
 608   SourceType s;
 609   Action<DestinationType()> action(Return(s));
 610 }
 611
 612 // Tests that ReturnNull() returns NULL in a pointer-returning function.
 613 TEST(ReturnNullTest, WorksInPointerReturningFunction) {
 614   const Action<int*()> a1 = ReturnNull();
 615   EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
 616
 617   const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
 618   EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr);
 619 }
 620
 621 // Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
 622 // functions.
 623 TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
 624   const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
 625   EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
 626
 627   const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
 628   EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr);
 629 }
 630
 631 // Tests that ReturnRef(v) works for reference types.
 632 TEST(ReturnRefTest, WorksForReference) {
 633   const int n = 0;
 634   const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT
 635
 636   EXPECT_EQ(&n, &ret.Perform(std::make_tuple(true)));
 637 }
 638
 639 // Tests that ReturnRef(v) is covariant.
 640 TEST(ReturnRefTest, IsCovariant) {
 641   Base base;
 642   Derived derived;
 643   Action<Base&()> a = ReturnRef(base);
 644   EXPECT_EQ(&base, &a.Perform(std::make_tuple()));
 645
 646   a = ReturnRef(derived);
 647   EXPECT_EQ(&derived, &a.Perform(std::make_tuple()));
 648 }
 649
 650 template <typename T, typename = decltype(ReturnRef(std::declval<T&&>()))>
 651 bool CanCallReturnRef(T&&) { return true; }
 652 bool CanCallReturnRef(Unused) { return false; }
 653
 654 // Tests that ReturnRef(v) is working with non-temporaries (T&)
 655 TEST(ReturnRefTest, WorksForNonTemporary) {
 656   int scalar_value = 123;
 657   EXPECT_TRUE(CanCallReturnRef(scalar_value));
 658
 659   std::string non_scalar_value("ABC");
 660   EXPECT_TRUE(CanCallReturnRef(non_scalar_value));
 661
 662   const int const_scalar_value{321};
 663   EXPECT_TRUE(CanCallReturnRef(const_scalar_value));
 664
 665   const std::string const_non_scalar_value("CBA");
 666   EXPECT_TRUE(CanCallReturnRef(const_non_scalar_value));
 667 }
 668
 669 // Tests that ReturnRef(v) is not working with temporaries (T&&)
 670 TEST(ReturnRefTest, DoesNotWorkForTemporary) {
 671   auto scalar_value = []()  -> int { return 123; };
 672   EXPECT_FALSE(CanCallReturnRef(scalar_value()));
 673
 674   auto non_scalar_value = []() -> std::string { return "ABC"; };
 675   EXPECT_FALSE(CanCallReturnRef(non_scalar_value()));
 676
 677   // cannot use here callable returning "const scalar type",
 678   // because such const for scalar return type is ignored
 679   EXPECT_FALSE(CanCallReturnRef(static_cast<const int>(321)));
 680
 681   auto const_non_scalar_value = []() -> const std::string { return "CBA"; };
 682   EXPECT_FALSE(CanCallReturnRef(const_non_scalar_value()));
 683 }
 684
 685 // Tests that ReturnRefOfCopy(v) works for reference types.
 686 TEST(ReturnRefOfCopyTest, WorksForReference) {
 687   int n = 42;
 688   const Action<const int&()> ret = ReturnRefOfCopy(n);
 689
 690   EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
 691   EXPECT_EQ(42, ret.Perform(std::make_tuple()));
 692
 693   n = 43;
 694   EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
 695   EXPECT_EQ(42, ret.Perform(std::make_tuple()));
 696 }
 697
 698 // Tests that ReturnRefOfCopy(v) is covariant.
 699 TEST(ReturnRefOfCopyTest, IsCovariant) {
 700   Base base;
 701   Derived derived;
 702   Action<Base&()> a = ReturnRefOfCopy(base);
 703   EXPECT_NE(&base, &a.Perform(std::make_tuple()));
 704
 705   a = ReturnRefOfCopy(derived);
 706   EXPECT_NE(&derived, &a.Perform(std::make_tuple()));
 707 }
 708
 709 // Tests that ReturnRoundRobin(v) works with initializer lists
 710 TEST(ReturnRoundRobinTest, WorksForInitList) {
 711   Action<int()> ret = ReturnRoundRobin({1, 2, 3});
 712
 713   EXPECT_EQ(1, ret.Perform(std::make_tuple()));
 714   EXPECT_EQ(2, ret.Perform(std::make_tuple()));
 715   EXPECT_EQ(3, ret.Perform(std::make_tuple()));
 716   EXPECT_EQ(1, ret.Perform(std::make_tuple()));
 717   EXPECT_EQ(2, ret.Perform(std::make_tuple()));
 718   EXPECT_EQ(3, ret.Perform(std::make_tuple()));
 719 }
 720
 721 // Tests that ReturnRoundRobin(v) works with vectors
 722 TEST(ReturnRoundRobinTest, WorksForVector) {
 723   std::vector<double> v = {4.4, 5.5, 6.6};
 724   Action<double()> ret = ReturnRoundRobin(v);
 725
 726   EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
 727   EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
 728   EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
 729   EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
 730   EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
 731   EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
 732 }
 733
 734 // Tests that DoDefault() does the default action for the mock method.
 735
 736 class MockClass {
 737  public:
 738   MockClass() {}
 739
 740   MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
 741   MOCK_METHOD0(Foo, MyNonDefaultConstructible());
 742   MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
 743   MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
 744   MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
 745   MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
 746   MOCK_METHOD2(TakeUnique,
 747                int(const std::unique_ptr<int>&, std::unique_ptr<int>));
 748
 749  private:
 750   GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
 751 };
 752
 753 // Tests that DoDefault() returns the built-in default value for the
 754 // return type by default.
 755 TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
 756   MockClass mock;
 757   EXPECT_CALL(mock, IntFunc(_))
 758       .WillOnce(DoDefault());
 759   EXPECT_EQ(0, mock.IntFunc(true));
 760 }
 761
 762 // Tests that DoDefault() throws (when exceptions are enabled) or aborts
 763 // the process when there is no built-in default value for the return type.
 764 TEST(DoDefaultDeathTest, DiesForUnknowType) {
 765   MockClass mock;
 766   EXPECT_CALL(mock, Foo())
 767       .WillRepeatedly(DoDefault());
 768 #if GTEST_HAS_EXCEPTIONS
 769   EXPECT_ANY_THROW(mock.Foo());
 770 #else
 771   EXPECT_DEATH_IF_SUPPORTED({
 772     mock.Foo();
 773   }, "");
 774 #endif
 775 }
 776
 777 // Tests that using DoDefault() inside a composite action leads to a
 778 // run-time error.
 779
 780 void VoidFunc(bool /* flag */) {}
 781
 782 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
 783   MockClass mock;
 784   EXPECT_CALL(mock, IntFunc(_))
 785       .WillRepeatedly(DoAll(Invoke(VoidFunc),
 786                             DoDefault()));
 787
 788   // Ideally we should verify the error message as well.  Sadly,
 789   // EXPECT_DEATH() can only capture stderr, while Google Mock's
 790   // errors are printed on stdout.  Therefore we have to settle for
 791   // not verifying the message.
 792   EXPECT_DEATH_IF_SUPPORTED({
 793     mock.IntFunc(true);
 794   }, "");
 795 }
 796
 797 // Tests that DoDefault() returns the default value set by
 798 // DefaultValue<T>::Set() when it's not overridden by an ON_CALL().
 799 TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
 800   DefaultValue<int>::Set(1);
 801   MockClass mock;
 802   EXPECT_CALL(mock, IntFunc(_))
 803       .WillOnce(DoDefault());
 804   EXPECT_EQ(1, mock.IntFunc(false));
 805   DefaultValue<int>::Clear();
 806 }
 807
 808 // Tests that DoDefault() does the action specified by ON_CALL().
 809 TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
 810   MockClass mock;
 811   ON_CALL(mock, IntFunc(_))
 812       .WillByDefault(Return(2));
 813   EXPECT_CALL(mock, IntFunc(_))
 814       .WillOnce(DoDefault());
 815   EXPECT_EQ(2, mock.IntFunc(false));
 816 }
 817
 818 // Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
 819 TEST(DoDefaultTest, CannotBeUsedInOnCall) {
 820   MockClass mock;
 821   EXPECT_NONFATAL_FAILURE({  // NOLINT
 822     ON_CALL(mock, IntFunc(_))
 823       .WillByDefault(DoDefault());
 824   }, "DoDefault() cannot be used in ON_CALL()");
 825 }
 826
 827 // Tests that SetArgPointee<N>(v) sets the variable pointed to by
 828 // the N-th (0-based) argument to v.
 829 TEST(SetArgPointeeTest, SetsTheNthPointee) {
 830   typedef void MyFunction(bool, int*, char*);
 831   Action<MyFunction> a = SetArgPointee<1>(2);
 832
 833   int n = 0;
 834   char ch = '\0';
 835   a.Perform(std::make_tuple(true, &n, &ch));
 836   EXPECT_EQ(2, n);
 837   EXPECT_EQ('\0', ch);
 838
 839   a = SetArgPointee<2>('a');
 840   n = 0;
 841   ch = '\0';
 842   a.Perform(std::make_tuple(true, &n, &ch));
 843   EXPECT_EQ(0, n);
 844   EXPECT_EQ('a', ch);
 845 }
 846
 847 // Tests that SetArgPointee<N>() accepts a string literal.
 848 TEST(SetArgPointeeTest, AcceptsStringLiteral) {
 849   typedef void MyFunction(std::string*, const char**);
 850   Action<MyFunction> a = SetArgPointee<0>("hi");
 851   std::string str;
 852   const char* ptr = nullptr;
 853   a.Perform(std::make_tuple(&str, &ptr));
 854   EXPECT_EQ("hi", str);
 855   EXPECT_TRUE(ptr == nullptr);
 856
 857   a = SetArgPointee<1>("world");
 858   str = "";
 859   a.Perform(std::make_tuple(&str, &ptr));
 860   EXPECT_EQ("", str);
 861   EXPECT_STREQ("world", ptr);
 862 }
 863
 864 TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
 865   typedef void MyFunction(const wchar_t**);
 866   Action<MyFunction> a = SetArgPointee<0>(L"world");
 867   const wchar_t* ptr = nullptr;
 868   a.Perform(std::make_tuple(&ptr));
 869   EXPECT_STREQ(L"world", ptr);
 870
 871 # if GTEST_HAS_STD_WSTRING
 872
 873   typedef void MyStringFunction(std::wstring*);
 874   Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
 875   std::wstring str = L"";
 876   a2.Perform(std::make_tuple(&str));
 877   EXPECT_EQ(L"world", str);
 878
 879 # endif
 880 }
 881
 882 // Tests that SetArgPointee<N>() accepts a char pointer.
 883 TEST(SetArgPointeeTest, AcceptsCharPointer) {
 884   typedef void MyFunction(bool, std::string*, const char**);
 885   const char* const hi = "hi";
 886   Action<MyFunction> a = SetArgPointee<1>(hi);
 887   std::string str;
 888   const char* ptr = nullptr;
 889   a.Perform(std::make_tuple(true, &str, &ptr));
 890   EXPECT_EQ("hi", str);
 891   EXPECT_TRUE(ptr == nullptr);
 892
 893   char world_array[] = "world";
 894   char* const world = world_array;
 895   a = SetArgPointee<2>(world);
 896   str = "";
 897   a.Perform(std::make_tuple(true, &str, &ptr));
 898   EXPECT_EQ("", str);
 899   EXPECT_EQ(world, ptr);
 900 }
 901
 902 TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
 903   typedef void MyFunction(bool, const wchar_t**);
 904   const wchar_t* const hi = L"hi";
 905   Action<MyFunction> a = SetArgPointee<1>(hi);
 906   const wchar_t* ptr = nullptr;
 907   a.Perform(std::make_tuple(true, &ptr));
 908   EXPECT_EQ(hi, ptr);
 909
 910 # if GTEST_HAS_STD_WSTRING
 911
 912   typedef void MyStringFunction(bool, std::wstring*);
 913   wchar_t world_array[] = L"world";
 914   wchar_t* const world = world_array;
 915   Action<MyStringFunction> a2 = SetArgPointee<1>(world);
 916   std::wstring str;
 917   a2.Perform(std::make_tuple(true, &str));
 918   EXPECT_EQ(world_array, str);
 919 # endif
 920 }
 921
 922 // Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
 923 // the N-th (0-based) argument to v.
 924 TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
 925   typedef void MyFunction(bool, int*, char*);
 926   Action<MyFunction> a = SetArgumentPointee<1>(2);
 927
 928   int n = 0;
 929   char ch = '\0';
 930   a.Perform(std::make_tuple(true, &n, &ch));
 931   EXPECT_EQ(2, n);
 932   EXPECT_EQ('\0', ch);
 933
 934   a = SetArgumentPointee<2>('a');
 935   n = 0;
 936   ch = '\0';
 937   a.Perform(std::make_tuple(true, &n, &ch));
 938   EXPECT_EQ(0, n);
 939   EXPECT_EQ('a', ch);
 940 }
 941
 942 // Sample functions and functors for testing Invoke() and etc.
 943 int Nullary() { return 1; }
 944
 945 class NullaryFunctor {
 946  public:
 947   int operator()() { return 2; }
 948 };
 949
 950 bool g_done = false;
 951 void VoidNullary() { g_done = true; }
 952
 953 class VoidNullaryFunctor {
 954  public:
 955   void operator()() { g_done = true; }
 956 };
 957
 958 short Short(short n) { return n; }  // NOLINT
 959 char Char(char ch) { return ch; }
 960
 961 const char* CharPtr(const char* s) { return s; }
 962
 963 bool Unary(int x) { return x < 0; }
 964
 965 const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
 966
 967 void VoidBinary(int, char) { g_done = true; }
 968
 969 int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
 970
 971 int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
 972
 973 class Foo {
 974  public:
 975   Foo() : value_(123) {}
 976
 977   int Nullary() const { return value_; }
 978
 979  private:
 980   int value_;
 981 };
 982
 983 // Tests InvokeWithoutArgs(function).
 984 TEST(InvokeWithoutArgsTest, Function) {
 985   // As an action that takes one argument.
 986   Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
 987   EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
 988
 989   // As an action that takes two arguments.
 990   Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
 991   EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
 992
 993   // As an action that returns void.
 994   Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
 995   g_done = false;
 996   a3.Perform(std::make_tuple(1));
 997   EXPECT_TRUE(g_done);
 998 }
 999
1000 // Tests InvokeWithoutArgs(functor).
1001 TEST(InvokeWithoutArgsTest, Functor) {
1002   // As an action that takes no argument.
1003   Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
1004   EXPECT_EQ(2, a.Perform(std::make_tuple()));
1005
1006   // As an action that takes three arguments.
1007   Action<int(int, double, char)> a2 =  // NOLINT
1008       InvokeWithoutArgs(NullaryFunctor());
1009   EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5, 'a')));
1010
1011   // As an action that returns void.
1012   Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
1013   g_done = false;
1014   a3.Perform(std::make_tuple());
1015   EXPECT_TRUE(g_done);
1016 }
1017
1018 // Tests InvokeWithoutArgs(obj_ptr, method).
1019 TEST(InvokeWithoutArgsTest, Method) {
1020   Foo foo;
1021   Action<int(bool, char)> a =  // NOLINT
1022       InvokeWithoutArgs(&foo, &Foo::Nullary);
1023   EXPECT_EQ(123, a.Perform(std::make_tuple(true, 'a')));
1024 }
1025
1026 // Tests using IgnoreResult() on a polymorphic action.
1027 TEST(IgnoreResultTest, PolymorphicAction) {
1028   Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
1029   a.Perform(std::make_tuple(1));
1030 }
1031
1032 // Tests using IgnoreResult() on a monomorphic action.
1033
1034 int ReturnOne() {
1035   g_done = true;
1036   return 1;
1037 }
1038
1039 TEST(IgnoreResultTest, MonomorphicAction) {
1040   g_done = false;
1041   Action<void()> a = IgnoreResult(Invoke(ReturnOne));
1042   a.Perform(std::make_tuple());
1043   EXPECT_TRUE(g_done);
1044 }
1045
1046 // Tests using IgnoreResult() on an action that returns a class type.
1047
1048 MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
1049   g_done = true;
1050   return MyNonDefaultConstructible(42);
1051 }
1052
1053 TEST(IgnoreResultTest, ActionReturningClass) {
1054   g_done = false;
1055   Action<void(int)> a =
1056       IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
1057   a.Perform(std::make_tuple(2));
1058   EXPECT_TRUE(g_done);
1059 }
1060
1061 TEST(AssignTest, Int) {
1062   int x = 0;
1063   Action<void(int)> a = Assign(&x, 5);
1064   a.Perform(std::make_tuple(0));
1065   EXPECT_EQ(5, x);
1066 }
1067
1068 TEST(AssignTest, String) {
1069   ::std::string x;
1070   Action<void(void)> a = Assign(&x, "Hello, world");
1071   a.Perform(std::make_tuple());
1072   EXPECT_EQ("Hello, world", x);
1073 }
1074
1075 TEST(AssignTest, CompatibleTypes) {
1076   double x = 0;
1077   Action<void(int)> a = Assign(&x, 5);
1078   a.Perform(std::make_tuple(0));
1079   EXPECT_DOUBLE_EQ(5, x);
1080 }
1081
1082
1083 // Tests using WithArgs and with an action that takes 1 argument.
1084 TEST(WithArgsTest, OneArg) {
1085   Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
1086   EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
1087   EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
1088 }
1089
1090 // Tests using WithArgs with an action that takes 2 arguments.
1091 TEST(WithArgsTest, TwoArgs) {
1092   Action<const char*(const char* s, double x, short n)> a =  // NOLINT
1093       WithArgs<0, 2>(Invoke(Binary));
1094   const char s[] = "Hello";
1095   EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
1096 }
1097
1098 struct ConcatAll {
1099   std::string operator()() const { return {}; }
1100   template <typename... I>
1101   std::string operator()(const char* a, I... i) const {
1102     return a + ConcatAll()(i...);
1103   }
1104 };
1105
1106 // Tests using WithArgs with an action that takes 10 arguments.
1107 TEST(WithArgsTest, TenArgs) {
1108   Action<std::string(const char*, const char*, const char*, const char*)> a =
1109       WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(ConcatAll{}));
1110   EXPECT_EQ("0123210123",
1111             a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
1112                                       CharPtr("3"))));
1113 }
1114
1115 // Tests using WithArgs with an action that is not Invoke().
1116 class SubtractAction : public ActionInterface<int(int, int)> {
1117  public:
1118   int Perform(const std::tuple<int, int>& args) override {
1119     return std::get<0>(args) - std::get<1>(args);
1120   }
1121 };
1122
1123 TEST(WithArgsTest, NonInvokeAction) {
1124   Action<int(const std::string&, int, int)> a =
1125       WithArgs<2, 1>(MakeAction(new SubtractAction));
1126   std::tuple<std::string, int, int> dummy =
1127       std::make_tuple(std::string("hi"), 2, 10);
1128   EXPECT_EQ(8, a.Perform(dummy));
1129 }
1130
1131 // Tests using WithArgs to pass all original arguments in the original order.
1132 TEST(WithArgsTest, Identity) {
1133   Action<int(int x, char y, short z)> a =  // NOLINT
1134       WithArgs<0, 1, 2>(Invoke(Ternary));
1135   EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
1136 }
1137
1138 // Tests using WithArgs with repeated arguments.
1139 TEST(WithArgsTest, RepeatedArguments) {
1140   Action<int(bool, int m, int n)> a =  // NOLINT
1141       WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
1142   EXPECT_EQ(4, a.Perform(std::make_tuple(false, 1, 10)));
1143 }
1144
1145 // Tests using WithArgs with reversed argument order.
1146 TEST(WithArgsTest, ReversedArgumentOrder) {
1147   Action<const char*(short n, const char* input)> a =  // NOLINT
1148       WithArgs<1, 0>(Invoke(Binary));
1149   const char s[] = "Hello";
1150   EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
1151 }
1152
1153 // Tests using WithArgs with compatible, but not identical, argument types.
1154 TEST(WithArgsTest, ArgsOfCompatibleTypes) {
1155   Action<long(short x, char y, double z, char c)> a =  // NOLINT
1156       WithArgs<0, 1, 3>(Invoke(Ternary));
1157   EXPECT_EQ(123,
1158             a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
1159 }
1160
1161 // Tests using WithArgs with an action that returns void.
1162 TEST(WithArgsTest, VoidAction) {
1163   Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
1164   g_done = false;
1165   a.Perform(std::make_tuple(1.5, 'a', 3));
1166   EXPECT_TRUE(g_done);
1167 }
1168
1169 TEST(WithArgsTest, ReturnReference) {
1170   Action<int&(int&, void*)> aa = WithArgs<0>([](int& a) -> int& { return a; });
1171   int i = 0;
1172   const int& res = aa.Perform(std::forward_as_tuple(i, nullptr));
1173   EXPECT_EQ(&i, &res);
1174 }
1175
1176 TEST(WithArgsTest, InnerActionWithConversion) {
1177   Action<Derived*()> inner = [] { return nullptr; };
1178   Action<Base*(double)> a = testing::WithoutArgs(inner);
1179   EXPECT_EQ(nullptr, a.Perform(std::make_tuple(1.1)));
1180 }
1181
1182 #if !GTEST_OS_WINDOWS_MOBILE
1183
1184 class SetErrnoAndReturnTest : public testing::Test {
1185  protected:
1186   void SetUp() override { errno = 0; }
1187   void TearDown() override { errno = 0; }
1188 };
1189
1190 TEST_F(SetErrnoAndReturnTest, Int) {
1191   Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
1192   EXPECT_EQ(-5, a.Perform(std::make_tuple()));
1193   EXPECT_EQ(ENOTTY, errno);
1194 }
1195
1196 TEST_F(SetErrnoAndReturnTest, Ptr) {
1197   int x;
1198   Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
1199   EXPECT_EQ(&x, a.Perform(std::make_tuple()));
1200   EXPECT_EQ(ENOTTY, errno);
1201 }
1202
1203 TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
1204   Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
1205   EXPECT_DOUBLE_EQ(5.0, a.Perform(std::make_tuple()));
1206   EXPECT_EQ(EINVAL, errno);
1207 }
1208
1209 #endif  // !GTEST_OS_WINDOWS_MOBILE
1210
1211 // Tests ByRef().
1212
1213 // Tests that the result of ByRef() is copyable.
1214 TEST(ByRefTest, IsCopyable) {
1215   const std::string s1 = "Hi";
1216   const std::string s2 = "Hello";
1217
1218   auto ref_wrapper = ByRef(s1);
1219   const std::string& r1 = ref_wrapper;
1220   EXPECT_EQ(&s1, &r1);
1221
1222   // Assigns a new value to ref_wrapper.
1223   ref_wrapper = ByRef(s2);
1224   const std::string& r2 = ref_wrapper;
1225   EXPECT_EQ(&s2, &r2);
1226
1227   auto ref_wrapper1 = ByRef(s1);
1228   // Copies ref_wrapper1 to ref_wrapper.
1229   ref_wrapper = ref_wrapper1;
1230   const std::string& r3 = ref_wrapper;
1231   EXPECT_EQ(&s1, &r3);
1232 }
1233
1234 // Tests using ByRef() on a const value.
1235 TEST(ByRefTest, ConstValue) {
1236   const int n = 0;
1237   // int& ref = ByRef(n);  // This shouldn't compile - we have a
1238                            // negative compilation test to catch it.
1239   const int& const_ref = ByRef(n);
1240   EXPECT_EQ(&n, &const_ref);
1241 }
1242
1243 // Tests using ByRef() on a non-const value.
1244 TEST(ByRefTest, NonConstValue) {
1245   int n = 0;
1246
1247   // ByRef(n) can be used as either an int&,
1248   int& ref = ByRef(n);
1249   EXPECT_EQ(&n, &ref);
1250
1251   // or a const int&.
1252   const int& const_ref = ByRef(n);
1253   EXPECT_EQ(&n, &const_ref);
1254 }
1255
1256 // Tests explicitly specifying the type when using ByRef().
1257 TEST(ByRefTest, ExplicitType) {
1258   int n = 0;
1259   const int& r1 = ByRef<const int>(n);
1260   EXPECT_EQ(&n, &r1);
1261
1262   // ByRef<char>(n);  // This shouldn't compile - we have a negative
1263                       // compilation test to catch it.
1264
1265   Derived d;
1266   Derived& r2 = ByRef<Derived>(d);
1267   EXPECT_EQ(&d, &r2);
1268
1269   const Derived& r3 = ByRef<const Derived>(d);
1270   EXPECT_EQ(&d, &r3);
1271
1272   Base& r4 = ByRef<Base>(d);
1273   EXPECT_EQ(&d, &r4);
1274
1275   const Base& r5 = ByRef<const Base>(d);
1276   EXPECT_EQ(&d, &r5);
1277
1278   // The following shouldn't compile - we have a negative compilation
1279   // test for it.
1280   //
1281   // Base b;
1282   // ByRef<Derived>(b);
1283 }
1284
1285 // Tests that Google Mock prints expression ByRef(x) as a reference to x.
1286 TEST(ByRefTest, PrintsCorrectly) {
1287   int n = 42;
1288   ::std::stringstream expected, actual;
1289   testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
1290   testing::internal::UniversalPrint(ByRef(n), &actual);
1291   EXPECT_EQ(expected.str(), actual.str());
1292 }
1293
1294 struct UnaryConstructorClass {
1295   explicit UnaryConstructorClass(int v) : value(v) {}
1296   int value;
1297 };
1298
1299 // Tests using ReturnNew() with a unary constructor.
1300 TEST(ReturnNewTest, Unary) {
1301   Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
1302   UnaryConstructorClass* c = a.Perform(std::make_tuple());
1303   EXPECT_EQ(4000, c->value);
1304   delete c;
1305 }
1306
1307 TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
1308   Action<UnaryConstructorClass*(bool, int)> a =
1309       ReturnNew<UnaryConstructorClass>(4000);
1310   UnaryConstructorClass* c = a.Perform(std::make_tuple(false, 5));
1311   EXPECT_EQ(4000, c->value);
1312   delete c;
1313 }
1314
1315 TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
1316   Action<const UnaryConstructorClass*()> a =
1317       ReturnNew<UnaryConstructorClass>(4000);
1318   const UnaryConstructorClass* c = a.Perform(std::make_tuple());
1319   EXPECT_EQ(4000, c->value);
1320   delete c;
1321 }
1322
1323 class TenArgConstructorClass {
1324  public:
1325   TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5, int a6, int a7,
1326                          int a8, int a9, int a10)
1327       : value_(a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10) {}
1328   int value_;
1329 };
1330
1331 // Tests using ReturnNew() with a 10-argument constructor.
1332 TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
1333   Action<TenArgConstructorClass*()> a = ReturnNew<TenArgConstructorClass>(
1334       1000000000, 200000000, 30000000, 4000000, 500000, 60000, 7000, 800, 90,
1335       0);
1336   TenArgConstructorClass* c = a.Perform(std::make_tuple());
1337   EXPECT_EQ(1234567890, c->value_);
1338   delete c;
1339 }
1340
1341 std::unique_ptr<int> UniquePtrSource() {
1342   return std::unique_ptr<int>(new int(19));
1343 }
1344
1345 std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
1346   std::vector<std::unique_ptr<int>> out;
1347   out.emplace_back(new int(7));
1348   return out;
1349 }
1350
1351 TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
1352   MockClass mock;
1353   std::unique_ptr<int> i(new int(19));
1354   EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
1355   EXPECT_CALL(mock, MakeVectorUnique())
1356       .WillOnce(Return(ByMove(VectorUniquePtrSource())));
1357   Derived* d = new Derived;
1358   EXPECT_CALL(mock, MakeUniqueBase())
1359       .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));
1360
1361   std::unique_ptr<int> result1 = mock.MakeUnique();
1362   EXPECT_EQ(19, *result1);
1363
1364   std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1365   EXPECT_EQ(1u, vresult.size());
1366   EXPECT_NE(nullptr, vresult[0]);
1367   EXPECT_EQ(7, *vresult[0]);
1368
1369   std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
1370   EXPECT_EQ(d, result2.get());
1371 }
1372
1373 TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
1374   testing::MockFunction<void()> mock_function;
1375   MockClass mock;
1376   std::unique_ptr<int> i(new int(19));
1377   EXPECT_CALL(mock_function, Call());
1378   EXPECT_CALL(mock, MakeUnique()).WillOnce(DoAll(
1379       InvokeWithoutArgs(&mock_function, &testing::MockFunction<void()>::Call),
1380       Return(ByMove(std::move(i)))));
1381
1382   std::unique_ptr<int> result1 = mock.MakeUnique();
1383   EXPECT_EQ(19, *result1);
1384 }
1385
1386 TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
1387   MockClass mock;
1388
1389   // Check default value
1390   DefaultValue<std::unique_ptr<int>>::SetFactory([] {
1391     return std::unique_ptr<int>(new int(42));
1392   });
1393   EXPECT_EQ(42, *mock.MakeUnique());
1394
1395   EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
1396   EXPECT_CALL(mock, MakeVectorUnique())
1397       .WillRepeatedly(Invoke(VectorUniquePtrSource));
1398   std::unique_ptr<int> result1 = mock.MakeUnique();
1399   EXPECT_EQ(19, *result1);
1400   std::unique_ptr<int> result2 = mock.MakeUnique();
1401   EXPECT_EQ(19, *result2);
1402   EXPECT_NE(result1, result2);
1403
1404   std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1405   EXPECT_EQ(1u, vresult.size());
1406   EXPECT_NE(nullptr, vresult[0]);
1407   EXPECT_EQ(7, *vresult[0]);
1408 }
1409
1410 TEST(MockMethodTest, CanTakeMoveOnlyValue) {
1411   MockClass mock;
1412   auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };
1413
1414   EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
1415     return *i;
1416   });
1417   // DoAll() does not compile, since it would move from its arguments twice.
1418   // EXPECT_CALL(mock, TakeUnique(_, _))
1419   //     .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
1420   //     Return(1)));
1421   EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
1422       .WillOnce(Return(-7))
1423       .RetiresOnSaturation();
1424   EXPECT_CALL(mock, TakeUnique(testing::IsNull()))
1425       .WillOnce(Return(-1))
1426       .RetiresOnSaturation();
1427
1428   EXPECT_EQ(5, mock.TakeUnique(make(5)));
1429   EXPECT_EQ(-7, mock.TakeUnique(make(7)));
1430   EXPECT_EQ(7, mock.TakeUnique(make(7)));
1431   EXPECT_EQ(7, mock.TakeUnique(make(7)));
1432   EXPECT_EQ(-1, mock.TakeUnique({}));
1433
1434   // Some arguments are moved, some passed by reference.
1435   auto lvalue = make(6);
1436   EXPECT_CALL(mock, TakeUnique(_, _))
1437       .WillOnce([](const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
1438         return *i * *j;
1439       });
1440   EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7)));
1441
1442   // The unique_ptr can be saved by the action.
1443   std::unique_ptr<int> saved;
1444   EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
1445     saved = std::move(i);
1446     return 0;
1447   });
1448   EXPECT_EQ(0, mock.TakeUnique(make(42)));
1449   EXPECT_EQ(42, *saved);
1450 }
1451
1452
1453 // Tests for std::function based action.
1454
1455 int Add(int val, int& ref, int* ptr) {  // NOLINT
1456   int result = val + ref + *ptr;
1457   ref = 42;
1458   *ptr = 43;
1459   return result;
1460 }
1461
1462 int Deref(std::unique_ptr<int> ptr) { return *ptr; }
1463
1464 struct Double {
1465   template <typename T>
1466   T operator()(T t) { return 2 * t; }
1467 };
1468
1469 std::unique_ptr<int> UniqueInt(int i) {
1470   return std::unique_ptr<int>(new int(i));
1471 }
1472
1473 TEST(FunctorActionTest, ActionFromFunction) {
1474   Action<int(int, int&, int*)> a = &Add;
1475   int x = 1, y = 2, z = 3;
1476   EXPECT_EQ(6, a.Perform(std::forward_as_tuple(x, y, &z)));
1477   EXPECT_EQ(42, y);
1478   EXPECT_EQ(43, z);
1479
1480   Action<int(std::unique_ptr<int>)> a1 = &Deref;
1481   EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
1482 }
1483
1484 TEST(FunctorActionTest, ActionFromLambda) {
1485   Action<int(bool, int)> a1 = [](bool b, int i) { return b ? i : 0; };
1486   EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
1487   EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 5)));
1488
1489   std::unique_ptr<int> saved;
1490   Action<void(std::unique_ptr<int>)> a2 = [&saved](std::unique_ptr<int> p) {
1491     saved = std::move(p);
1492   };
1493   a2.Perform(std::make_tuple(UniqueInt(5)));
1494   EXPECT_EQ(5, *saved);
1495 }
1496
1497 TEST(FunctorActionTest, PolymorphicFunctor) {
1498   Action<int(int)> ai = Double();
1499   EXPECT_EQ(2, ai.Perform(std::make_tuple(1)));
1500   Action<double(double)> ad = Double();  // Double? Double double!
1501   EXPECT_EQ(3.0, ad.Perform(std::make_tuple(1.5)));
1502 }
1503
1504 TEST(FunctorActionTest, TypeConversion) {
1505   // Numeric promotions are allowed.
1506   const Action<bool(int)> a1 = [](int i) { return i > 1; };
1507   const Action<int(bool)> a2 = Action<int(bool)>(a1);
1508   EXPECT_EQ(1, a1.Perform(std::make_tuple(42)));
1509   EXPECT_EQ(0, a2.Perform(std::make_tuple(42)));
1510
1511   // Implicit constructors are allowed.
1512   const Action<bool(std::string)> s1 = [](std::string s) { return !s.empty(); };
1513   const Action<int(const char*)> s2 = Action<int(const char*)>(s1);
1514   EXPECT_EQ(0, s2.Perform(std::make_tuple("")));
1515   EXPECT_EQ(1, s2.Perform(std::make_tuple("hello")));
1516
1517   // Also between the lambda and the action itself.
1518   const Action<bool(std::string)> x1 = [](Unused) { return 42; };
1519   const Action<bool(std::string)> x2 = [] { return 42; };
1520   EXPECT_TRUE(x1.Perform(std::make_tuple("hello")));
1521   EXPECT_TRUE(x2.Perform(std::make_tuple("hello")));
1522
1523   // Ensure decay occurs where required.
1524   std::function<int()> f = [] { return 7; };
1525   Action<int(int)> d = f;
1526   f = nullptr;
1527   EXPECT_EQ(7, d.Perform(std::make_tuple(1)));
1528
1529   // Ensure creation of an empty action succeeds.
1530   Action<void(int)>(nullptr);
1531 }
1532
1533 TEST(FunctorActionTest, UnusedArguments) {
1534   // Verify that users can ignore uninteresting arguments.
1535   Action<int(int, double y, double z)> a =
1536       [](int i, Unused, Unused) { return 2 * i; };
1537   std::tuple<int, double, double> dummy = std::make_tuple(3, 7.3, 9.44);
1538   EXPECT_EQ(6, a.Perform(dummy));
1539 }
1540
1541 // Test that basic built-in actions work with move-only arguments.
1542 TEST(MoveOnlyArgumentsTest, ReturningActions) {
1543   Action<int(std::unique_ptr<int>)> a = Return(1);
1544   EXPECT_EQ(1, a.Perform(std::make_tuple(nullptr)));
1545
1546   a = testing::WithoutArgs([]() { return 7; });
1547   EXPECT_EQ(7, a.Perform(std::make_tuple(nullptr)));
1548
1549   Action<void(std::unique_ptr<int>, int*)> a2 = testing::SetArgPointee<1>(3);
1550   int x = 0;
1551   a2.Perform(std::make_tuple(nullptr, &x));
1552   EXPECT_EQ(x, 3);
1553 }
1554
1555 ACTION(ReturnArity) {
1556   return std::tuple_size<args_type>::value;
1557 }
1558
1559 TEST(ActionMacro, LargeArity) {
1560   EXPECT_EQ(
1561       1, testing::Action<int(int)>(ReturnArity()).Perform(std::make_tuple(0)));
1562   EXPECT_EQ(
1563       10,
1564       testing::Action<int(int, int, int, int, int, int, int, int, int, int)>(
1565           ReturnArity())
1566           .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)));
1567   EXPECT_EQ(
1568       20,
1569       testing::Action<int(int, int, int, int, int, int, int, int, int, int, int,
1570                           int, int, int, int, int, int, int, int, int)>(
1571           ReturnArity())
1572           .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1573                                    14, 15, 16, 17, 18, 19)));
1574 }
1575
1576 }  // Unnamed namespace
1577
1578 #ifdef _MSC_VER
1579 #if _MSC_VER == 1900
1580 #  pragma warning(pop)
1581 #endif
1582 #endif
1583