gmock-actions_test.cc 60.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
29

30
31
32
33
// Google Mock - a framework for writing C++ mock classes.
//
// This file tests the built-in actions.

durandal's avatar
durandal committed
34
// Silence C4100 (unreferenced formal parameter) for MSVC
Gennadiy Civil's avatar
 
Gennadiy Civil committed
35
#ifdef _MSC_VER
36
37
#pragma warning(push)
#pragma warning(disable : 4100)
durandal's avatar
durandal committed
38
39
40
#if _MSC_VER == 1900
// and silence C4800 (C4800: 'int *const ': forcing value
// to bool 'true' or 'false') for MSVC 15
41
#pragma warning(disable : 4800)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
42
43
44
#endif
#endif

45
#include "gmock/gmock-actions.h"
46

47
48
#include <algorithm>
#include <iterator>
49
#include <memory>
50
#include <string>
51
#include <type_traits>
52

53
54
55
#include "gmock/gmock.h"
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest-spi.h"
56
#include "gtest/gtest.h"
57

58
namespace testing {
59
60
namespace {

Abseil Team's avatar
Abseil Team committed
61
using ::testing::internal::BuiltInDefaultValue;
62

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
TEST(TypeTraits, Negation) {
  // Direct use with std types.
  static_assert(std::is_base_of<std::false_type,
                                internal::negation<std::true_type>>::value,
                "");

  static_assert(std::is_base_of<std::true_type,
                                internal::negation<std::false_type>>::value,
                "");

  // With other types that fit the requirement of a value member that is
  // convertible to bool.
  static_assert(std::is_base_of<
                    std::true_type,
                    internal::negation<std::integral_constant<int, 0>>>::value,
                "");

  static_assert(std::is_base_of<
                    std::false_type,
                    internal::negation<std::integral_constant<int, 1>>>::value,
                "");

  static_assert(std::is_base_of<
                    std::false_type,
                    internal::negation<std::integral_constant<int, -1>>>::value,
                "");
}

// Weird false/true types that aren't actually bool constants (but should still
// be legal according to [meta.logical] because `bool(T::value)` is valid), are
// distinct from std::false_type and std::true_type, and are distinct from other
// instantiations of the same template.
//
// These let us check finicky details mandated by the standard like
// "std::conjunction should evaluate to a type that inherits from the first
// false-y input".
template <int>
struct MyFalse : std::integral_constant<int, 0> {};

template <int>
struct MyTrue : std::integral_constant<int, -1> {};

TEST(TypeTraits, Conjunction) {
  // Base case: always true.
  static_assert(std::is_base_of<std::true_type, internal::conjunction<>>::value,
                "");

  // One predicate: inherits from that predicate, regardless of value.
  static_assert(
      std::is_base_of<MyFalse<0>, internal::conjunction<MyFalse<0>>>::value,
      "");

  static_assert(
      std::is_base_of<MyTrue<0>, internal::conjunction<MyTrue<0>>>::value, "");

  // Multiple predicates, with at least one false: inherits from that one.
  static_assert(
      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
                                                        MyTrue<2>>>::value,
      "");

  static_assert(
      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
                                                        MyFalse<2>>>::value,
      "");

  // Short circuiting: in the case above, additional predicates need not even
  // define a value member.
  struct Empty {};
  static_assert(
      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
                                                        Empty>>::value,
      "");

  // All predicates true: inherits from the last.
  static_assert(
      std::is_base_of<MyTrue<2>, internal::conjunction<MyTrue<0>, MyTrue<1>,
                                                       MyTrue<2>>>::value,
      "");
}

TEST(TypeTraits, Disjunction) {
  // Base case: always false.
  static_assert(
      std::is_base_of<std::false_type, internal::disjunction<>>::value, "");

  // One predicate: inherits from that predicate, regardless of value.
  static_assert(
      std::is_base_of<MyFalse<0>, internal::disjunction<MyFalse<0>>>::value,
      "");

  static_assert(
      std::is_base_of<MyTrue<0>, internal::disjunction<MyTrue<0>>>::value, "");

  // Multiple predicates, with at least one true: inherits from that one.
  static_assert(
      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
                                                       MyFalse<2>>>::value,
      "");

  static_assert(
      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
                                                       MyTrue<2>>>::value,
      "");

  // Short circuiting: in the case above, additional predicates need not even
  // define a value member.
  struct Empty {};
  static_assert(
      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
                                                       Empty>>::value,
      "");

  // All predicates false: inherits from the last.
  static_assert(
      std::is_base_of<MyFalse<2>, internal::disjunction<MyFalse<0>, MyFalse<1>,
                                                        MyFalse<2>>>::value,
      "");
}

TEST(TypeTraits, IsInvocableRV) {
  struct C {
    int operator()() const { return 0; }
    void operator()(int) & {}
    std::string operator()(int) && { return ""; };
  };

  // The first overload is callable for const and non-const rvalues and lvalues.
  // It can be used to obtain an int, void, or anything int is convertible too.
  static_assert(internal::is_callable_r<int, C>::value, "");
  static_assert(internal::is_callable_r<int, C&>::value, "");
  static_assert(internal::is_callable_r<int, const C>::value, "");
  static_assert(internal::is_callable_r<int, const C&>::value, "");

  static_assert(internal::is_callable_r<void, C>::value, "");
  static_assert(internal::is_callable_r<char, C>::value, "");

  // It's possible to provide an int. If it's given to an lvalue, the result is
  // void. Otherwise it is std::string (which is also treated as allowed for a
  // void result type).
  static_assert(internal::is_callable_r<void, C&, int>::value, "");
  static_assert(!internal::is_callable_r<int, C&, int>::value, "");
  static_assert(!internal::is_callable_r<std::string, C&, int>::value, "");
  static_assert(!internal::is_callable_r<void, const C&, int>::value, "");

  static_assert(internal::is_callable_r<std::string, C, int>::value, "");
  static_assert(internal::is_callable_r<void, C, int>::value, "");
  static_assert(!internal::is_callable_r<int, C, int>::value, "");

  // It's not possible to provide other arguments.
  static_assert(!internal::is_callable_r<void, C, std::string>::value, "");
  static_assert(!internal::is_callable_r<void, C, int, int>::value, "");

  // Nothing should choke when we try to call other arguments besides directly
  // callable objects, but they should not show up as callable.
  static_assert(!internal::is_callable_r<void, int>::value, "");
  static_assert(!internal::is_callable_r<void, void (C::*)()>::value, "");
  static_assert(!internal::is_callable_r<void, void (C::*)(), C*>::value, "");
}
222
223
224

// Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
225
226
227
  EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == nullptr);
  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == nullptr);
  EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == nullptr);
228
229
}

230
231
232
233
234
235
236
// Tests that BuiltInDefaultValue<T*>::Exists() return true.
TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
  EXPECT_TRUE(BuiltInDefaultValue<int*>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<const char*>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<void*>::Exists());
}

237
238
239
// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
// built-in numeric type.
TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
240
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
241
242
  EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
243
#if GMOCK_WCHAR_T_IS_NATIVE_
244
#if !defined(__WCHAR_UNSIGNED__)
245
  EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
246
247
248
#else
  EXPECT_EQ(0U, BuiltInDefaultValue<wchar_t>::Get());
#endif
249
#endif
250
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
251
252
  EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());     // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());            // NOLINT
253
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
254
255
  EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
256
257
258
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());       // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());          // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());                 // NOLINT
Abseil Team's avatar
Abseil Team committed
259
  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long long>::Get());  // NOLINT
260
261
  EXPECT_EQ(0, BuiltInDefaultValue<signed long long>::Get());     // NOLINT
  EXPECT_EQ(0, BuiltInDefaultValue<long long>::Get());            // NOLINT
262
263
264
265
  EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
}

266
267
268
269
270
271
// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
// built-in numeric type.
TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
  EXPECT_TRUE(BuiltInDefaultValue<unsigned char>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<signed char>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<char>::Exists());
272
#if GMOCK_WCHAR_T_IS_NATIVE_
273
  EXPECT_TRUE(BuiltInDefaultValue<wchar_t>::Exists());
274
#endif
275
  EXPECT_TRUE(BuiltInDefaultValue<unsigned short>::Exists());  // NOLINT
276
277
  EXPECT_TRUE(BuiltInDefaultValue<signed short>::Exists());    // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<short>::Exists());           // NOLINT
278
279
280
  EXPECT_TRUE(BuiltInDefaultValue<unsigned int>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<signed int>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<int>::Exists());
281
282
283
  EXPECT_TRUE(BuiltInDefaultValue<unsigned long>::Exists());       // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<signed long>::Exists());         // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<long>::Exists());                // NOLINT
Abseil Team's avatar
Abseil Team committed
284
  EXPECT_TRUE(BuiltInDefaultValue<unsigned long long>::Exists());  // NOLINT
