38# pragma warning(disable:4100)
42# pragma warning(disable:4800)
46#include "gmock/gmock-actions.h"
52#include "gmock/gmock.h"
53#include "gmock/internal/gmock-port.h"
54#include "gtest/gtest.h"
55#include "gtest/gtest-spi.h"
60using ::testing::Action;
61using ::testing::ActionInterface;
62using ::testing::Assign;
63using ::testing::ByMove;
64using ::testing::ByRef;
65using ::testing::DefaultValue;
66using ::testing::DoAll;
67using ::testing::DoDefault;
68using ::testing::IgnoreResult;
69using ::testing::Invoke;
70using ::testing::InvokeWithoutArgs;
71using ::testing::MakePolymorphicAction;
72using ::testing::PolymorphicAction;
73using ::testing::Return;
74using ::testing::ReturnNew;
75using ::testing::ReturnNull;
76using ::testing::ReturnRef;
77using ::testing::ReturnRefOfCopy;
78using ::testing::ReturnRoundRobin;
79using ::testing::SetArgPointee;
80using ::testing::SetArgumentPointee;
81using ::testing::Unused;
82using ::testing::WithArgs;
83using ::testing::internal::BuiltInDefaultValue;
85#if !GTEST_OS_WINDOWS_MOBILE
86using ::testing::SetErrnoAndReturn;
90TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
91 EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() ==
nullptr);
92 EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() ==
nullptr);
93 EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() ==
nullptr);
97TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
98 EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
99 EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
100 EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
105TEST(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());
113 EXPECT_EQ(0U, BuiltInDefaultValue<wchar_t>::Get());
116 EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());
117 EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());
118 EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());
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());
123 EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());
124 EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());
125 EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long long>::Get());
126 EXPECT_EQ(0, BuiltInDefaultValue<signed long long>::Get());
127 EXPECT_EQ(0, BuiltInDefaultValue<long long>::Get());
128 EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
129 EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
134TEST(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());
141 EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());
142 EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());
143 EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());
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());
148 EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());
149 EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());
150 EXPECT_TRUE(BuiltInDefaultValue<unsigned long long>::Exists());
151 EXPECT_TRUE(BuiltInDefaultValue<signed long long>::Exists());
152 EXPECT_TRUE(BuiltInDefaultValue<long long>::Exists());
153 EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
154 EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
158TEST(BuiltInDefaultValueTest, IsFalseForBool) {
159 EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
163TEST(BuiltInDefaultValueTest, BoolExists) {
164 EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
169TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
170 EXPECT_EQ(
"", BuiltInDefaultValue< ::std::string>::Get());
175TEST(BuiltInDefaultValueTest, ExistsForString) {
176 EXPECT_TRUE(BuiltInDefaultValue< ::std::string>::Exists());
181TEST(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());
189class MyDefaultConstructible {
191 MyDefaultConstructible() : value_(42) {}
193 int value()
const {
return value_; }
200class MyNonDefaultConstructible {
203 explicit MyNonDefaultConstructible(
int a_value) : value_(a_value) {}
205 int value()
const {
return value_; }
212TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
213 EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
216TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
217 EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
221TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
222 EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
226TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
227 EXPECT_DEATH_IF_SUPPORTED({
228 BuiltInDefaultValue<int&>::Get();
230 EXPECT_DEATH_IF_SUPPORTED({
231 BuiltInDefaultValue<const char&>::Get();
235TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
236 EXPECT_DEATH_IF_SUPPORTED({
237 BuiltInDefaultValue<MyNonDefaultConstructible>::Get();
242TEST(DefaultValueTest, IsInitiallyUnset) {
243 EXPECT_FALSE(DefaultValue<int>::IsSet());
244 EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
245 EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
249TEST(DefaultValueTest, CanBeSetAndUnset) {
250 EXPECT_TRUE(DefaultValue<int>::Exists());
251 EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
253 DefaultValue<int>::Set(1);
254 DefaultValue<const MyNonDefaultConstructible>::Set(
255 MyNonDefaultConstructible(42));
257 EXPECT_EQ(1, DefaultValue<int>::Get());
258 EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
260 EXPECT_TRUE(DefaultValue<int>::Exists());
261 EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
263 DefaultValue<int>::Clear();
264 DefaultValue<const MyNonDefaultConstructible>::Clear();
266 EXPECT_FALSE(DefaultValue<int>::IsSet());
267 EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
269 EXPECT_TRUE(DefaultValue<int>::Exists());
270 EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
276TEST(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());
282 EXPECT_EQ(0, DefaultValue<int>::Get());
284 EXPECT_DEATH_IF_SUPPORTED({
285 DefaultValue<MyNonDefaultConstructible>::Get();
289TEST(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));
295 EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
296 std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
301TEST(DefaultValueTest, GetWorksForVoid) {
302 return DefaultValue<void>::Get();
308TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
309 EXPECT_FALSE(DefaultValue<int&>::IsSet());
310 EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
311 EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
315TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
316 EXPECT_FALSE(DefaultValue<int&>::Exists());
317 EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
318 EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
322TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
324 DefaultValue<const int&>::Set(n);
325 MyNonDefaultConstructible x(42);
326 DefaultValue<MyNonDefaultConstructible&>::Set(x);
328 EXPECT_TRUE(DefaultValue<const int&>::Exists());
329 EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
331 EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
332 EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
334 DefaultValue<const int&>::Clear();
335 DefaultValue<MyNonDefaultConstructible&>::Clear();
337 EXPECT_FALSE(DefaultValue<const int&>::Exists());
338 EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
340 EXPECT_FALSE(DefaultValue<const int&>::IsSet());
341 EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
347TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
348 EXPECT_FALSE(DefaultValue<int&>::IsSet());
349 EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
351 EXPECT_DEATH_IF_SUPPORTED({
352 DefaultValue<int&>::Get();
354 EXPECT_DEATH_IF_SUPPORTED({
355 DefaultValue<MyNonDefaultConstructible>::Get();
362typedef int MyGlobalFunction(
bool,
int);
364class MyActionImpl :
public ActionInterface<MyGlobalFunction> {
366 int Perform(
const std::tuple<bool, int>& args)
override {
367 return std::get<0>(args) ? std::get<1>(args) : 0;
371TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
372 MyActionImpl my_action_impl;
373 (void)my_action_impl;
376TEST(ActionInterfaceTest, MakeAction) {
377 Action<MyGlobalFunction> action = MakeAction(
new MyActionImpl);
384 EXPECT_EQ(5, action.Perform(std::make_tuple(
true, 5)));
389TEST(ActionTest, CanBeConstructedFromActionInterface) {
390 Action<MyGlobalFunction> action(
new MyActionImpl);
394TEST(ActionTest, DelegatesWorkToActionInterface) {
395 const Action<MyGlobalFunction> action(
new MyActionImpl);
397 EXPECT_EQ(5, action.Perform(std::make_tuple(
true, 5)));
398 EXPECT_EQ(0, action.Perform(std::make_tuple(
false, 1)));
402TEST(ActionTest, IsCopyable) {
403 Action<MyGlobalFunction> a1(
new MyActionImpl);
404 Action<MyGlobalFunction> a2(a1);
407 EXPECT_EQ(5, a1.Perform(std::make_tuple(
true, 5)));
408 EXPECT_EQ(0, a1.Perform(std::make_tuple(
false, 1)));
411 EXPECT_EQ(5, a2.Perform(std::make_tuple(
true, 5)));
412 EXPECT_EQ(0, a2.Perform(std::make_tuple(
false, 1)));
417 EXPECT_EQ(5, a1.Perform(std::make_tuple(
true, 5)));
418 EXPECT_EQ(0, a1.Perform(std::make_tuple(
false, 1)));
421 EXPECT_EQ(5, a2.Perform(std::make_tuple(
true, 5)));
422 EXPECT_EQ(0, a2.Perform(std::make_tuple(
false, 1)));
428class IsNotZero :
public ActionInterface<bool(int)> {
430 bool Perform(
const std::tuple<int>& arg)
override {
431 return std::get<0>(arg) != 0;
435TEST(ActionTest, CanBeConvertedToOtherActionType) {
436 const Action<bool(
int)> a1(
new IsNotZero);
437 const Action<int(
char)> a2 = Action<int(char)>(a1);
438 EXPECT_EQ(1, a2.Perform(std::make_tuple(
'a')));
439 EXPECT_EQ(0, a2.Perform(std::make_tuple(
'\0')));
446class ReturnSecondArgumentAction {
451 template <
typename Result,
typename ArgumentTuple>
452 Result Perform(
const ArgumentTuple& args) {
453 return std::get<1>(args);
459class ReturnZeroFromNullaryFunctionAction {
468 template <
typename Result>
469 Result Perform(
const std::tuple<>&)
const {
477PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
478 return MakePolymorphicAction(ReturnSecondArgumentAction());
481PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
482ReturnZeroFromNullaryFunction() {
483 return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
488TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
489 Action<int(
bool,
int,
double)> a1 = ReturnSecondArgument();
490 EXPECT_EQ(5, a1.Perform(std::make_tuple(
false, 5, 2.0)));
495TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
496 Action<int()> a1 = ReturnZeroFromNullaryFunction();
497 EXPECT_EQ(0, a1.Perform(std::make_tuple()));
499 Action<
void*()> a2 = ReturnZeroFromNullaryFunction();
500 EXPECT_TRUE(a2.Perform(std::make_tuple()) ==
nullptr);
505TEST(ReturnTest, WorksForVoid) {
506 const Action<void(
int)> ret = Return();
507 return ret.Perform(std::make_tuple(1));
511TEST(ReturnTest, ReturnsGivenValue) {
512 Action<int()> ret = Return(1);
513 EXPECT_EQ(1, ret.Perform(std::make_tuple()));
516 EXPECT_EQ(-5, ret.Perform(std::make_tuple()));
520TEST(ReturnTest, AcceptsStringLiteral) {
521 Action<
const char*()> a1 = Return(
"Hello");
522 EXPECT_STREQ(
"Hello", a1.Perform(std::make_tuple()));
524 Action<std::string()> a2 = Return(
"world");
525 EXPECT_EQ(
"world", a2.Perform(std::make_tuple()));
530struct IntegerVectorWrapper {
531 std::vector<int> * v;
532 IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}
536TEST(ReturnTest, SupportsWrapperReturnType) {
539 for (
int i = 0; i < 5; ++i) v.push_back(i);
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));
551 bool operator==(
const Base&) {
return true; }
554struct Derived :
public Base {
555 bool operator==(
const Derived&) {
return true; }
558TEST(ReturnTest, IsCovariant) {
561 Action<Base*()> ret = Return(&base);
562 EXPECT_EQ(&base, ret.Perform(std::make_tuple()));
564 ret = Return(&derived);
565 EXPECT_EQ(&derived, ret.Perform(std::make_tuple()));
574 explicit FromType(
bool* is_converted) : converted_(is_converted) {}
575 bool* converted()
const {
return converted_; }
578 bool*
const converted_;
584 ToType(
const FromType& x) { *x.converted() =
true; }
587TEST(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.";
594 action.Perform(std::tuple<>());
595 EXPECT_FALSE(converted) <<
"Action must NOT convert its argument "
596 <<
"when performed.";
599class DestinationType {};
604 operator DestinationType() {
return DestinationType(); }
607TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
609 Action<DestinationType()> action(Return(s));
613TEST(ReturnNullTest, WorksInPointerReturningFunction) {
614 const Action<
int*()> a1 = ReturnNull();
615 EXPECT_TRUE(a1.Perform(std::make_tuple()) ==
nullptr);
617 const Action<
const char*(bool)> a2 = ReturnNull();
618 EXPECT_TRUE(a2.Perform(std::make_tuple(
true)) ==
nullptr);
623TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
624 const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
625 EXPECT_TRUE(a1.Perform(std::make_tuple()) ==
nullptr);
627 const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
628 EXPECT_TRUE(a2.Perform(std::make_tuple(
"foo")) ==
nullptr);
632TEST(ReturnRefTest, WorksForReference) {
634 const Action<
const int&(bool)> ret = ReturnRef(n);
636 EXPECT_EQ(&n, &ret.Perform(std::make_tuple(
true)));
640TEST(ReturnRefTest, IsCovariant) {
643 Action<Base&()> a = ReturnRef(base);
644 EXPECT_EQ(&base, &a.Perform(std::make_tuple()));
646 a = ReturnRef(derived);
647 EXPECT_EQ(&derived, &a.Perform(std::make_tuple()));
650template <typename T, typename = decltype(ReturnRef(std::declval<T&&>()))>
651bool CanCallReturnRef(T&&) {
return true; }
652bool CanCallReturnRef(Unused) {
return false; }
655TEST(ReturnRefTest, WorksForNonTemporary) {
656 int scalar_value = 123;
657 EXPECT_TRUE(CanCallReturnRef(scalar_value));
659 std::string non_scalar_value(
"ABC");
660 EXPECT_TRUE(CanCallReturnRef(non_scalar_value));
662 const int const_scalar_value{321};
663 EXPECT_TRUE(CanCallReturnRef(const_scalar_value));
665 const std::string const_non_scalar_value(
"CBA");
666 EXPECT_TRUE(CanCallReturnRef(const_non_scalar_value));
670TEST(ReturnRefTest, DoesNotWorkForTemporary) {
671 auto scalar_value = []() ->
int {
return 123; };
672 EXPECT_FALSE(CanCallReturnRef(scalar_value()));
674 auto non_scalar_value = []() -> std::string {
return "ABC"; };
675 EXPECT_FALSE(CanCallReturnRef(non_scalar_value()));
679 EXPECT_FALSE(CanCallReturnRef(
static_cast<const int>(321)));
681 auto const_non_scalar_value = []() ->
const std::string {
return "CBA"; };
682 EXPECT_FALSE(CanCallReturnRef(const_non_scalar_value()));
686TEST(ReturnRefOfCopyTest, WorksForReference) {
688 const Action<
const int&()> ret = ReturnRefOfCopy(n);
690 EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
691 EXPECT_EQ(42, ret.Perform(std::make_tuple()));
694 EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
695 EXPECT_EQ(42, ret.Perform(std::make_tuple()));
699TEST(ReturnRefOfCopyTest, IsCovariant) {
702 Action<Base&()> a = ReturnRefOfCopy(base);
703 EXPECT_NE(&base, &a.Perform(std::make_tuple()));
705 a = ReturnRefOfCopy(derived);
706 EXPECT_NE(&derived, &a.Perform(std::make_tuple()));
710TEST(ReturnRoundRobinTest, WorksForInitList) {
711 Action<int()> ret = ReturnRoundRobin({1, 2, 3});
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()));
722TEST(ReturnRoundRobinTest, WorksForVector) {
723 std::vector<double> v = {4.4, 5.5, 6.6};
724 Action<double()> ret = ReturnRoundRobin(v);
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()));
740 MOCK_METHOD1(IntFunc,
int(
bool flag));
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>));
750 GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
755TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
757 EXPECT_CALL(mock, IntFunc(_))
758 .WillOnce(DoDefault());
759 EXPECT_EQ(0, mock.IntFunc(
true));
764TEST(DoDefaultDeathTest, DiesForUnknowType) {
766 EXPECT_CALL(mock, Foo())
767 .WillRepeatedly(DoDefault());
768#if GTEST_HAS_EXCEPTIONS
769 EXPECT_ANY_THROW(mock.Foo());
771 EXPECT_DEATH_IF_SUPPORTED({
780void VoidFunc(
bool ) {}
782TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
784 EXPECT_CALL(mock, IntFunc(_))
785 .WillRepeatedly(DoAll(Invoke(VoidFunc),
792 EXPECT_DEATH_IF_SUPPORTED({
799TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
800 DefaultValue<int>::Set(1);
802 EXPECT_CALL(mock, IntFunc(_))
803 .WillOnce(DoDefault());
804 EXPECT_EQ(1, mock.IntFunc(
false));
805 DefaultValue<int>::Clear();
809TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
811 ON_CALL(mock, IntFunc(_))
812 .WillByDefault(Return(2));
813 EXPECT_CALL(mock, IntFunc(_))
814 .WillOnce(DoDefault());
815 EXPECT_EQ(2, mock.IntFunc(
false));
819TEST(DoDefaultTest, CannotBeUsedInOnCall) {
821 EXPECT_NONFATAL_FAILURE({
822 ON_CALL(mock, IntFunc(_))
823 .WillByDefault(DoDefault());
824 },
"DoDefault() cannot be used in ON_CALL()");
829TEST(SetArgPointeeTest, SetsTheNthPointee) {
830 typedef void MyFunction(
bool,
int*,
char*);
831 Action<MyFunction> a = SetArgPointee<1>(2);
835 a.Perform(std::make_tuple(
true, &n, &ch));
839 a = SetArgPointee<2>(
'a');
842 a.Perform(std::make_tuple(
true, &n, &ch));
848TEST(SetArgPointeeTest, AcceptsStringLiteral) {
849 typedef void MyFunction(std::string*,
const char**);
850 Action<MyFunction> a = SetArgPointee<0>(
"hi");
852 const char* ptr =
nullptr;
853 a.Perform(std::make_tuple(&str, &ptr));
854 EXPECT_EQ(
"hi", str);
855 EXPECT_TRUE(ptr ==
nullptr);
857 a = SetArgPointee<1>(
"world");
859 a.Perform(std::make_tuple(&str, &ptr));
861 EXPECT_STREQ(
"world", ptr);
864TEST(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);
871# if GTEST_HAS_STD_WSTRING
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);
883TEST(SetArgPointeeTest, AcceptsCharPointer) {
884 typedef void MyFunction(
bool, std::string*,
const char**);
885 const char*
const hi =
"hi";
886 Action<MyFunction> a = SetArgPointee<1>(hi);
888 const char* ptr =
nullptr;
889 a.Perform(std::make_tuple(
true, &str, &ptr));
890 EXPECT_EQ(
"hi", str);
891 EXPECT_TRUE(ptr ==
nullptr);
893 char world_array[] =
"world";
894 char*
const world = world_array;
895 a = SetArgPointee<2>(world);
897 a.Perform(std::make_tuple(
true, &str, &ptr));
899 EXPECT_EQ(world, ptr);
902TEST(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));
910# if GTEST_HAS_STD_WSTRING
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);
917 a2.Perform(std::make_tuple(
true, &str));
918 EXPECT_EQ(world_array, str);
924TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
925 typedef void MyFunction(
bool,
int*,
char*);
926 Action<MyFunction> a = SetArgumentPointee<1>(2);
930 a.Perform(std::make_tuple(
true, &n, &ch));
934 a = SetArgumentPointee<2>(
'a');
937 a.Perform(std::make_tuple(
true, &n, &ch));
943int Nullary() {
return 1; }
945class NullaryFunctor {
947 int operator()() {
return 2; }
951void VoidNullary() { g_done =
true; }
953class VoidNullaryFunctor {
955 void operator()() { g_done =
true; }
958short Short(
short n) {
return n; }
959char Char(
char ch) {
return ch; }
961const char* CharPtr(
const char* s) {
return s; }
963bool Unary(
int x) {
return x < 0; }
965const char* Binary(
const char* input,
short n) {
return input + n; }
967void VoidBinary(
int,
char) { g_done =
true; }
969int Ternary(
int x,
char y,
short z) {
return x + y + z; }
971int SumOf4(
int a,
int b,
int c,
int d) {
return a + b + c + d; }
975 Foo() : value_(123) {}
977 int Nullary()
const {
return value_; }
984TEST(InvokeWithoutArgsTest, Function) {
986 Action<int(
int)> a = InvokeWithoutArgs(Nullary);
987 EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
990 Action<int(
int,
double)> a2 = InvokeWithoutArgs(Nullary);
991 EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
994 Action<void(
int)> a3 = InvokeWithoutArgs(VoidNullary);
996 a3.Perform(std::make_tuple(1));
1001TEST(InvokeWithoutArgsTest, Functor) {
1003 Action<int()> a = InvokeWithoutArgs(NullaryFunctor());
1004 EXPECT_EQ(2, a.Perform(std::make_tuple()));
1007 Action<int(
int,
double,
char)> a2 =
1008 InvokeWithoutArgs(NullaryFunctor());
1009 EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5,
'a')));
1012 Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
1014 a3.Perform(std::make_tuple());
1015 EXPECT_TRUE(g_done);
1019TEST(InvokeWithoutArgsTest, Method) {
1021 Action<int(
bool,
char)> a =
1022 InvokeWithoutArgs(&foo, &Foo::Nullary);
1023 EXPECT_EQ(123, a.Perform(std::make_tuple(
true,
'a')));
1027TEST(IgnoreResultTest, PolymorphicAction) {
1028 Action<void(
int)> a = IgnoreResult(Return(5));
1029 a.Perform(std::make_tuple(1));
1039TEST(IgnoreResultTest, MonomorphicAction) {
1041 Action<void()> a = IgnoreResult(Invoke(ReturnOne));
1042 a.Perform(std::make_tuple());
1043 EXPECT_TRUE(g_done);
1048MyNonDefaultConstructible ReturnMyNonDefaultConstructible(
double ) {
1050 return MyNonDefaultConstructible(42);
1053TEST(IgnoreResultTest, ActionReturningClass) {
1055 Action<void(
int)> a =
1056 IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));
1057 a.Perform(std::make_tuple(2));
1058 EXPECT_TRUE(g_done);
1061TEST(AssignTest, Int) {
1063 Action<void(
int)> a = Assign(&x, 5);
1064 a.Perform(std::make_tuple(0));
1068TEST(AssignTest, String) {
1070 Action<void(
void)> a = Assign(&x,
"Hello, world");
1071 a.Perform(std::make_tuple());
1072 EXPECT_EQ(
"Hello, world", x);
1075TEST(AssignTest, CompatibleTypes) {
1077 Action<void(
int)> a = Assign(&x, 5);
1078 a.Perform(std::make_tuple(0));
1079 EXPECT_DOUBLE_EQ(5, x);
1084TEST(WithArgsTest, OneArg) {
1085 Action<bool(
double x,
int n)> a = WithArgs<1>(Invoke(Unary));
1086 EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
1087 EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
1091TEST(WithArgsTest, TwoArgs) {
1092 Action<
const char*(
const char* s,
double x,
short n)> a =
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))));
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...);
1107TEST(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"),
1116class SubtractAction :
public ActionInterface<int(int, int)> {
1118 int Perform(
const std::tuple<int, int>& args)
override {
1119 return std::get<0>(args) - std::get<1>(args);
1123TEST(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));
1132TEST(WithArgsTest, Identity) {
1133 Action<int(
int x,
char y,
short z)> a =
1134 WithArgs<0, 1, 2>(Invoke(Ternary));
1135 EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
1139TEST(WithArgsTest, RepeatedArguments) {
1140 Action<int(
bool,
int m,
int n)> a =
1141 WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
1142 EXPECT_EQ(4, a.Perform(std::make_tuple(
false, 1, 10)));
1146TEST(WithArgsTest, ReversedArgumentOrder) {
1147 Action<
const char*(
short n,
const char* input)> a =
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))));
1154TEST(WithArgsTest, ArgsOfCompatibleTypes) {
1155 Action<long(
short x,
char y,
double z,
char c)> a =
1156 WithArgs<0, 1, 3>(Invoke(Ternary));
1158 a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
1162TEST(WithArgsTest, VoidAction) {
1163 Action<void(
double x,
char c,
int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
1165 a.Perform(std::make_tuple(1.5,
'a', 3));
1166 EXPECT_TRUE(g_done);
1169TEST(WithArgsTest, ReturnReference) {
1170 Action<
int&(
int&,
void*)> aa = WithArgs<0>([](
int& a) ->
int& {
return a; });
1172 const int& res = aa.Perform(std::forward_as_tuple(i,
nullptr));
1173 EXPECT_EQ(&i, &res);
1176TEST(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)));
1182#if !GTEST_OS_WINDOWS_MOBILE
1186 void SetUp()
override { errno = 0; }
1187 void TearDown()
override { errno = 0; }
1190TEST_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);
1196TEST_F(SetErrnoAndReturnTest, Ptr) {
1198 Action<
int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
1199 EXPECT_EQ(&x, a.Perform(std::make_tuple()));
1200 EXPECT_EQ(ENOTTY, errno);
1203TEST_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);
1214TEST(ByRefTest, IsCopyable) {
1215 const std::string s1 =
"Hi";
1216 const std::string s2 =
"Hello";
1218 auto ref_wrapper = ByRef(s1);
1219 const std::string& r1 = ref_wrapper;
1220 EXPECT_EQ(&s1, &r1);
1223 ref_wrapper = ByRef(s2);
1224 const std::string& r2 = ref_wrapper;
1225 EXPECT_EQ(&s2, &r2);
1227 auto ref_wrapper1 = ByRef(s1);
1229 ref_wrapper = ref_wrapper1;
1230 const std::string& r3 = ref_wrapper;
1231 EXPECT_EQ(&s1, &r3);
1235TEST(ByRefTest, ConstValue) {
1239 const int& const_ref = ByRef(n);
1240 EXPECT_EQ(&n, &const_ref);
1244TEST(ByRefTest, NonConstValue) {
1248 int& ref = ByRef(n);
1249 EXPECT_EQ(&n, &ref);
1252 const int& const_ref = ByRef(n);
1253 EXPECT_EQ(&n, &const_ref);
1257TEST(ByRefTest, ExplicitType) {
1259 const int& r1 = ByRef<const int>(n);
1266 Derived& r2 = ByRef<Derived>(d);
1269 const Derived& r3 = ByRef<const Derived>(d);
1272 Base& r4 = ByRef<Base>(d);
1275 const Base& r5 = ByRef<const Base>(d);
1286TEST(ByRefTest, PrintsCorrectly) {
1288 ::std::stringstream expected, actual;
1290 testing::internal::UniversalPrint(ByRef(n), &actual);
1291 EXPECT_EQ(expected.str(), actual.str());
1294struct UnaryConstructorClass {
1295 explicit UnaryConstructorClass(
int v) : value(v) {}
1300TEST(ReturnNewTest, Unary) {
1301 Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
1302 UnaryConstructorClass* c = a.Perform(std::make_tuple());
1303 EXPECT_EQ(4000, c->value);
1307TEST(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);
1315TEST(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);
1323class TenArgConstructorClass {
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) {}
1332TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
1333 Action<TenArgConstructorClass*()> a = ReturnNew<TenArgConstructorClass>(
1334 1000000000, 200000000, 30000000, 4000000, 500000, 60000, 7000, 800, 90,
1336 TenArgConstructorClass* c = a.Perform(std::make_tuple());
1337 EXPECT_EQ(1234567890, c->value_);
1341std::unique_ptr<int> UniquePtrSource() {
1342 return std::unique_ptr<int>(
new int(19));
1345std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
1346 std::vector<std::unique_ptr<int>> out;
1347 out.emplace_back(
new int(7));
1351TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
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))));
1361 std::unique_ptr<int> result1 = mock.MakeUnique();
1362 EXPECT_EQ(19, *result1);
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]);
1369 std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
1370 EXPECT_EQ(d, result2.get());
1373TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
1374 testing::MockFunction<void()> mock_function;
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)))));
1382 std::unique_ptr<int> result1 = mock.MakeUnique();
1383 EXPECT_EQ(19, *result1);
1386TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
1390 DefaultValue<std::unique_ptr<int>>::SetFactory([] {
1391 return std::unique_ptr<int>(
new int(42));
1393 EXPECT_EQ(42, *mock.MakeUnique());
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);
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]);
1410TEST(MockMethodTest, CanTakeMoveOnlyValue) {
1412 auto make = [](
int i) {
return std::unique_ptr<int>(
new int(i)); };
1414 EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
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();
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({}));
1435 auto lvalue = make(6);
1436 EXPECT_CALL(mock, TakeUnique(_, _))
1437 .WillOnce([](
const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
1440 EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7)));
1443 std::unique_ptr<int> saved;
1444 EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
1445 saved = std::move(i);
1448 EXPECT_EQ(0, mock.TakeUnique(make(42)));
1449 EXPECT_EQ(42, *saved);
1455int Add(
int val,
int& ref,
int* ptr) {
1456 int result = val + ref + *ptr;
1462int Deref(std::unique_ptr<int> ptr) {
return *ptr; }
1465 template <
typename T>
1466 T operator()(T t) {
return 2 * t; }
1469std::unique_ptr<int> UniqueInt(
int i) {
1470 return std::unique_ptr<int>(
new int(i));
1473TEST(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)));
1480 Action<int(std::unique_ptr<int>)> a1 = &Deref;
1481 EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
1484TEST(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)));
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);
1493 a2.Perform(std::make_tuple(UniqueInt(5)));
1494 EXPECT_EQ(5, *saved);
1497TEST(FunctorActionTest, PolymorphicFunctor) {
1498 Action<int(
int)> ai = Double();
1499 EXPECT_EQ(2, ai.Perform(std::make_tuple(1)));
1500 Action<double(
double)> ad = Double();
1501 EXPECT_EQ(3.0, ad.Perform(std::make_tuple(1.5)));
1504TEST(FunctorActionTest, TypeConversion) {
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)));
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")));
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")));
1524 std::function<int()> f = [] {
return 7; };
1525 Action<int(
int)> d = f;
1527 EXPECT_EQ(7, d.Perform(std::make_tuple(1)));
1530 Action<void(int)>(
nullptr);
1533TEST(FunctorActionTest, UnusedArguments) {
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));
1542TEST(MoveOnlyArgumentsTest, ReturningActions) {
1543 Action<int(std::unique_ptr<int>)> a = Return(1);
1544 EXPECT_EQ(1, a.Perform(std::make_tuple(
nullptr)));
1546 a = testing::WithoutArgs([]() {
return 7; });
1547 EXPECT_EQ(7, a.Perform(std::make_tuple(
nullptr)));
1549 Action<void(std::unique_ptr<int>,
int*)> a2 = testing::SetArgPointee<1>(3);
1551 a2.Perform(std::make_tuple(
nullptr, &x));
1555ACTION(ReturnArity) {
1556 return std::tuple_size<args_type>::value;
1559TEST(ActionMacro, LargeArity) {
1561 1,
testing::Action<
int(
int)>(ReturnArity()).Perform(std::make_tuple(0)));
1564 testing::Action<
int(
int,
int,
int,
int,
int,
int,
int,
int,
int,
int)>(
1566 .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)));
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)>(
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)));
1580# pragma warning(pop)
Definition gmock-actions.h:438
Definition gtest-printers.h:690