1 // Copyright 2007, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
30 // Google Mock - a framework for writing C++ mock classes.
32 // This file tests the built-in actions in gmock-actions.h.
39 #include "gmock/gmock-actions.h"
40 #include "gmock/gmock.h"
41 #include "gtest/gtest-spi.h"
42 #include "gtest/gtest.h"
45 namespace gmock_more_actions_test
{
50 using testing::Action
;
51 using testing::ActionInterface
;
52 using testing::DeleteArg
;
53 using testing::Invoke
;
54 using testing::Return
;
55 using testing::ReturnArg
;
56 using testing::ReturnPointee
;
57 using testing::SaveArg
;
58 using testing::SaveArgPointee
;
59 using testing::SetArgReferee
;
60 using testing::Unused
;
61 using testing::WithArg
;
62 using testing::WithoutArgs
;
64 // For suppressing compiler warnings on conversion possibly losing precision.
65 inline short Short(short n
) { return n
; } // NOLINT
66 inline char Char(char ch
) { return ch
; }
68 // Sample functions and functors for testing Invoke() and etc.
69 int Nullary() { return 1; }
71 class NullaryFunctor
{
73 int operator()() { return 2; }
77 void VoidNullary() { g_done
= true; }
79 class VoidNullaryFunctor
{
81 void operator()() { g_done
= true; }
84 bool Unary(int x
) { return x
< 0; }
86 const char* Plus1(const char* s
) { return s
+ 1; }
88 void VoidUnary(int /* n */) { g_done
= true; }
90 bool ByConstRef(const std::string
& s
) { return s
== "Hi"; }
92 const double g_double
= 0;
93 bool ReferencesGlobalDouble(const double& x
) { return &x
== &g_double
; }
95 std::string
ByNonConstRef(std::string
& s
) { return s
+= "+"; } // NOLINT
98 int operator()(bool x
) { return x
? 1 : -1; }
101 const char* Binary(const char* input
, short n
) { return input
+ n
; } // NOLINT
103 void VoidBinary(int, char) { g_done
= true; }
105 int Ternary(int x
, char y
, short z
) { return x
+ y
+ z
; } // NOLINT
107 void VoidTernary(int, char, bool) { g_done
= true; }
109 int SumOf4(int a
, int b
, int c
, int d
) { return a
+ b
+ c
+ d
; }
111 int SumOfFirst2(int a
, int b
, Unused
, Unused
) { return a
+ b
; }
113 void VoidFunctionWithFourArguments(char, int, float, double) { g_done
= true; }
115 std::string
Concat4(const char* s1
, const char* s2
, const char* s3
,
117 return std::string(s1
) + s2
+ s3
+ s4
;
120 int SumOf5(int a
, int b
, int c
, int d
, int e
) { return a
+ b
+ c
+ d
+ e
; }
122 struct SumOf5Functor
{
123 int operator()(int a
, int b
, int c
, int d
, int e
) {
124 return a
+ b
+ c
+ d
+ e
;
128 std::string
Concat5(const char* s1
, const char* s2
, const char* s3
,
129 const char* s4
, const char* s5
) {
130 return std::string(s1
) + s2
+ s3
+ s4
+ s5
;
133 int SumOf6(int a
, int b
, int c
, int d
, int e
, int f
) {
134 return a
+ b
+ c
+ d
+ e
+ f
;
137 struct SumOf6Functor
{
138 int operator()(int a
, int b
, int c
, int d
, int e
, int f
) {
139 return a
+ b
+ c
+ d
+ e
+ f
;
143 std::string
Concat6(const char* s1
, const char* s2
, const char* s3
,
144 const char* s4
, const char* s5
, const char* s6
) {
145 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
;
148 std::string
Concat7(const char* s1
, const char* s2
, const char* s3
,
149 const char* s4
, const char* s5
, const char* s6
,
151 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
;
154 std::string
Concat8(const char* s1
, const char* s2
, const char* s3
,
155 const char* s4
, const char* s5
, const char* s6
,
156 const char* s7
, const char* s8
) {
157 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
;
160 std::string
Concat9(const char* s1
, const char* s2
, const char* s3
,
161 const char* s4
, const char* s5
, const char* s6
,
162 const char* s7
, const char* s8
, const char* s9
) {
163 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
+ s9
;
166 std::string
Concat10(const char* s1
, const char* s2
, const char* s3
,
167 const char* s4
, const char* s5
, const char* s6
,
168 const char* s7
, const char* s8
, const char* s9
,
170 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
+ s9
+ s10
;
175 Foo() : value_(123) {}
177 int Nullary() const { return value_
; }
179 short Unary(long x
) { return static_cast<short>(value_
+ x
); } // NOLINT
181 std::string
Binary(const std::string
& str
, char c
) const { return str
+ c
; }
183 int Ternary(int x
, bool y
, char z
) { return value_
+ x
+ y
*z
; }
185 int SumOf4(int a
, int b
, int c
, int d
) const {
186 return a
+ b
+ c
+ d
+ value_
;
189 int SumOfLast2(Unused
, Unused
, int a
, int b
) const { return a
+ b
; }
191 int SumOf5(int a
, int b
, int c
, int d
, int e
) { return a
+ b
+ c
+ d
+ e
; }
193 int SumOf6(int a
, int b
, int c
, int d
, int e
, int f
) {
194 return a
+ b
+ c
+ d
+ e
+ f
;
197 std::string
Concat7(const char* s1
, const char* s2
, const char* s3
,
198 const char* s4
, const char* s5
, const char* s6
,
200 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
;
203 std::string
Concat8(const char* s1
, const char* s2
, const char* s3
,
204 const char* s4
, const char* s5
, const char* s6
,
205 const char* s7
, const char* s8
) {
206 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
;
209 std::string
Concat9(const char* s1
, const char* s2
, const char* s3
,
210 const char* s4
, const char* s5
, const char* s6
,
211 const char* s7
, const char* s8
, const char* s9
) {
212 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
+ s9
;
215 std::string
Concat10(const char* s1
, const char* s2
, const char* s3
,
216 const char* s4
, const char* s5
, const char* s6
,
217 const char* s7
, const char* s8
, const char* s9
,
219 return std::string(s1
) + s2
+ s3
+ s4
+ s5
+ s6
+ s7
+ s8
+ s9
+ s10
;
226 // Tests using Invoke() with a nullary function.
227 TEST(InvokeTest
, Nullary
) {
228 Action
<int()> a
= Invoke(Nullary
); // NOLINT
229 EXPECT_EQ(1, a
.Perform(std::make_tuple()));
232 // Tests using Invoke() with a unary function.
233 TEST(InvokeTest
, Unary
) {
234 Action
<bool(int)> a
= Invoke(Unary
); // NOLINT
235 EXPECT_FALSE(a
.Perform(std::make_tuple(1)));
236 EXPECT_TRUE(a
.Perform(std::make_tuple(-1)));
239 // Tests using Invoke() with a binary function.
240 TEST(InvokeTest
, Binary
) {
241 Action
<const char*(const char*, short)> a
= Invoke(Binary
); // NOLINT
242 const char* p
= "Hello";
243 EXPECT_EQ(p
+ 2, a
.Perform(std::make_tuple(p
, Short(2))));
246 // Tests using Invoke() with a ternary function.
247 TEST(InvokeTest
, Ternary
) {
248 Action
<int(int, char, short)> a
= Invoke(Ternary
); // NOLINT
249 EXPECT_EQ(6, a
.Perform(std::make_tuple(1, '\2', Short(3))));
252 // Tests using Invoke() with a 4-argument function.
253 TEST(InvokeTest
, FunctionThatTakes4Arguments
) {
254 Action
<int(int, int, int, int)> a
= Invoke(SumOf4
); // NOLINT
255 EXPECT_EQ(1234, a
.Perform(std::make_tuple(1000, 200, 30, 4)));
258 // Tests using Invoke() with a 5-argument function.
259 TEST(InvokeTest
, FunctionThatTakes5Arguments
) {
260 Action
<int(int, int, int, int, int)> a
= Invoke(SumOf5
); // NOLINT
261 EXPECT_EQ(12345, a
.Perform(std::make_tuple(10000, 2000, 300, 40, 5)));
264 // Tests using Invoke() with a 6-argument function.
265 TEST(InvokeTest
, FunctionThatTakes6Arguments
) {
266 Action
<int(int, int, int, int, int, int)> a
= Invoke(SumOf6
); // NOLINT
268 a
.Perform(std::make_tuple(100000, 20000, 3000, 400, 50, 6)));
271 // A helper that turns the type of a C-string literal from const
272 // char[N] to const char*.
273 inline const char* CharPtr(const char* s
) { return s
; }
275 // Tests using Invoke() with a 7-argument function.
276 TEST(InvokeTest
, FunctionThatTakes7Arguments
) {
277 Action
<std::string(const char*, const char*, const char*, const char*,
278 const char*, const char*, const char*)>
281 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
282 CharPtr("4"), CharPtr("5"), CharPtr("6"),
286 // Tests using Invoke() with a 8-argument function.
287 TEST(InvokeTest
, FunctionThatTakes8Arguments
) {
288 Action
<std::string(const char*, const char*, const char*, const char*,
289 const char*, const char*, const char*, const char*)>
291 EXPECT_EQ("12345678",
292 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
293 CharPtr("4"), CharPtr("5"), CharPtr("6"),
294 CharPtr("7"), CharPtr("8"))));
297 // Tests using Invoke() with a 9-argument function.
298 TEST(InvokeTest
, FunctionThatTakes9Arguments
) {
299 Action
<std::string(const char*, const char*, const char*, const char*,
300 const char*, const char*, const char*, const char*,
303 EXPECT_EQ("123456789", a
.Perform(std::make_tuple(
304 CharPtr("1"), CharPtr("2"), CharPtr("3"),
305 CharPtr("4"), CharPtr("5"), CharPtr("6"),
306 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
309 // Tests using Invoke() with a 10-argument function.
310 TEST(InvokeTest
, FunctionThatTakes10Arguments
) {
311 Action
<std::string(const char*, const char*, const char*, const char*,
312 const char*, const char*, const char*, const char*,
313 const char*, const char*)>
314 a
= Invoke(Concat10
);
315 EXPECT_EQ("1234567890",
316 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
317 CharPtr("4"), CharPtr("5"), CharPtr("6"),
318 CharPtr("7"), CharPtr("8"), CharPtr("9"),
322 // Tests using Invoke() with functions with parameters declared as Unused.
323 TEST(InvokeTest
, FunctionWithUnusedParameters
) {
324 Action
<int(int, int, double, const std::string
&)> a1
= Invoke(SumOfFirst2
);
325 std::tuple
<int, int, double, std::string
> dummy
=
326 std::make_tuple(10, 2, 5.6, std::string("hi"));
327 EXPECT_EQ(12, a1
.Perform(dummy
));
329 Action
<int(int, int, bool, int*)> a2
=
332 23, a2
.Perform(std::make_tuple(20, 3, true, static_cast<int*>(nullptr))));
335 // Tests using Invoke() with methods with parameters declared as Unused.
336 TEST(InvokeTest
, MethodWithUnusedParameters
) {
338 Action
<int(std::string
, bool, int, int)> a1
= Invoke(&foo
, &Foo::SumOfLast2
);
339 EXPECT_EQ(12, a1
.Perform(std::make_tuple(CharPtr("hi"), true, 10, 2)));
341 Action
<int(char, double, int, int)> a2
=
342 Invoke(&foo
, &Foo::SumOfLast2
);
343 EXPECT_EQ(23, a2
.Perform(std::make_tuple('a', 2.5, 20, 3)));
346 // Tests using Invoke() with a functor.
347 TEST(InvokeTest
, Functor
) {
348 Action
<long(long, int)> a
= Invoke(plus
<long>()); // NOLINT
349 EXPECT_EQ(3L, a
.Perform(std::make_tuple(1, 2)));
352 // Tests using Invoke(f) as an action of a compatible type.
353 TEST(InvokeTest
, FunctionWithCompatibleType
) {
354 Action
<long(int, short, char, bool)> a
= Invoke(SumOf4
); // NOLINT
355 EXPECT_EQ(4321, a
.Perform(std::make_tuple(4000, Short(300), Char(20), true)));
358 // Tests using Invoke() with an object pointer and a method pointer.
360 // Tests using Invoke() with a nullary method.
361 TEST(InvokeMethodTest
, Nullary
) {
363 Action
<int()> a
= Invoke(&foo
, &Foo::Nullary
); // NOLINT
364 EXPECT_EQ(123, a
.Perform(std::make_tuple()));
367 // Tests using Invoke() with a unary method.
368 TEST(InvokeMethodTest
, Unary
) {
370 Action
<short(long)> a
= Invoke(&foo
, &Foo::Unary
); // NOLINT
371 EXPECT_EQ(4123, a
.Perform(std::make_tuple(4000)));
374 // Tests using Invoke() with a binary method.
375 TEST(InvokeMethodTest
, Binary
) {
377 Action
<std::string(const std::string
&, char)> a
= Invoke(&foo
, &Foo::Binary
);
378 std::string
s("Hell");
379 std::tuple
<std::string
, char> dummy
= std::make_tuple(s
, 'o');
380 EXPECT_EQ("Hello", a
.Perform(dummy
));
383 // Tests using Invoke() with a ternary method.
384 TEST(InvokeMethodTest
, Ternary
) {
386 Action
<int(int, bool, char)> a
= Invoke(&foo
, &Foo::Ternary
); // NOLINT
387 EXPECT_EQ(1124, a
.Perform(std::make_tuple(1000, true, Char(1))));
390 // Tests using Invoke() with a 4-argument method.
391 TEST(InvokeMethodTest
, MethodThatTakes4Arguments
) {
393 Action
<int(int, int, int, int)> a
= Invoke(&foo
, &Foo::SumOf4
); // NOLINT
394 EXPECT_EQ(1357, a
.Perform(std::make_tuple(1000, 200, 30, 4)));
397 // Tests using Invoke() with a 5-argument method.
398 TEST(InvokeMethodTest
, MethodThatTakes5Arguments
) {
400 Action
<int(int, int, int, int, int)> a
= Invoke(&foo
, &Foo::SumOf5
); // NOLINT
401 EXPECT_EQ(12345, a
.Perform(std::make_tuple(10000, 2000, 300, 40, 5)));
404 // Tests using Invoke() with a 6-argument method.
405 TEST(InvokeMethodTest
, MethodThatTakes6Arguments
) {
407 Action
<int(int, int, int, int, int, int)> a
= // NOLINT
408 Invoke(&foo
, &Foo::SumOf6
);
410 a
.Perform(std::make_tuple(100000, 20000, 3000, 400, 50, 6)));
413 // Tests using Invoke() with a 7-argument method.
414 TEST(InvokeMethodTest
, MethodThatTakes7Arguments
) {
416 Action
<std::string(const char*, const char*, const char*, const char*,
417 const char*, const char*, const char*)>
418 a
= Invoke(&foo
, &Foo::Concat7
);
420 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
421 CharPtr("4"), CharPtr("5"), CharPtr("6"),
425 // Tests using Invoke() with a 8-argument method.
426 TEST(InvokeMethodTest
, MethodThatTakes8Arguments
) {
428 Action
<std::string(const char*, const char*, const char*, const char*,
429 const char*, const char*, const char*, const char*)>
430 a
= Invoke(&foo
, &Foo::Concat8
);
431 EXPECT_EQ("12345678",
432 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
433 CharPtr("4"), CharPtr("5"), CharPtr("6"),
434 CharPtr("7"), CharPtr("8"))));
437 // Tests using Invoke() with a 9-argument method.
438 TEST(InvokeMethodTest
, MethodThatTakes9Arguments
) {
440 Action
<std::string(const char*, const char*, const char*, const char*,
441 const char*, const char*, const char*, const char*,
443 a
= Invoke(&foo
, &Foo::Concat9
);
444 EXPECT_EQ("123456789", a
.Perform(std::make_tuple(
445 CharPtr("1"), CharPtr("2"), CharPtr("3"),
446 CharPtr("4"), CharPtr("5"), CharPtr("6"),
447 CharPtr("7"), CharPtr("8"), CharPtr("9"))));
450 // Tests using Invoke() with a 10-argument method.
451 TEST(InvokeMethodTest
, MethodThatTakes10Arguments
) {
453 Action
<std::string(const char*, const char*, const char*, const char*,
454 const char*, const char*, const char*, const char*,
455 const char*, const char*)>
456 a
= Invoke(&foo
, &Foo::Concat10
);
457 EXPECT_EQ("1234567890",
458 a
.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
459 CharPtr("4"), CharPtr("5"), CharPtr("6"),
460 CharPtr("7"), CharPtr("8"), CharPtr("9"),
464 // Tests using Invoke(f) as an action of a compatible type.
465 TEST(InvokeMethodTest
, MethodWithCompatibleType
) {
467 Action
<long(int, short, char, bool)> a
= // NOLINT
468 Invoke(&foo
, &Foo::SumOf4
);
469 EXPECT_EQ(4444, a
.Perform(std::make_tuple(4000, Short(300), Char(20), true)));
472 // Tests using WithoutArgs with an action that takes no argument.
473 TEST(WithoutArgsTest
, NoArg
) {
474 Action
<int(int n
)> a
= WithoutArgs(Invoke(Nullary
)); // NOLINT
475 EXPECT_EQ(1, a
.Perform(std::make_tuple(2)));
478 // Tests using WithArg with an action that takes 1 argument.
479 TEST(WithArgTest
, OneArg
) {
480 Action
<bool(double x
, int n
)> b
= WithArg
<1>(Invoke(Unary
)); // NOLINT
481 EXPECT_TRUE(b
.Perform(std::make_tuple(1.5, -1)));
482 EXPECT_FALSE(b
.Perform(std::make_tuple(1.5, 1)));
485 TEST(ReturnArgActionTest
, WorksForOneArgIntArg0
) {
486 const Action
<int(int)> a
= ReturnArg
<0>();
487 EXPECT_EQ(5, a
.Perform(std::make_tuple(5)));
490 TEST(ReturnArgActionTest
, WorksForMultiArgBoolArg0
) {
491 const Action
<bool(bool, bool, bool)> a
= ReturnArg
<0>();
492 EXPECT_TRUE(a
.Perform(std::make_tuple(true, false, false)));
495 TEST(ReturnArgActionTest
, WorksForMultiArgStringArg2
) {
496 const Action
<std::string(int, int, std::string
, int)> a
= ReturnArg
<2>();
497 EXPECT_EQ("seven", a
.Perform(std::make_tuple(5, 6, std::string("seven"), 8)));
500 TEST(SaveArgActionTest
, WorksForSameType
) {
502 const Action
<void(int n
)> a1
= SaveArg
<0>(&result
);
503 a1
.Perform(std::make_tuple(5));
504 EXPECT_EQ(5, result
);
507 TEST(SaveArgActionTest
, WorksForCompatibleType
) {
509 const Action
<void(bool, char)> a1
= SaveArg
<1>(&result
);
510 a1
.Perform(std::make_tuple(true, 'a'));
511 EXPECT_EQ('a', result
);
514 TEST(SaveArgPointeeActionTest
, WorksForSameType
) {
517 const Action
<void(const int*)> a1
= SaveArgPointee
<0>(&result
);
518 a1
.Perform(std::make_tuple(&value
));
519 EXPECT_EQ(5, result
);
522 TEST(SaveArgPointeeActionTest
, WorksForCompatibleType
) {
525 const Action
<void(bool, char*)> a1
= SaveArgPointee
<1>(&result
);
526 a1
.Perform(std::make_tuple(true, &value
));
527 EXPECT_EQ('a', result
);
530 TEST(SetArgRefereeActionTest
, WorksForSameType
) {
532 const Action
<void(int&)> a1
= SetArgReferee
<0>(1);
533 a1
.Perform(std::tuple
<int&>(value
));
537 TEST(SetArgRefereeActionTest
, WorksForCompatibleType
) {
539 const Action
<void(int, int&)> a1
= SetArgReferee
<1>('a');
540 a1
.Perform(std::tuple
<int, int&>(0, value
));
541 EXPECT_EQ('a', value
);
544 TEST(SetArgRefereeActionTest
, WorksWithExtraArguments
) {
546 const Action
<void(bool, int, int&, const char*)> a1
= SetArgReferee
<2>('a');
547 a1
.Perform(std::tuple
<bool, int, int&, const char*>(true, 0, value
, "hi"));
548 EXPECT_EQ('a', value
);
551 // A class that can be used to verify that its destructor is called: it will set
552 // the bool provided to the constructor to true when destroyed.
553 class DeletionTester
{
555 explicit DeletionTester(bool* is_deleted
)
556 : is_deleted_(is_deleted
) {
557 // Make sure the bit is set to false.
558 *is_deleted_
= false;
569 TEST(DeleteArgActionTest
, OneArg
) {
570 bool is_deleted
= false;
571 DeletionTester
* t
= new DeletionTester(&is_deleted
);
572 const Action
<void(DeletionTester
*)> a1
= DeleteArg
<0>(); // NOLINT
573 EXPECT_FALSE(is_deleted
);
574 a1
.Perform(std::make_tuple(t
));
575 EXPECT_TRUE(is_deleted
);
578 TEST(DeleteArgActionTest
, TenArgs
) {
579 bool is_deleted
= false;
580 DeletionTester
* t
= new DeletionTester(&is_deleted
);
581 const Action
<void(bool, int, int, const char*, bool,
582 int, int, int, int, DeletionTester
*)> a1
= DeleteArg
<9>();
583 EXPECT_FALSE(is_deleted
);
584 a1
.Perform(std::make_tuple(true, 5, 6, CharPtr("hi"), false, 7, 8, 9, 10, t
));
585 EXPECT_TRUE(is_deleted
);
588 #if GTEST_HAS_EXCEPTIONS
590 TEST(ThrowActionTest
, ThrowsGivenExceptionInVoidFunction
) {
591 const Action
<void(int n
)> a
= Throw('a');
592 EXPECT_THROW(a
.Perform(std::make_tuple(0)), char);
595 class MyException
{};
597 TEST(ThrowActionTest
, ThrowsGivenExceptionInNonVoidFunction
) {
598 const Action
<double(char ch
)> a
= Throw(MyException());
599 EXPECT_THROW(a
.Perform(std::make_tuple('0')), MyException
);
602 TEST(ThrowActionTest
, ThrowsGivenExceptionInNullaryFunction
) {
603 const Action
<double()> a
= Throw(MyException());
604 EXPECT_THROW(a
.Perform(std::make_tuple()), MyException
);
610 virtual void Func() {}
613 class MockObject
: public Object
{
615 ~MockObject() override
{}
616 MOCK_METHOD(void, Func
, (), (override
));
619 TEST(ThrowActionTest
, Times0
) {
620 EXPECT_NONFATAL_FAILURE(
624 ON_CALL(m
, Func()).WillByDefault([] { throw "something"; });
625 EXPECT_CALL(m
, Func()).Times(0);
628 // Exception is caught but Times(0) still triggers a failure.
634 #endif // GTEST_HAS_EXCEPTIONS
636 // Tests that SetArrayArgument<N>(first, last) sets the elements of the array
637 // pointed to by the N-th (0-based) argument to values in range [first, last).
638 TEST(SetArrayArgumentTest
, SetsTheNthArray
) {
639 typedef void MyFunction(bool, int*, char*);
640 int numbers
[] = { 1, 2, 3 };
641 Action
<MyFunction
> a
= SetArrayArgument
<1>(numbers
, numbers
+ 3);
647 a
.Perform(std::make_tuple(true, pn
, pch
));
652 EXPECT_EQ('\0', ch
[0]);
653 EXPECT_EQ('\0', ch
[1]);
654 EXPECT_EQ('\0', ch
[2]);
655 EXPECT_EQ('\0', ch
[3]);
657 // Tests first and last are iterators.
658 std::string letters
= "abc";
659 a
= SetArrayArgument
<2>(letters
.begin(), letters
.end());
660 std::fill_n(n
, 4, 0);
661 std::fill_n(ch
, 4, '\0');
662 a
.Perform(std::make_tuple(true, pn
, pch
));
667 EXPECT_EQ('a', ch
[0]);
668 EXPECT_EQ('b', ch
[1]);
669 EXPECT_EQ('c', ch
[2]);
670 EXPECT_EQ('\0', ch
[3]);
673 // Tests SetArrayArgument<N>(first, last) where first == last.
674 TEST(SetArrayArgumentTest
, SetsTheNthArrayWithEmptyRange
) {
675 typedef void MyFunction(bool, int*);
676 int numbers
[] = { 1, 2, 3 };
677 Action
<MyFunction
> a
= SetArrayArgument
<1>(numbers
, numbers
);
681 a
.Perform(std::make_tuple(true, pn
));
688 // Tests SetArrayArgument<N>(first, last) where *first is convertible
689 // (but not equal) to the argument type.
690 TEST(SetArrayArgumentTest
, SetsTheNthArrayWithConvertibleType
) {
691 typedef void MyFunction(bool, int*);
692 char chars
[] = { 97, 98, 99 };
693 Action
<MyFunction
> a
= SetArrayArgument
<1>(chars
, chars
+ 3);
695 int codes
[4] = { 111, 222, 333, 444 };
697 a
.Perform(std::make_tuple(true, pcodes
));
698 EXPECT_EQ(97, codes
[0]);
699 EXPECT_EQ(98, codes
[1]);
700 EXPECT_EQ(99, codes
[2]);
701 EXPECT_EQ(444, codes
[3]);
704 // Test SetArrayArgument<N>(first, last) with iterator as argument.
705 TEST(SetArrayArgumentTest
, SetsTheNthArrayWithIteratorArgument
) {
706 typedef void MyFunction(bool, std::back_insert_iterator
<std::string
>);
707 std::string letters
= "abc";
708 Action
<MyFunction
> a
= SetArrayArgument
<1>(letters
.begin(), letters
.end());
711 a
.Perform(std::make_tuple(true, back_inserter(s
)));
712 EXPECT_EQ(letters
, s
);
715 TEST(ReturnPointeeTest
, Works
) {
717 const Action
<int()> a
= ReturnPointee(&n
);
718 EXPECT_EQ(42, a
.Perform(std::make_tuple()));
721 EXPECT_EQ(43, a
.Perform(std::make_tuple()));
724 } // namespace gmock_generated_actions_test
725 } // namespace testing