285
286
  EXPECT_TRUE(BuiltInDefaultValue<signed long long>::Exists());    // NOLINT
  EXPECT_TRUE(BuiltInDefaultValue<long long>::Exists());           // NOLINT
287
288
289
290
  EXPECT_TRUE(BuiltInDefaultValue<float>::Exists());
  EXPECT_TRUE(BuiltInDefaultValue<double>::Exists());
}

291
292
293
294
295
// Tests that BuiltInDefaultValue<bool>::Get() returns false.
TEST(BuiltInDefaultValueTest, IsFalseForBool) {
  EXPECT_FALSE(BuiltInDefaultValue<bool>::Get());
}

296
297
298
299
300
// Tests that BuiltInDefaultValue<bool>::Exists() returns true.
TEST(BuiltInDefaultValueTest, BoolExists) {
  EXPECT_TRUE(BuiltInDefaultValue<bool>::Exists());
}

301
302
303
// Tests that BuiltInDefaultValue<T>::Get() returns "" when T is a
// string type.
TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
304
  EXPECT_EQ("", BuiltInDefaultValue<::std::string>::Get());
305
306
}

307
308
309
// Tests that BuiltInDefaultValue<T>::Exists() returns true when T is a
// string type.
TEST(BuiltInDefaultValueTest, ExistsForString) {
310
  EXPECT_TRUE(BuiltInDefaultValue<::std::string>::Exists());
311
312
}

313
314
315
316
317
// Tests that BuiltInDefaultValue<const T>::Get() returns the same
// value as BuiltInDefaultValue<T>::Get() does.
TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
  EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
  EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
318
  EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == nullptr);
319
320
321
  EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
}

322
323
324
325
326
327
// A type that's default constructible.
class MyDefaultConstructible {
 public:
  MyDefaultConstructible() : value_(42) {}

  int value() const { return value_; }
328

329
330
 private:
  int value_;
331
332
};

333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
// A type that's not default constructible.
class MyNonDefaultConstructible {
 public:
  // Does not have a default ctor.
  explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}

  int value() const { return value_; }

 private:
  int value_;
};

TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
  EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
}

TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
  EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
}

TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
  EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
355
356
}

357
358
// Tests that BuiltInDefaultValue<T&>::Get() aborts the program.
TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
359
360
  EXPECT_DEATH_IF_SUPPORTED({ BuiltInDefaultValue<int&>::Get(); }, "");
  EXPECT_DEATH_IF_SUPPORTED({ BuiltInDefaultValue<const char&>::Get(); }, "");
361
362
}

363
TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructibleType) {
364
365
  EXPECT_DEATH_IF_SUPPORTED(
      { BuiltInDefaultValue<MyNonDefaultConstructible>::Get(); }, "");
366
367
368
369
370
}

// Tests that DefaultValue<T>::IsSet() is false initially.
TEST(DefaultValueTest, IsInitiallyUnset) {
  EXPECT_FALSE(DefaultValue<int>::IsSet());
371
372
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible>::IsSet());
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
373
374
375
376
}

// Tests that DefaultValue<T> can be set and then unset.
TEST(DefaultValueTest, CanBeSetAndUnset) {
377
  EXPECT_TRUE(DefaultValue<int>::Exists());
378
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
379

380
  DefaultValue<int>::Set(1);
381
382
  DefaultValue<const MyNonDefaultConstructible>::Set(
      MyNonDefaultConstructible(42));
383
384

  EXPECT_EQ(1, DefaultValue<int>::Get());
385
  EXPECT_EQ(42, DefaultValue<const MyNonDefaultConstructible>::Get().value());
386

387
  EXPECT_TRUE(DefaultValue<int>::Exists());
388
  EXPECT_TRUE(DefaultValue<const MyNonDefaultConstructible>::Exists());
389

390
  DefaultValue<int>::Clear();
391
  DefaultValue<const MyNonDefaultConstructible>::Clear();
392
393

  EXPECT_FALSE(DefaultValue<int>::IsSet());
394
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::IsSet());
395
396

  EXPECT_TRUE(DefaultValue<int>::Exists());
397
  EXPECT_FALSE(DefaultValue<const MyNonDefaultConstructible>::Exists());
398
399
400
401
402
403
404
}

// Tests that DefaultValue<T>::Get() returns the
// BuiltInDefaultValue<T>::Get() when DefaultValue<T>::IsSet() is
// false.
TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_FALSE(DefaultValue<int>::IsSet());
405
  EXPECT_TRUE(DefaultValue<int>::Exists());
406
407
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::IsSet());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible>::Exists());
408
409
410

  EXPECT_EQ(0, DefaultValue<int>::Get());

411
412
  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
                            "");
413
414
}

415
416
TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
417
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
418
419
  DefaultValue<std::unique_ptr<int>>::SetFactory(
      [] { return std::unique_ptr<int>(new int(42)); });
420
421
422
423
424
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
  EXPECT_EQ(42, *i);
}

425
// Tests that DefaultValue<void>::Get() returns void.
426
TEST(DefaultValueTest, GetWorksForVoid) { return DefaultValue<void>::Get(); }
427
428
429
430
431
432

// Tests using DefaultValue with a reference type.

// Tests that DefaultValue<T&>::IsSet() is false initially.
TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
  EXPECT_FALSE(DefaultValue<int&>::IsSet());
433
434
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::IsSet());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
435
436
}

437
438
439
// Tests that DefaultValue<T&>::Exists is false initiallly.
TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
  EXPECT_FALSE(DefaultValue<int&>::Exists());
440
441
  EXPECT_FALSE(DefaultValue<MyDefaultConstructible&>::Exists());
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
442
443
}

444
445
446
447
// Tests that DefaultValue<T&> can be set and then unset.
TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
  int n = 1;
  DefaultValue<const int&>::Set(n);
448
449
  MyNonDefaultConstructible x(42);
  DefaultValue<MyNonDefaultConstructible&>::Set(x);
450

451
  EXPECT_TRUE(DefaultValue<const int&>::Exists());
452
  EXPECT_TRUE(DefaultValue<MyNonDefaultConstructible&>::Exists());
453

454
  EXPECT_EQ(&n, &(DefaultValue<const int&>::Get()));
455
  EXPECT_EQ(&x, &(DefaultValue<MyNonDefaultConstructible&>::Get()));
456
457

  DefaultValue<const int&>::Clear();
458
  DefaultValue<MyNonDefaultConstructible&>::Clear();
459

460
  EXPECT_FALSE(DefaultValue<const int&>::Exists());
461
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::Exists());
462

463
  EXPECT_FALSE(DefaultValue<const int&>::IsSet());
464
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
465
466
467
468
469
470
471
}

// Tests that DefaultValue<T&>::Get() returns the
// BuiltInDefaultValue<T&>::Get() when DefaultValue<T&>::IsSet() is
// false.
TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_FALSE(DefaultValue<int&>::IsSet());
472
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
473

474
475
476
  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<int&>::Get(); }, "");
  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
                            "");
477
478
479
480
481
}

// Tests that ActionInterface can be implemented by defining the
// Perform method.

482
typedef int MyGlobalFunction(bool, int);
483

484
class MyActionImpl : public ActionInterface<MyGlobalFunction> {
485
 public:
Abseil Team's avatar
Abseil Team committed
486
  int Perform(const std::tuple<bool, int>& args) override {
Abseil Team's avatar
Abseil Team committed
487
    return std::get<0>(args) ? std::get<1>(args) : 0;
488
489
490
491
492
  }
};

TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
  MyActionImpl my_action_impl;
493
  (void)my_action_impl;
494
495
496
}

TEST(ActionInterfaceTest, MakeAction) {
497
  Action<MyGlobalFunction> action = MakeAction(new MyActionImpl);
498
499
500
501
502

  // When exercising the Perform() method of Action<F>, we must pass
  // it a tuple whose size and type are compatible with F's argument
  // types.  For example, if F is int(), then Perform() takes a
  // 0-tuple; if F is void(bool, int), then Perform() takes a
Abseil Team's avatar
Abseil Team committed
503
504
  // std::tuple<bool, int>, and so on.
  EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
505
506
}

slowy07's avatar
slowy07 committed
507
// Tests that Action<F> can be constructed from a pointer to
508
509
// ActionInterface<F>.
TEST(ActionTest, CanBeConstructedFromActionInterface) {
510
  Action<MyGlobalFunction> action(new MyActionImpl);
511
512
513
514
}

// Tests that Action<F> delegates actual work to ActionInterface<F>.
TEST(ActionTest, DelegatesWorkToActionInterface) {
515
  const Action<MyGlobalFunction> action(new MyActionImpl);
516

Abseil Team's avatar
Abseil Team committed
517
518
  EXPECT_EQ(5, action.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, action.Perform(std::make_tuple(false, 1)));
519
520
521
522
}

// Tests that Action<F> can be copied.
TEST(ActionTest, IsCopyable) {
523
524
  Action<MyGlobalFunction> a1(new MyActionImpl);
  Action<MyGlobalFunction> a2(a1);  // Tests the copy constructor.
525
526

  // a1 should continue to work after being copied from.
Abseil Team's avatar
Abseil Team committed
527
528
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
529
530

  // a2 should work like the action it was copied from.
Abseil Team's avatar
Abseil Team committed
531
532
  EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
533
534
535
536

  a2 = a1;  // Tests the assignment operator.

  // a1 should continue to work after being copied from.
Abseil Team's avatar
Abseil Team committed
537
538
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 1)));
539
540

  // a2 should work like the action it was copied from.
Abseil Team's avatar
Abseil Team committed
541
542
  EXPECT_EQ(5, a2.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(false, 1)));
543
544
545
546
547
548
549
}

// Tests that an Action<From> object can be converted to a
// compatible Action<To> object.

class IsNotZero : public ActionInterface<bool(int)> {  // NOLINT
 public:
Abseil Team's avatar
Abseil Team committed
550
  bool Perform(const std::tuple<int>& arg) override {
Abseil Team's avatar
Abseil Team committed
551
    return std::get<0>(arg) != 0;
552
553
554
555
  }
};

TEST(ActionTest, CanBeConvertedToOtherActionType) {
556
  const Action<bool(int)> a1(new IsNotZero);           // NOLINT
557
  const Action<int(char)> a2 = Action<int(char)>(a1);  // NOLINT
Abseil Team's avatar
Abseil Team committed
558
559
  EXPECT_EQ(1, a2.Perform(std::make_tuple('a')));
  EXPECT_EQ(0, a2.Perform(std::make_tuple('\0')));
560
561
562
563
564
565
566
567
568
569
570
571
}

// The following two classes are for testing MakePolymorphicAction().

// Implements a polymorphic action that returns the second of the
// arguments it receives.
class ReturnSecondArgumentAction {
 public:
  // We want to verify that MakePolymorphicAction() can work with a
  // polymorphic action whose Perform() method template is either
  // const or not.  This lets us verify the non-const case.
  template <typename Result, typename ArgumentTuple>
Abseil Team's avatar
Abseil Team committed
572
573
574
  Result Perform(const ArgumentTuple& args) {
    return std::get<1>(args);
  }
575
576
577
578
579
580
581
582
583
584
585
586
587
588
};

// Implements a polymorphic action that can be used in a nullary
// function to return 0.
class ReturnZeroFromNullaryFunctionAction {
 public:
  // For testing that MakePolymorphicAction() works when the
  // implementation class' Perform() method template takes only one
  // template parameter.
  //
  // We want to verify that MakePolymorphicAction() can work with a
  // polymorphic action whose Perform() method template is either
  // const or not.  This lets us verify the const case.
  template <typename Result>
Abseil Team's avatar
Abseil Team committed
589
590
591
  Result Perform(const std::tuple<>&) const {
    return 0;
  }
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
};

// These functions verify that MakePolymorphicAction() returns a
// PolymorphicAction<T> where T is the argument's type.

PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
  return MakePolymorphicAction(ReturnSecondArgumentAction());
}

PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
ReturnZeroFromNullaryFunction() {
  return MakePolymorphicAction(ReturnZeroFromNullaryFunctionAction());
}

// Tests that MakePolymorphicAction() turns a polymorphic action
// implementation class into a polymorphic action.
TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
  Action<int(bool, int, double)> a1 = ReturnSecondArgument();  // NOLINT
Abseil Team's avatar
Abseil Team committed
610
  EXPECT_EQ(5, a1.Perform(std::make_tuple(false, 5, 2.0)));
611
612
613
614
615
616
}

// Tests that MakePolymorphicAction() works when the implementation
// class' Perform() method template has only one template parameter.
TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
  Action<int()> a1 = ReturnZeroFromNullaryFunction();
Abseil Team's avatar
Abseil Team committed
617
  EXPECT_EQ(0, a1.Perform(std::make_tuple()));
618
619

  Action<void*()> a2 = ReturnZeroFromNullaryFunction();
Abseil Team's avatar
Abseil Team committed
620
  EXPECT_TRUE(a2.Perform(std::make_tuple()) == nullptr);
621
622
623
624
625
626
}

// Tests that Return() works as an action for void-returning
// functions.
TEST(ReturnTest, WorksForVoid) {
  const Action<void(int)> ret = Return();  // NOLINT
Abseil Team's avatar
Abseil Team committed
627
  return ret.Perform(std::make_tuple(1));
628
629
630
631
632
}

// Tests that Return(v) returns v.
TEST(ReturnTest, ReturnsGivenValue) {
  Action<int()> ret = Return(1);  // NOLINT
Abseil Team's avatar
Abseil Team committed
633
  EXPECT_EQ(1, ret.Perform(std::make_tuple()));
634
635

  ret = Return(-5);
Abseil Team's avatar
Abseil Team committed
636
  EXPECT_EQ(-5, ret.Perform(std::make_tuple()));
637
638
639
640
641
}

// Tests that Return("string literal") works.
TEST(ReturnTest, AcceptsStringLiteral) {
  Action<const char*()> a1 = Return("Hello");
Abseil Team's avatar
Abseil Team committed
642
  EXPECT_STREQ("Hello", a1.Perform(std::make_tuple()));
643
644

  Action<std::string()> a2 = Return("world");
Abseil Team's avatar
Abseil Team committed
645
  EXPECT_EQ("world", a2.Perform(std::make_tuple()));
646
647
}

648
649
650
// Test struct which wraps a vector of integers. Used in
// 'SupportsWrapperReturnType' test.
struct IntegerVectorWrapper {
651
  std::vector<int>* v;
652
653
654
655
656
657
658
659
660
661
662
663
  IntegerVectorWrapper(std::vector<int>& _v) : v(&_v) {}  // NOLINT
};

// Tests that Return() works when return type is a wrapper type.
TEST(ReturnTest, SupportsWrapperReturnType) {
  // Initialize vector of integers.
  std::vector<int> v;
  for (int i = 0; i < 5; ++i) v.push_back(i);

  // Return() called with 'v' as argument. The Action will return the same data
  // as 'v' (copy) but it will be wrapped in an IntegerVectorWrapper.
  Action<IntegerVectorWrapper()> a = Return(v);
Abseil Team's avatar
Abseil Team committed
664
  const std::vector<int>& result = *(a.Perform(std::make_tuple()).v);
665
666
667
  EXPECT_THAT(result, ::testing::ElementsAre(0, 1, 2, 3, 4));
}

668
669
670
671
672
673
674
675
676
677
678
679
680
681
// Tests that Return(v) is covaraint.

struct Base {
  bool operator==(const Base&) { return true; }
};

struct Derived : public Base {
  bool operator==(const Derived&) { return true; }
};

TEST(ReturnTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base*()> ret = Return(&base);
Abseil Team's avatar
Abseil Team committed
682
  EXPECT_EQ(&base, ret.Perform(std::make_tuple()));
683
684

  ret = Return(&derived);
Abseil Team's avatar
Abseil Team committed
685
  EXPECT_EQ(&derived, ret.Perform(std::make_tuple()));
686
687
}

688
689
690
691
692
693
// Tests that the type of the value passed into Return is converted into T
// when the action is cast to Action<T(...)> rather than when the action is
// performed. See comments on testing::internal::ReturnAction in
// gmock-actions.h for more information.
class FromType {
 public:
694
  explicit FromType(bool* is_converted) : converted_(is_converted) {}
695
696
697
698
699
700
701
702
  bool* converted() const { return converted_; }

 private:
  bool* const converted_;
};

class ToType {
 public:
703
704
  // Must allow implicit conversion due to use in ImplicitCast_<T>.
  ToType(const FromType& x) { *x.converted() = true; }  // NOLINT
705
706
707
708
709
710
711
712
713
};

TEST(ReturnTest, ConvertsArgumentWhenConverted) {
  bool converted = false;
  FromType x(&converted);
  Action<ToType()> action(Return(x));
  EXPECT_TRUE(converted) << "Return must convert its argument in its own "
                         << "conversion operator.";
  converted = false;
Abseil Team's avatar
Abseil Team committed
714
  action.Perform(std::tuple<>());
715
  EXPECT_FALSE(converted) << "Action must NOT convert its argument "
716
                          << "when performed.";
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
}

class DestinationType {};

class SourceType {
 public:
  // Note: a non-const typecast operator.
  operator DestinationType() { return DestinationType(); }
};

TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
  SourceType s;
  Action<DestinationType()> action(Return(s));
}

732
733
734
// Tests that ReturnNull() returns NULL in a pointer-returning function.
TEST(ReturnNullTest, WorksInPointerReturningFunction) {
  const Action<int*()> a1 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
735
  EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
736
737

  const Action<const char*(bool)> a2 = ReturnNull();  // NOLINT
Abseil Team's avatar
Abseil Team committed
738
  EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr);
739
740
}

741
742
743
744
// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
// functions.
TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
  const Action<std::unique_ptr<const int>()> a1 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
745
  EXPECT_TRUE(a1.Perform(std::make_tuple()) == nullptr);
746
747

  const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
Abseil Team's avatar
Abseil Team committed
748
  EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr);
749
750
}

751
752
753
754
755
// Tests that ReturnRef(v) works for reference types.
TEST(ReturnRefTest, WorksForReference) {
  const int n = 0;
  const Action<const int&(bool)> ret = ReturnRef(n);  // NOLINT

Abseil Team's avatar
Abseil Team committed
756
  EXPECT_EQ(&n, &ret.Perform(std::make_tuple(true)));
757
758
759
760
761
762
763
}

// Tests that ReturnRef(v) is covariant.
TEST(ReturnRefTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base&()> a = ReturnRef(base);
Abseil Team's avatar
Abseil Team committed
764
  EXPECT_EQ(&base, &a.Perform(std::make_tuple()));
765
766

  a = ReturnRef(derived);
Abseil Team's avatar
Abseil Team committed
767
  EXPECT_EQ(&derived, &a.Perform(std::make_tuple()));
768
769
}

770
template <typename T, typename = decltype(ReturnRef(std::declval<T&&>()))>
771
772
773
bool CanCallReturnRef(T&&) {
  return true;
}
774
bool CanCallReturnRef(Unused) { return false; }
775
776

// Tests that ReturnRef(v) is working with non-temporaries (T&)
777
TEST(ReturnRefTest, WorksForNonTemporary) {
778
779
  int scalar_value = 123;
  EXPECT_TRUE(CanCallReturnRef(scalar_value));
780

781
782
  std::string non_scalar_value("ABC");
  EXPECT_TRUE(CanCallReturnRef(non_scalar_value));
783

784
785
  const int const_scalar_value{321};
  EXPECT_TRUE(CanCallReturnRef(const_scalar_value));
786

787
788
  const std::string const_non_scalar_value("CBA");
  EXPECT_TRUE(CanCallReturnRef(const_non_scalar_value));
789
790
791
}

// Tests that ReturnRef(v) is not working with temporaries (T&&)
792
TEST(ReturnRefTest, DoesNotWorkForTemporary) {
793
  auto scalar_value = []() -> int { return 123; };
794
  EXPECT_FALSE(CanCallReturnRef(scalar_value()));
795

796
797
  auto non_scalar_value = []() -> std::string { return "ABC"; };
  EXPECT_FALSE(CanCallReturnRef(non_scalar_value()));
798

Piotr Nycz's avatar
Piotr Nycz committed
799
800
  // cannot use here callable returning "const scalar type",
  // because such const for scalar return type is ignored
801
  EXPECT_FALSE(CanCallReturnRef(static_cast<const int>(321)));
802

803
804
  auto const_non_scalar_value = []() -> const std::string { return "CBA"; };
  EXPECT_FALSE(CanCallReturnRef(const_non_scalar_value()));
805
}
806

807
808
809
810
811
// Tests that ReturnRefOfCopy(v) works for reference types.
TEST(ReturnRefOfCopyTest, WorksForReference) {
  int n = 42;
  const Action<const int&()> ret = ReturnRefOfCopy(n);

Abseil Team's avatar
Abseil Team committed
812
813
  EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
  EXPECT_EQ(42, ret.Perform(std::make_tuple()));
814
815

  n = 43;
Abseil Team's avatar
Abseil Team committed
816
817
  EXPECT_NE(&n, &ret.Perform(std::make_tuple()));
  EXPECT_EQ(42, ret.Perform(std::make_tuple()));
818
819
820
821
822
823
824
}

// Tests that ReturnRefOfCopy(v) is covariant.
TEST(ReturnRefOfCopyTest, IsCovariant) {
  Base base;
  Derived derived;
  Action<Base&()> a = ReturnRefOfCopy(base);
Abseil Team's avatar
Abseil Team committed
825
  EXPECT_NE(&base, &a.Perform(std::make_tuple()));
826
827

  a = ReturnRefOfCopy(derived);
Abseil Team's avatar
Abseil Team committed
828
  EXPECT_NE(&derived, &a.Perform(std::make_tuple()));
829
830
}

Abseil Team's avatar
Abseil Team committed
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
// Tests that ReturnRoundRobin(v) works with initializer lists
TEST(ReturnRoundRobinTest, WorksForInitList) {
  Action<int()> ret = ReturnRoundRobin({1, 2, 3});

  EXPECT_EQ(1, ret.Perform(std::make_tuple()));
  EXPECT_EQ(2, ret.Perform(std::make_tuple()));
  EXPECT_EQ(3, ret.Perform(std::make_tuple()));
  EXPECT_EQ(1, ret.Perform(std::make_tuple()));
  EXPECT_EQ(2, ret.Perform(std::make_tuple()));
  EXPECT_EQ(3, ret.Perform(std::make_tuple()));
}

// Tests that ReturnRoundRobin(v) works with vectors
TEST(ReturnRoundRobinTest, WorksForVector) {
  std::vector<double> v = {4.4, 5.5, 6.6};
  Action<double()> ret = ReturnRoundRobin(v);

  EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
  EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
  EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
  EXPECT_EQ(4.4, ret.Perform(std::make_tuple()));
  EXPECT_EQ(5.5, ret.Perform(std::make_tuple()));
  EXPECT_EQ(6.6, ret.Perform(std::make_tuple()));
}

856
857
858
859
// Tests that DoDefault() does the default action for the mock method.

class MockClass {
 public:
860
861
  MockClass() {}

862
  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
863
  MOCK_METHOD0(Foo, MyNonDefaultConstructible());
864
  MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
865
  MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
866
  MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
Gennadiy Civil's avatar
Gennadiy Civil committed
867
  MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
868
869
  MOCK_METHOD2(TakeUnique,
               int(const std::unique_ptr<int>&, std::unique_ptr<int>));
870
871
872

 private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
873
874
875
876
877
878
};

// Tests that DoDefault() returns the built-in default value for the
// return type by default.
TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
  MockClass mock;
879
  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
880
881
882
  EXPECT_EQ(0, mock.IntFunc(true));
}

883
884
// Tests that DoDefault() throws (when exceptions are enabled) or aborts
// the process when there is no built-in default value for the return type.
885
886
TEST(DoDefaultDeathTest, DiesForUnknowType) {
  MockClass mock;
887
  EXPECT_CALL(mock, Foo()).WillRepeatedly(DoDefault());
888
889
890
#if GTEST_HAS_EXCEPTIONS
  EXPECT_ANY_THROW(mock.Foo());
#else
891
  EXPECT_DEATH_IF_SUPPORTED({ mock.Foo(); }, "");
892
#endif
893
894
895
896
897
}

// Tests that using DoDefault() inside a composite action leads to a
// run-time error.

898
void VoidFunc(bool /* flag */) {}
899
900
901
902

TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
  MockClass mock;
  EXPECT_CALL(mock, IntFunc(_))
903
      .WillRepeatedly(DoAll(Invoke(VoidFunc), DoDefault()));
904
905
906
907
908

  // Ideally we should verify the error message as well.  Sadly,
  // EXPECT_DEATH() can only capture stderr, while Google Mock's
  // errors are printed on stdout.  Therefore we have to settle for
  // not verifying the message.
909
  EXPECT_DEATH_IF_SUPPORTED({ mock.IntFunc(true); }, "");
910
911
912
}

// Tests that DoDefault() returns the default value set by
John Bampton's avatar
John Bampton committed
913
// DefaultValue<T>::Set() when it's not overridden by an ON_CALL().
914
915
916
TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIsOne) {
  DefaultValue<int>::Set(1);
  MockClass mock;
917
  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
918
919
920
921
922
923
924
  EXPECT_EQ(1, mock.IntFunc(false));
  DefaultValue<int>::Clear();
}

// Tests that DoDefault() does the action specified by ON_CALL().
TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
  MockClass mock;
925
926
  ON_CALL(mock, IntFunc(_)).WillByDefault(Return(2));
  EXPECT_CALL(mock, IntFunc(_)).WillOnce(DoDefault());
927
928
929
930
931
932
  EXPECT_EQ(2, mock.IntFunc(false));
}

// Tests that using DoDefault() in ON_CALL() leads to a run-time failure.
TEST(DoDefaultTest, CannotBeUsedInOnCall) {
  MockClass mock;
933
934
935
936
937
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
        ON_CALL(mock, IntFunc(_)).WillByDefault(DoDefault());
      },
      "DoDefault() cannot be used in ON_CALL()");
938
939
}

940
941
942
943
944
945
946
947
// Tests that SetArgPointee<N>(v) sets the variable pointed to by
// the N-th (0-based) argument to v.
TEST(SetArgPointeeTest, SetsTheNthPointee) {
  typedef void MyFunction(bool, int*, char*);
  Action<MyFunction> a = SetArgPointee<1>(2);

  int n = 0;
  char ch = '\0';
Abseil Team's avatar
Abseil Team committed
948
  a.Perform(std::make_tuple(true, &n, &ch));
949
950
951
952
953
954
  EXPECT_EQ(2, n);
  EXPECT_EQ('\0', ch);

  a = SetArgPointee<2>('a');
  n = 0;
  ch = '\0';
Abseil Team's avatar
Abseil Team committed
955
  a.Perform(std::make_tuple(true, &n, &ch));
956
957
958
959
  EXPECT_EQ(0, n);
  EXPECT_EQ('a', ch);
}

960
961
// Tests that SetArgPointee<N>() accepts a string literal.
TEST(SetArgPointeeTest, AcceptsStringLiteral) {
962
963
  typedef void MyFunction(std::string*, const char**);
  Action<MyFunction> a = SetArgPointee<0>("hi");
964
  std::string str;
965
  const char* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
966
  a.Perform(std::make_tuple(&str, &ptr));
967
  EXPECT_EQ("hi", str);
968
  EXPECT_TRUE(ptr == nullptr);
969

970
  a = SetArgPointee<1>("world");
971
  str = "";
Abseil Team's avatar
Abseil Team committed
972
  a.Perform(std::make_tuple(&str, &ptr));
973
974
975
976
  EXPECT_EQ("", str);
  EXPECT_STREQ("world", ptr);
}

977
978
979
TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
  typedef void MyFunction(const wchar_t**);
  Action<MyFunction> a = SetArgPointee<0>(L"world");
980
  const wchar_t* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
981
  a.Perform(std::make_tuple(&ptr));
982
983
  EXPECT_STREQ(L"world", ptr);

984
#if GTEST_HAS_STD_WSTRING
985
986
987
988

  typedef void MyStringFunction(std::wstring*);
  Action<MyStringFunction> a2 = SetArgPointee<0>(L"world");
  std::wstring str = L"";
Abseil Team's avatar
Abseil Team committed
989
  a2.Perform(std::make_tuple(&str));
990
991
  EXPECT_EQ(L"world", str);

992
#endif
993
994
}

995
996
997
998
999
1000
// Tests that SetArgPointee<N>() accepts a char pointer.
TEST(SetArgPointeeTest, AcceptsCharPointer) {
  typedef void MyFunction(bool, std::string*, const char**);
  const char* const hi = "hi";
  Action<MyFunction> a = SetArgPointee<1>(hi);
  std::string str;
1001
  const char* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
1002
  a.Perform(std::make_tuple(true, &str, &ptr));
1003
  EXPECT_EQ("hi", str);
1004
  EXPECT_TRUE(ptr == nullptr);
1005
1006
1007
1008
1009

  char world_array[] = "world";
  char* const world = world_array;
  a = SetArgPointee<2>(world);
  str = "";
Abseil Team's avatar
Abseil Team committed
1010
  a.Perform(std::make_tuple(true, &str, &ptr));
1011
1012
1013
1014
  EXPECT_EQ("", str);
  EXPECT_EQ(world, ptr);
}

1015
1016
1017
1018
TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
  typedef void MyFunction(bool, const wchar_t**);
  const wchar_t* const hi = L"hi";
  Action<MyFunction> a = SetArgPointee<1>(hi);
1019
  const wchar_t* ptr = nullptr;
Abseil Team's avatar
Abseil Team committed
1020
  a.Perform(std::make_tuple(true, &ptr));
1021
1022
  EXPECT_EQ(hi, ptr);

1023
#if GTEST_HAS_STD_WSTRING
1024
1025
1026
1027
1028
1029

  typedef void MyStringFunction(bool, std::wstring*);
  wchar_t world_array[] = L"world";
  wchar_t* const world = world_array;
  Action<MyStringFunction> a2 = SetArgPointee<1>(world);
  std::wstring str;
Abseil Team's avatar
Abseil Team committed
1030
  a2.Perform(std::make_tuple(true, &str));
1031
  EXPECT_EQ(world_array, str);
1032
#endif
1033
1034
}

1035
1036
1037
1038
1039
1040
1041
1042
// Tests that SetArgumentPointee<N>(v) sets the variable pointed to by
// the N-th (0-based) argument to v.
TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
  typedef void MyFunction(bool, int*, char*);
  Action<MyFunction> a = SetArgumentPointee<1>(2);

  int n = 0;
  char ch = '\0';
Abseil Team's avatar
Abseil Team committed
1043
  a.Perform(std::make_tuple(true, &n, &ch));
1044
1045
1046
1047
1048
1049
  EXPECT_EQ(2, n);
  EXPECT_EQ('\0', ch);

  a = SetArgumentPointee<2>('a');
  n = 0;
  ch = '\0';
Abseil Team's avatar
Abseil Team committed
1050
  a.Perform(std::make_tuple(true, &n, &ch));
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
  EXPECT_EQ(0, n);
  EXPECT_EQ('a', ch);
}

// Sample functions and functors for testing Invoke() and etc.
int Nullary() { return 1; }

class NullaryFunctor {
 public:
  int operator()() { return 2; }
};

bool g_done = false;
void VoidNullary() { g_done = true; }

class VoidNullaryFunctor {
 public:
  void operator()() { g_done = true; }
};

Abseil Team's avatar
Abseil Team committed
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
short Short(short n) { return n; }  // NOLINT
char Char(char ch) { return ch; }

const char* CharPtr(const char* s) { return s; }

bool Unary(int x) { return x < 0; }

const char* Binary(const char* input, short n) { return input + n; }  // NOLINT

void VoidBinary(int, char) { g_done = true; }

int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT

int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }

1086
1087
1088
1089
1090
class Foo {
 public:
  Foo() : value_(123) {}

  int Nullary() const { return value_; }
1091

1092
1093
1094
1095
1096
1097
1098
1099
 private:
  int value_;
};

// Tests InvokeWithoutArgs(function).
TEST(InvokeWithoutArgsTest, Function) {
  // As an action that takes one argument.
  Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
Abseil Team's avatar
Abseil Team committed
1100
  EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
1101
1102

  // As an action that takes two arguments.
1103
  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
Abseil Team's avatar
Abseil Team committed
1104
  EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
1105
1106
1107
1108

  // As an action that returns void.
  Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
  g_done = false;
Abseil Team's avatar
Abseil Team committed
1109
  a3.Perform(std::make_tuple(1));
1110
1111
1112
1113
1114
1115
1116
  EXPECT_TRUE(g_done);
}

// Tests InvokeWithoutArgs(functor).
TEST(InvokeWithoutArgsTest, Functor) {
  // As an action that takes no argument.
  Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
Abseil Team's avatar
Abseil Team committed
1117
  EXPECT_EQ(2, a.Perform(std::make_tuple()));
1118
1119

  // As an action that takes three arguments.
1120
  Action<int(int, double, char)> a2 =  // NOLINT
1121
      InvokeWithoutArgs(NullaryFunctor());
Abseil Team's avatar
Abseil Team committed
1122
  EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5, 'a')));
1123
1124
1125
1126

  // As an action that returns void.
  Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
  g_done = false;
Abseil Team's avatar
Abseil Team committed
1127
  a3.Perform(std::make_tuple());
1128
1129
1130
1131
1132
1133
1134
1135
  EXPECT_TRUE(g_done);
}

// Tests InvokeWithoutArgs(obj_ptr, method).
TEST(InvokeWithoutArgsTest, Method) {
  Foo foo;
  Action<int(bool, char)> a =  // NOLINT
      InvokeWithoutArgs(&foo, &Foo::Nullary);
Abseil Team's avatar
Abseil Team committed
1136
  EXPECT_EQ(123, a.Perform(std::make_tuple(true, 'a')));
1137
1138
1139
1140
1141
}

// Tests using IgnoreResult() on a polymorphic action.
TEST(IgnoreResultTest, PolymorphicAction) {
  Action<void(int)> a = IgnoreResult(Return(5));  // NOLINT
Abseil Team's avatar
Abseil Team committed
1142
  a.Perform(std::make_tuple(1));
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
}

// Tests using IgnoreResult() on a monomorphic action.

int ReturnOne() {
  g_done = true;
  return 1;
}

TEST(IgnoreResultTest, MonomorphicAction) {
  g_done = false;
  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
Abseil Team's avatar
Abseil Team committed
1155
  a.Perform(std::make_tuple());
1156
1157
1158
1159
1160
  EXPECT_TRUE(g_done);
}

// Tests using IgnoreResult() on an action that returns a class type.

1161
MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
1162
  g_done = true;
1163
  return MyNonDefaultConstructible(42);
1164
1165
1166
1167
}

TEST(IgnoreResultTest, ActionReturningClass) {
  g_done = false;
1168
1169
  Action<void(int)> a =
      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
Abseil Team's avatar
Abseil Team committed
1170
  a.Perform(std::make_tuple(2));
1171
1172
1173
1174
1175
1176
  EXPECT_TRUE(g_done);
}

TEST(AssignTest, Int) {
  int x = 0;
  Action<void(int)> a = Assign(&x, 5);
Abseil Team's avatar
Abseil Team committed
1177
  a.Perform(std::make_tuple(0));
1178
1179
1180
1181
1182
1183
  EXPECT_EQ(5, x);
}

TEST(AssignTest, String) {
  ::std::string x;
  Action<void(void)> a = Assign(&x, "Hello, world");
Abseil Team's avatar
Abseil Team committed
1184
  a.Perform(std::make_tuple());
1185
1186
1187
1188
1189
1190
  EXPECT_EQ("Hello, world", x);
}

TEST(AssignTest, CompatibleTypes) {
  double x = 0;
  Action<void(int)> a = Assign(&x, 5);
Abseil Team's avatar
Abseil Team committed
1191
  a.Perform(std::make_tuple(0));
1192
1193
1194
  EXPECT_DOUBLE_EQ(5, x);
}

Abseil Team's avatar
Abseil Team committed
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
// Tests using WithArgs and with an action that takes 1 argument.
TEST(WithArgsTest, OneArg) {
  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
  EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
}

// Tests using WithArgs with an action that takes 2 arguments.
TEST(WithArgsTest, TwoArgs) {
  Action<const char*(const char* s, double x, short n)> a =  // NOLINT
      WithArgs<0, 2>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
}

struct ConcatAll {
  std::string operator()() const { return {}; }
  template <typename... I>
  std::string operator()(const char* a, I... i) const {
    return a + ConcatAll()(i...);
  }
};

// Tests using WithArgs with an action that takes 10 arguments.
TEST(WithArgsTest, TenArgs) {
  Action<std::string(const char*, const char*, const char*, const char*)> a =
      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(ConcatAll{}));
  EXPECT_EQ("0123210123",
            a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                      CharPtr("3"))));
}

// Tests using WithArgs with an action that is not Invoke().
class SubtractAction : public ActionInterface<int(int, int)> {
 public:
Abseil Team's avatar
Abseil Team committed
1230
  int Perform(const std::tuple<int, int>& args) override {
Abseil Team's avatar
Abseil Team committed
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
    return std::get<0>(args) - std::get<1>(args);
  }
};

TEST(WithArgsTest, NonInvokeAction) {
  Action<int(const std::string&, int, int)> a =
      WithArgs<2, 1>(MakeAction(new SubtractAction));
  std::tuple<std::string, int, int> dummy =
      std::make_tuple(std::string("hi"), 2, 10);
  EXPECT_EQ(8, a.Perform(dummy));
}

// Tests using WithArgs to pass all original arguments in the original order.
TEST(WithArgsTest, Identity) {
  Action<int(int x, char y, short z)> a =  // NOLINT
      WithArgs<0, 1, 2>(Invoke(Ternary));
  EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
}

// Tests using WithArgs with repeated arguments.
TEST(WithArgsTest, RepeatedArguments) {
  Action<int(bool, int m, int n)> a =  // NOLINT
      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
  EXPECT_EQ(4, a.Perform(std::make_tuple(false, 1, 10)));
}

// Tests using WithArgs with reversed argument order.
TEST(WithArgsTest, ReversedArgumentOrder) {
  Action<const char*(short n, const char* input)> a =  // NOLINT
      WithArgs<1, 0>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
}

// Tests using WithArgs with compatible, but not identical, argument types.
TEST(WithArgsTest, ArgsOfCompatibleTypes) {
  Action<long(short x, char y, double z, char c)> a =  // NOLINT
      WithArgs<0, 1, 3>(Invoke(Ternary));
  EXPECT_EQ(123,
            a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
}

// Tests using WithArgs with an action that returns void.
TEST(WithArgsTest, VoidAction) {
  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
  g_done = false;
  a.Perform(std::make_tuple(1.5, 'a', 3));
  EXPECT_TRUE(g_done);
}

TEST(WithArgsTest, ReturnReference) {
misterg's avatar
misterg committed
1282
  Action<int&(int&, void*)> aa = WithArgs<0>([](int& a) -> int& { return a; });
Abseil Team's avatar
Abseil Team committed
1283
  int i = 0;
misterg's avatar
misterg committed
1284
  const int& res = aa.Perform(std::forward_as_tuple(i, nullptr));
Abseil Team's avatar
Abseil Team committed
1285
1286
1287
1288
1289
1290
1291
1292
1293
  EXPECT_EQ(&i, &res);
}

TEST(WithArgsTest, InnerActionWithConversion) {
  Action<Derived*()> inner = [] { return nullptr; };
  Action<Base*(double)> a = testing::WithoutArgs(inner);
  EXPECT_EQ(nullptr, a.Perform(std::make_tuple(1.1)));
}

1294
#if !GTEST_OS_WINDOWS_MOBILE
1295

1296
1297
class SetErrnoAndReturnTest : public testing::Test {
 protected:
Abseil Team's avatar
Abseil Team committed
1298
1299
  void SetUp() override { errno = 0; }
  void TearDown() override { errno = 0; }
1300
1301
1302
1303
};

TEST_F(SetErrnoAndReturnTest, Int) {
  Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
Abseil Team's avatar
Abseil Team committed
1304
  EXPECT_EQ(-5, a.Perform(std::make_tuple()));
1305
1306
1307
1308
1309
1310
  EXPECT_EQ(ENOTTY, errno);
}

TEST_F(SetErrnoAndReturnTest, Ptr) {
  int x;
  Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
Abseil Team's avatar
Abseil Team committed
1311
  EXPECT_EQ(&x, a.Perform(std::make_tuple()));
1312
1313
1314
1315
1316
  EXPECT_EQ(ENOTTY, errno);
}

TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
  Action<double()> a = SetErrnoAndReturn(EINVAL, 5);
Abseil Team's avatar
Abseil Team committed
1317
  EXPECT_DOUBLE_EQ(5.0, a.Perform(std::make_tuple()));
1318
1319
1320
  EXPECT_EQ(EINVAL, errno);
}

1321
#endif  // !GTEST_OS_WINDOWS_MOBILE
1322

1323
1324
// Tests ByRef().

Abseil Team's avatar
Abseil Team committed
1325
// Tests that the result of ByRef() is copyable.
1326
1327
1328
1329
TEST(ByRefTest, IsCopyable) {
  const std::string s1 = "Hi";
  const std::string s2 = "Hello";

Abseil Team's avatar
Abseil Team committed
1330
  auto ref_wrapper = ByRef(s1);
1331
1332
1333
1334
1335
1336
1337
1338
  const std::string& r1 = ref_wrapper;
  EXPECT_EQ(&s1, &r1);

  // Assigns a new value to ref_wrapper.
  ref_wrapper = ByRef(s2);
  const std::string& r2 = ref_wrapper;
  EXPECT_EQ(&s2, &r2);

Abseil Team's avatar
Abseil Team committed
1339
  auto ref_wrapper1 = ByRef(s1);
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
  // Copies ref_wrapper1 to ref_wrapper.
  ref_wrapper = ref_wrapper1;
  const std::string& r3 = ref_wrapper;
  EXPECT_EQ(&s1, &r3);
}

// Tests using ByRef() on a const value.
TEST(ByRefTest, ConstValue) {
  const int n = 0;
  // int& ref = ByRef(n);  // This shouldn't compile - we have a
1350
  // negative compilation test to catch it.
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
  const int& const_ref = ByRef(n);
  EXPECT_EQ(&n, &const_ref);
}

// Tests using ByRef() on a non-const value.
TEST(ByRefTest, NonConstValue) {
  int n = 0;

  // ByRef(n) can be used as either an int&,
  int& ref = ByRef(n);
  EXPECT_EQ(&n, &ref);

  // or a const int&.
  const int& const_ref = ByRef(n);
  EXPECT_EQ(&n, &const_ref);
}

// Tests explicitly specifying the type when using ByRef().
TEST(ByRefTest, ExplicitType) {
  int n = 0;
  const int& r1 = ByRef<const int>(n);
  EXPECT_EQ(&n, &r1);

  // ByRef<char>(n);  // This shouldn't compile - we have a negative
1375
  // compilation test to catch it.
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405

  Derived d;
  Derived& r2 = ByRef<Derived>(d);
  EXPECT_EQ(&d, &r2);

  const Derived& r3 = ByRef<const Derived>(d);
  EXPECT_EQ(&d, &r3);

  Base& r4 = ByRef<Base>(d);
  EXPECT_EQ(&d, &r4);

  const Base& r5 = ByRef<const Base>(d);
  EXPECT_EQ(&d, &r5);

  // The following shouldn't compile - we have a negative compilation
  // test for it.
  //
  // Base b;
  // ByRef<Derived>(b);
}

// Tests that Google Mock prints expression ByRef(x) as a reference to x.
TEST(ByRefTest, PrintsCorrectly) {
  int n = 42;
  ::std::stringstream expected, actual;
  testing::internal::UniversalPrinter<const int&>::Print(n, &expected);
  testing::internal::UniversalPrint(ByRef(n), &actual);
  EXPECT_EQ(expected.str(), actual.str());
}

Abseil Team's avatar
Abseil Team committed
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
struct UnaryConstructorClass {
  explicit UnaryConstructorClass(int v) : value(v) {}
  int value;
};

// Tests using ReturnNew() with a unary constructor.
TEST(ReturnNewTest, Unary) {
  Action<UnaryConstructorClass*()> a = ReturnNew<UnaryConstructorClass>(4000);
  UnaryConstructorClass* c = a.Perform(std::make_tuple());
  EXPECT_EQ(4000, c->value);
  delete c;
}

TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
  Action<UnaryConstructorClass*(bool, int)> a =
      ReturnNew<UnaryConstructorClass>(4000);
  UnaryConstructorClass* c = a.Perform(std::make_tuple(false, 5));
  EXPECT_EQ(4000, c->value);
  delete c;
}

TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
  Action<const UnaryConstructorClass*()> a =
      ReturnNew<UnaryConstructorClass>(4000);
  const UnaryConstructorClass* c = a.Perform(std::make_tuple());
  EXPECT_EQ(4000, c->value);
  delete c;
}

class TenArgConstructorClass {
 public:
  TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5, int a6, int a7,
                         int a8, int a9, int a10)
      : value_(a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10) {}
  int value_;
};

// Tests using ReturnNew() with a 10-argument constructor.
TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
  Action<TenArgConstructorClass*()> a = ReturnNew<TenArgConstructorClass>(
      1000000000, 200000000, 30000000, 4000000, 500000, 60000, 7000, 800, 90,
      0);
  TenArgConstructorClass* c = a.Perform(std::make_tuple());
  EXPECT_EQ(1234567890, c->value_);
  delete c;
}
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462

std::unique_ptr<int> UniquePtrSource() {
  return std::unique_ptr<int>(new int(19));
}

std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
  std::vector<std::unique_ptr<int>> out;
  out.emplace_back(new int(7));
  return out;
}

1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
  MockClass mock;
  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
  Derived* d = new Derived;
  EXPECT_CALL(mock, MakeUniqueBase())
      .WillOnce(Return(ByMove(std::unique_ptr<Derived>(d))));

  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);

  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1477
  EXPECT_EQ(1u, vresult.size());
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
  EXPECT_NE(nullptr, vresult[0]);
  EXPECT_EQ(7, *vresult[0]);

  std::unique_ptr<Base> result2 = mock.MakeUniqueBase();
  EXPECT_EQ(d, result2.get());
}

TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
  testing::MockFunction<void()> mock_function;
  MockClass mock;
  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock_function, Call());
1490
1491
1492
1493
  EXPECT_CALL(mock, MakeUnique())
      .WillOnce(DoAll(InvokeWithoutArgs(&mock_function,
                                        &testing::MockFunction<void()>::Call),
                      Return(ByMove(std::move(i)))));
1494
1495
1496
1497
1498
1499

  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
}

TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
1500
1501
1502
  MockClass mock;

  // Check default value
1503
1504
  DefaultValue<std::unique_ptr<int>>::SetFactory(
      [] { return std::unique_ptr<int>(new int(42)); });
1505
1506
  EXPECT_EQ(42, *mock.MakeUnique());

1507
  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
1508
1509
1510
1511
1512
1513
1514
1515
1516
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillRepeatedly(Invoke(VectorUniquePtrSource));
  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
  std::unique_ptr<int> result2 = mock.MakeUnique();
  EXPECT_EQ(19, *result2);
  EXPECT_NE(result1, result2);

  std::vector<std::unique_ptr<int>> vresult = mock.MakeVectorUnique();
1517
  EXPECT_EQ(1u, vresult.size());
1518
1519
1520
1521
  EXPECT_NE(nullptr, vresult[0]);
  EXPECT_EQ(7, *vresult[0]);
}

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
TEST(MockMethodTest, CanTakeMoveOnlyValue) {
  MockClass mock;
  auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };

  EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
    return *i;
  });
  // DoAll() does not compile, since it would move from its arguments twice.
  // EXPECT_CALL(mock, TakeUnique(_, _))
  //     .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
  //     Return(1)));
  EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
      .WillOnce(Return(-7))
      .RetiresOnSaturation();
  EXPECT_CALL(mock, TakeUnique(testing::IsNull()))
      .WillOnce(Return(-1))
      .RetiresOnSaturation();

  EXPECT_EQ(5, mock.TakeUnique(make(5)));
  EXPECT_EQ(-7, mock.TakeUnique(make(7)));
  EXPECT_EQ(7, mock.TakeUnique(make(7)));
  EXPECT_EQ(7, mock.TakeUnique(make(7)));
  EXPECT_EQ(-1, mock.TakeUnique({}));

  // Some arguments are moved, some passed by reference.
  auto lvalue = make(6);
  EXPECT_CALL(mock, TakeUnique(_, _))
      .WillOnce([](const std::unique_ptr<int>& i, std::unique_ptr<int> j) {
        return *i * *j;
      });
  EXPECT_EQ(42, mock.TakeUnique(lvalue, make(7)));

  // The unique_ptr can be saved by the action.
  std::unique_ptr<int> saved;
  EXPECT_CALL(mock, TakeUnique(_)).WillOnce([&saved](std::unique_ptr<int> i) {
    saved = std::move(i);
    return 0;
  });
  EXPECT_EQ(0, mock.TakeUnique(make(42)));
  EXPECT_EQ(42, *saved);
}

1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
// It should be possible to use callables with an &&-qualified call operator
// with WillOnce, since they will be called only once. This allows actions to
// contain and manipulate move-only types.
TEST(MockMethodTest, ActionHasRvalueRefQualifiedCallOperator) {
  struct Return17 {
    int operator()() && { return 17; }
  };

  // Action is directly compatible with mocked function type.
  {
    MockFunction<int()> mock;
    EXPECT_CALL(mock, Call).WillOnce(Return17());

    EXPECT_EQ(17, mock.AsStdFunction()());
  }

  // Action doesn't want mocked function arguments.
  {
    MockFunction<int(int)> mock;
    EXPECT_CALL(mock, Call).WillOnce(Return17());

    EXPECT_EQ(17, mock.AsStdFunction()(0));
  }
}

// Edge case: if an action has both a const-qualified and an &&-qualified call
// operator, there should be no "ambiguous call" errors. The &&-qualified
// operator should be used by WillOnce (since it doesn't need to retain the
// action beyond one call), and the const-qualified one by WillRepeatedly.
TEST(MockMethodTest, ActionHasMultipleCallOperators) {
  struct ReturnInt {
    int operator()() && { return 17; }
    int operator()() const& { return 19; }
  };

  // Directly compatible with mocked function type.
  {
    MockFunction<int()> mock;
    EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());

    EXPECT_EQ(17, mock.AsStdFunction()());
    EXPECT_EQ(19, mock.AsStdFunction()());
    EXPECT_EQ(19, mock.AsStdFunction()());
  }

  // Ignores function arguments.
  {
    MockFunction<int(int)> mock;
    EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());

    EXPECT_EQ(17, mock.AsStdFunction()(0));
    EXPECT_EQ(19, mock.AsStdFunction()(0));
    EXPECT_EQ(19, mock.AsStdFunction()(0));
  }
}

// WillOnce should have no problem coping with a move-only action, whether it is
// &&-qualified or not.
TEST(MockMethodTest, MoveOnlyAction) {
  // &&-qualified
  {
    struct Return17 {
      Return17() = default;
      Return17(Return17&&) = default;

      Return17(const Return17&) = delete;
      Return17 operator=(const Return17&) = delete;

      int operator()() && { return 17; }
    };

    MockFunction<int()> mock;
    EXPECT_CALL(mock, Call).WillOnce(Return17());
    EXPECT_EQ(17, mock.AsStdFunction()());
  }

  // Not &&-qualified
  {
    struct Return17 {
      Return17() = default;
      Return17(Return17&&) = default;

      Return17(const Return17&) = delete;
      Return17 operator=(const Return17&) = delete;

      int operator()() const { return 17; }
    };

    MockFunction<int()> mock;
    EXPECT_CALL(mock, Call).WillOnce(Return17());
    EXPECT_EQ(17, mock.AsStdFunction()());
  }
}

// It should be possible to use an action that returns a value with a mock
// function that doesn't, both through WillOnce and WillRepeatedly.
TEST(MockMethodTest, ActionReturnsIgnoredValue) {
  struct ReturnInt {
    int operator()() const { return 0; }
  };

  MockFunction<void()> mock;
  EXPECT_CALL(mock, Call).WillOnce(ReturnInt()).WillRepeatedly(ReturnInt());

  mock.AsStdFunction()();
  mock.AsStdFunction()();
}

// Despite the fanciness around move-only actions and so on, it should still be
// possible to hand an lvalue reference to a copyable action to WillOnce.
TEST(MockMethodTest, WillOnceCanAcceptLvalueReference) {
  MockFunction<int()> mock;

  const auto action = [] { return 17; };
  EXPECT_CALL(mock, Call).WillOnce(action);

  EXPECT_EQ(17, mock.AsStdFunction()());
}

// A callable that doesn't use SFINAE to restrict its call operator's overload
// set, but is still picky about which arguments it will accept.
struct StaticAssertSingleArgument {
  template <typename... Args>
  static constexpr bool CheckArgs() {
    static_assert(sizeof...(Args) == 1, "");
    return true;
  }

  template <typename... Args, bool = CheckArgs<Args...>()>
  int operator()(Args...) const {
    return 17;
  }
};

// WillOnce and WillRepeatedly should both work fine with naïve implementations
// of actions that don't use SFINAE to limit the overload set for their call
// operator. If they are compatible with the actual mocked signature, we
// shouldn't probe them with no arguments and trip a static_assert.
TEST(MockMethodTest, ActionSwallowsAllArguments) {
  MockFunction<int(int)> mock;
  EXPECT_CALL(mock, Call)
      .WillOnce(StaticAssertSingleArgument{})
      .WillRepeatedly(StaticAssertSingleArgument{});

  EXPECT_EQ(17, mock.AsStdFunction()(0));
  EXPECT_EQ(17, mock.AsStdFunction()(0));
}

Gennadiy Civil's avatar
 
Gennadiy Civil committed
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
// Tests for std::function based action.

int Add(int val, int& ref, int* ptr) {  // NOLINT
  int result = val + ref + *ptr;
  ref = 42;
  *ptr = 43;
  return result;
}

int Deref(std::unique_ptr<int> ptr) { return *ptr; }

struct Double {
  template <typename T>
1725
1726
1727
  T operator()(T t) {
    return 2 * t;
  }
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
};

std::unique_ptr<int> UniqueInt(int i) {
  return std::unique_ptr<int>(new int(i));
}

TEST(FunctorActionTest, ActionFromFunction) {
  Action<int(int, int&, int*)> a = &Add;
  int x = 1, y = 2, z = 3;
  EXPECT_EQ(6, a.Perform(std::forward_as_tuple(x, y, &z)));
  EXPECT_EQ(42, y);
  EXPECT_EQ(43, z);

  Action<int(std::unique_ptr<int>)> a1 = &Deref;
  EXPECT_EQ(7, a1.Perform(std::make_tuple(UniqueInt(7))));
}

TEST(FunctorActionTest, ActionFromLambda) {
  Action<int(bool, int)> a1 = [](bool b, int i) { return b ? i : 0; };
Abseil Team's avatar
Abseil Team committed
1747
1748
  EXPECT_EQ(5, a1.Perform(std::make_tuple(true, 5)));
  EXPECT_EQ(0, a1.Perform(std::make_tuple(false, 5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1749
1750
1751
1752
1753

  std::unique_ptr<int> saved;
  Action<void(std::unique_ptr<int>)> a2 = [&saved](std::unique_ptr<int> p) {
    saved = std::move(p);
  };
Abseil Team's avatar
Abseil Team committed
1754
  a2.Perform(std::make_tuple(UniqueInt(5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1755
1756
1757
1758
1759
  EXPECT_EQ(5, *saved);
}

TEST(FunctorActionTest, PolymorphicFunctor) {
  Action<int(int)> ai = Double();
Abseil Team's avatar
Abseil Team committed
1760
  EXPECT_EQ(2, ai.Perform(std::make_tuple(1)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1761
  Action<double(double)> ad = Double();  // Double? Double double!
Abseil Team's avatar
Abseil Team committed
1762
  EXPECT_EQ(3.0, ad.Perform(std::make_tuple(1.5)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1763
1764
1765
1766
1767
1768
}

TEST(FunctorActionTest, TypeConversion) {
  // Numeric promotions are allowed.
  const Action<bool(int)> a1 = [](int i) { return i > 1; };
  const Action<int(bool)> a2 = Action<int(bool)>(a1);
Abseil Team's avatar
Abseil Team committed
1769
1770
  EXPECT_EQ(1, a1.Perform(std::make_tuple(42)));
  EXPECT_EQ(0, a2.Perform(std::make_tuple(42)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1771
1772
1773
1774

  // Implicit constructors are allowed.
  const Action<bool(std::string)> s1 = [](std::string s) { return !s.empty(); };
  const Action<int(const char*)> s2 = Action<int(const char*)>(s1);
Abseil Team's avatar
Abseil Team committed
1775
1776
  EXPECT_EQ(0, s2.Perform(std::make_tuple("")));
  EXPECT_EQ(1, s2.Perform(std::make_tuple("hello")));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1777
1778

  // Also between the lambda and the action itself.
Abseil Team's avatar
Abseil Team committed
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
  const Action<bool(std::string)> x1 = [](Unused) { return 42; };
  const Action<bool(std::string)> x2 = [] { return 42; };
  EXPECT_TRUE(x1.Perform(std::make_tuple("hello")));
  EXPECT_TRUE(x2.Perform(std::make_tuple("hello")));

  // Ensure decay occurs where required.
  std::function<int()> f = [] { return 7; };
  Action<int(int)> d = f;
  f = nullptr;
  EXPECT_EQ(7, d.Perform(std::make_tuple(1)));

  // Ensure creation of an empty action succeeds.
  Action<void(int)>(nullptr);
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1792
1793
1794
1795
}

TEST(FunctorActionTest, UnusedArguments) {
  // Verify that users can ignore uninteresting arguments.
1796
1797
1798
  Action<int(int, double y, double z)> a = [](int i, Unused, Unused) {
    return 2 * i;
  };
Abseil Team's avatar
Abseil Team committed
1799
  std::tuple<int, double, double> dummy = std::make_tuple(3, 7.3, 9.44);
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1800
  EXPECT_EQ(6, a.Perform(dummy));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1801
1802
1803
1804
1805
}

// Test that basic built-in actions work with move-only arguments.
TEST(MoveOnlyArgumentsTest, ReturningActions) {
  Action<int(std::unique_ptr<int>)> a = Return(1);
Abseil Team's avatar
Abseil Team committed
1806
  EXPECT_EQ(1, a.Perform(std::make_tuple(nullptr)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1807
1808

  a = testing::WithoutArgs([]() { return 7; });
Abseil Team's avatar
Abseil Team committed
1809
  EXPECT_EQ(7, a.Perform(std::make_tuple(nullptr)));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1810
1811
1812

  Action<void(std::unique_ptr<int>, int*)> a2 = testing::SetArgPointee<1>(3);
  int x = 0;
Abseil Team's avatar
Abseil Team committed
1813
  a2.Perform(std::make_tuple(nullptr, &x));
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1814
1815
1816
  EXPECT_EQ(x, 3);
}

1817
ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
Abseil Team's avatar
Abseil Team committed
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834

TEST(ActionMacro, LargeArity) {
  EXPECT_EQ(
      1, testing::Action<int(int)>(ReturnArity()).Perform(std::make_tuple(0)));
  EXPECT_EQ(
      10,
      testing::Action<int(int, int, int, int, int, int, int, int, int, int)>(
          ReturnArity())
          .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)));
  EXPECT_EQ(
      20,
      testing::Action<int(int, int, int, int, int, int, int, int, int, int, int,
                          int, int, int, int, int, int, int, int, int)>(
          ReturnArity())
          .Perform(std::make_tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                                   14, 15, 16, 17, 18, 19)));
}
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1835

1836
1837
}  // namespace
}  // namespace testing
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1838
1839
1840

#ifdef _MSC_VER
#if _MSC_VER == 1900
1841
#pragma warning(pop)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
1842
1843
#endif
#endif