gmock-actions.h 56.3 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

// Google Mock - a framework for writing C++ mock classes.
//
Abseil Team's avatar
Abseil Team committed
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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
// The ACTION* family of macros can be used in a namespace scope to
// define custom actions easily.  The syntax:
//
//   ACTION(name) { statements; }
//
// will define an action with the given name that executes the
// statements.  The value returned by the statements will be used as
// the return value of the action.  Inside the statements, you can
// refer to the K-th (0-based) argument of the mock function by
// 'argK', and refer to its type by 'argK_type'.  For example:
//
//   ACTION(IncrementArg1) {
//     arg1_type temp = arg1;
//     return ++(*temp);
//   }
//
// allows you to write
//
//   ...WillOnce(IncrementArg1());
//
// You can also refer to the entire argument tuple and its type by
// 'args' and 'args_type', and refer to the mock function type and its
// return type by 'function_type' and 'return_type'.
//
// Note that you don't need to specify the types of the mock function
// arguments.  However rest assured that your code is still type-safe:
// you'll get a compiler error if *arg1 doesn't support the ++
// operator, or if the type of ++(*arg1) isn't compatible with the
// mock function's return type, for example.
//
// Sometimes you'll want to parameterize the action.   For that you can use
// another macro:
//
//   ACTION_P(name, param_name) { statements; }
//
// For example:
//
//   ACTION_P(Add, n) { return arg0 + n; }
//
// will allow you to write:
//
//   ...WillOnce(Add(5));
//
// Note that you don't need to provide the type of the parameter
// either.  If you need to reference the type of a parameter named
// 'foo', you can write 'foo_type'.  For example, in the body of
// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
// of 'n'.
//
// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
// multi-parameter actions.
//
// For the purpose of typing, you can view
//
//   ACTION_Pk(Foo, p1, ..., pk) { ... }
//
// as shorthand for
//
//   template <typename p1_type, ..., typename pk_type>
//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
//
// In particular, you can provide the template type arguments
// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
// although usually you can rely on the compiler to infer the types
// for you automatically.  You can assign the result of expression
// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
// pk_type>.  This can be useful when composing actions.
//
// You can also overload actions with different numbers of parameters:
//
//   ACTION_P(Plus, a) { ... }
//   ACTION_P2(Plus, a, b) { ... }
//
// While it's tempting to always use the ACTION* macros when defining
// a new action, you should also consider implementing ActionInterface
// or using MakePolymorphicAction() instead, especially if you need to
// use the action a lot.  While these approaches require more work,
// they give you more control on the types of the mock function
// arguments and the action parameters, which in general leads to
// better compiler error messages that pay off in the long run.  They
// also allow overloading actions based on parameter types (as opposed
// to just based on the number of parameters).
//
// CAVEAT:
//
// ACTION*() can only be used in a namespace scope as templates cannot be
// declared inside of a local class.
// Users can, however, define any local functors (e.g. a lambda) that
// can be used as actions.
//
// MORE INFORMATION:
//
// To learn more about using these macros, please search for 'ACTION' on
// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md
127

Gennadiy Civil's avatar
 
Gennadiy Civil committed
128
129
// GOOGLETEST_CM0002 DO NOT DELETE

130
131
132
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_

133
#ifndef _WIN32_WCE
134
# include <errno.h>
135
136
#endif

137
#include <algorithm>
Abseil Team's avatar
Abseil Team committed
138
#include <functional>
misterg's avatar
misterg committed
139
#include <memory>
140
#include <string>
Abseil Team's avatar
Abseil Team committed
141
#include <type_traits>
Abseil Team's avatar
Abseil Team committed
142
#include <utility>
143

144
145
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
Abseil Team's avatar
Abseil Team committed
146
#include "gmock/internal/gmock-pp.h"
147

misterg's avatar
misterg committed
148
149
150
151
152
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif

153
154
155
156
157
158
159
160
161
162
163
164
165
namespace testing {

// To implement an action Foo, define:
//   1. a class FooAction that implements the ActionInterface interface, and
//   2. a factory function that creates an Action object from a
//      const FooAction*.
//
// The two-level delegation design follows that of Matcher, providing
// consistency for extension developers.  It also eases ownership
// management as Action objects can now be copied like plain values.

namespace internal {

166
167
168
169
170
171
172
173
174
// BuiltInDefaultValueGetter<T, true>::Get() returns a
// default-constructed T value.  BuiltInDefaultValueGetter<T,
// false>::Get() crashes with an error.
//
// This primary template is used when kDefaultConstructible is true.
template <typename T, bool kDefaultConstructible>
struct BuiltInDefaultValueGetter {
  static T Get() { return T(); }
};
175
template <typename T>
176
struct BuiltInDefaultValueGetter<T, false> {
177
178
179
180
181
182
183
184
185
  static T Get() {
    Assert(false, __FILE__, __LINE__,
           "Default action undefined for the function return type.");
    return internal::Invalid<T>();
    // The above statement will never be reached, but is required in
    // order for this function to compile.
  }
};

186
187
188
189
190
191
192
193
194
195
// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
// for type T, which is NULL when T is a raw pointer type, 0 when T is
// a numeric type, false when T is bool, or "" when T is string or
// std::string.  In addition, in C++11 and above, it turns a
// default-constructed T value if T is default constructible.  For any
// other type T, the built-in default T value is undefined, and the
// function will abort the process.
template <typename T>
class BuiltInDefaultValue {
 public:
196
197
  // This function returns true if and only if type T has a built-in default
  // value.
198
199
200
201
202
203
204
205
206
207
  static bool Exists() {
    return ::std::is_default_constructible<T>::value;
  }

  static T Get() {
    return BuiltInDefaultValueGetter<
        T, ::std::is_default_constructible<T>::value>::Get();
  }
};

208
209
210
211
212
// This partial specialization says that we use the same built-in
// default value for T and const T.
template <typename T>
class BuiltInDefaultValue<const T> {
 public:
213
  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
214
215
216
217
218
219
220
221
  static T Get() { return BuiltInDefaultValue<T>::Get(); }
};

// This partial specialization defines the default values for pointer
// types.
template <typename T>
class BuiltInDefaultValue<T*> {
 public:
222
  static bool Exists() { return true; }
223
  static T* Get() { return nullptr; }
224
225
226
227
};

// The following specializations define the default values for
// specific types we care about.
228
#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
229
230
231
  template <> \
  class BuiltInDefaultValue<type> { \
   public: \
232
    static bool Exists() { return true; } \
233
234
235
    static type Get() { return value; } \
  }

236
237
238
239
240
241
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
242
243
244
245
246
247
248

// There's no need for a default action for signed wchar_t, as that
// type is the same as wchar_t for gcc, and invalid for MSVC.
//
// There's also no need for a default action for unsigned wchar_t, as
// that type is the same as unsigned int for gcc, and invalid for
// MSVC.
249
#if GMOCK_WCHAR_T_IS_NATIVE_
250
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
251
252
#endif

253
254
255
256
257
258
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
Abseil Team's avatar
Abseil Team committed
259
260
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
261
262
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
263

264
#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

}  // namespace internal

// When an unexpected function call is encountered, Google Mock will
// let it return a default value if the user has specified one for its
// return type, or if the return type has a built-in default value;
// otherwise Google Mock won't know what value to return and will have
// to abort the process.
//
// The DefaultValue<T> class allows a user to specify the
// default value for a type T that is both copyable and publicly
// destructible (i.e. anything that can be used as a function return
// type).  The usage is:
//
//   // Sets the default value for type T to be foo.
//   DefaultValue<T>::Set(foo);
template <typename T>
class DefaultValue {
 public:
  // Sets the default value for type T; requires T to be
  // copy-constructable and have a public destructor.
  static void Set(T x) {
287
288
289
290
291
292
293
294
295
296
297
    delete producer_;
    producer_ = new FixedValueProducer(x);
  }

  // Provides a factory function to be called to generate the default value.
  // This method can be used even if T is only move-constructible, but it is not
  // limited to that case.
  typedef T (*FactoryFunction)();
  static void SetFactory(FactoryFunction factory) {
    delete producer_;
    producer_ = new FactoryValueProducer(factory);
298
299
300
301
  }

  // Unsets the default value for type T.
  static void Clear() {
302
    delete producer_;
303
    producer_ = nullptr;
304
305
  }

306
  // Returns true if and only if the user has set the default value for type T.
307
  static bool IsSet() { return producer_ != nullptr; }
308

309
310
311
312
313
314
  // Returns true if T has a default return value set by the user or there
  // exists a built-in default value.
  static bool Exists() {
    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
  }

315
  // Returns the default value for type T if the user has set one;
316
317
  // otherwise returns the built-in default value. Requires that Exists()
  // is true, which ensures that the return value is well-defined.
318
  static T Get() {
319
320
    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
                                : producer_->Produce();
321
  }
322

323
 private:
324
325
326
327
328
329
330
331
332
  class ValueProducer {
   public:
    virtual ~ValueProducer() {}
    virtual T Produce() = 0;
  };

  class FixedValueProducer : public ValueProducer {
   public:
    explicit FixedValueProducer(T value) : value_(value) {}
Abseil Team's avatar
Abseil Team committed
333
    T Produce() override { return value_; }
334
335
336
337
338
339
340
341
342
343

   private:
    const T value_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
  };

  class FactoryValueProducer : public ValueProducer {
   public:
    explicit FactoryValueProducer(FactoryFunction factory)
        : factory_(factory) {}
Abseil Team's avatar
Abseil Team committed
344
    T Produce() override { return factory_(); }
345
346
347
348
349
350
351

   private:
    const FactoryFunction factory_;
    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
  };

  static ValueProducer* producer_;
352
353
354
355
356
357
358
359
360
361
362
363
364
};

// This partial specialization allows a user to set default values for
// reference types.
template <typename T>
class DefaultValue<T&> {
 public:
  // Sets the default value for type T&.
  static void Set(T& x) {  // NOLINT
    address_ = &x;
  }

  // Unsets the default value for type T&.
365
  static void Clear() { address_ = nullptr; }
366

367
  // Returns true if and only if the user has set the default value for type T&.
368
  static bool IsSet() { return address_ != nullptr; }
369

370
371
372
373
374
375
  // Returns true if T has a default return value set by the user or there
  // exists a built-in default value.
  static bool Exists() {
    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
  }

376
377
378
379
  // Returns the default value for type T& if the user has set one;
  // otherwise returns the built-in default value if there is one;
  // otherwise aborts the process.
  static T& Get() {
380
381
    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
                               : *address_;
382
  }
383

384
385
386
387
388
389
390
391
392
 private:
  static T* address_;
};

// This specialization allows DefaultValue<void>::Get() to
// compile.
template <>
class DefaultValue<void> {
 public:
393
  static bool Exists() { return true; }
394
395
396
397
398
  static void Get() {}
};

// Points to the user-set default value for type T.
template <typename T>
399
typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
400
401
402

// Points to the user-set default value for type T&.
template <typename T>
403
T* DefaultValue<T&>::address_ = nullptr;
404
405
406
407
408
409
410
411

// Implement this interface to define an action for function type F.
template <typename F>
class ActionInterface {
 public:
  typedef typename internal::Function<F>::Result Result;
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

412
  ActionInterface() {}
413
414
415
416
417
418
419
420
421
  virtual ~ActionInterface() {}

  // Performs the action.  This method is not const, as in general an
  // action can have side effects and be stateful.  For example, a
  // get-the-next-element-from-the-collection action will need to
  // remember the current element.
  virtual Result Perform(const ArgumentTuple& args) = 0;

 private:
422
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
423
424
425
426
427
};

// An Action<F> is a copyable and IMMUTABLE (except by assignment)
// object that represents an action to be taken when a mock function
// of type F is called.  The implementation of Action<T> is just a
misterg's avatar
misterg committed
428
// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
429
430
431
432
433
// You can view an object implementing ActionInterface<F> as a
// concrete action (including its current state), and an Action<F>
// object as a handle to it.
template <typename F>
class Action {
Abseil Team's avatar
Abseil Team committed
434
435
436
437
438
439
440
441
442
443
444
445
446
  // Adapter class to allow constructing Action from a legacy ActionInterface.
  // New code should create Actions from functors instead.
  struct ActionAdapter {
    // Adapter must be copyable to satisfy std::function requirements.
    ::std::shared_ptr<ActionInterface<F>> impl_;

    template <typename... Args>
    typename internal::Function<F>::Result operator()(Args&&... args) {
      return impl_->Perform(
          ::std::forward_as_tuple(::std::forward<Args>(args)...));
    }
  };

447
448
449
450
451
452
 public:
  typedef typename internal::Function<F>::Result Result;
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

  // Constructs a null Action.  Needed for storing Action objects in
  // STL containers.
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
453
  Action() {}
454

Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
455
456
457
458
459
460
461
  // Construct an Action from a specified callable.
  // This cannot take std::function directly, because then Action would not be
  // directly constructible from lambda (it would require two conversions).
  template <typename G,
            typename = typename ::std::enable_if<
                ::std::is_constructible<::std::function<F>, G>::value>::type>
  Action(G&& fun) : fun_(::std::forward<G>(fun)) {}  // NOLINT
462

Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
463
  // Constructs an Action from its implementation.
Abseil Team's avatar
Abseil Team committed
464
465
  explicit Action(ActionInterface<F>* impl)
      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
Gennadiy Civil's avatar
Gennadiy Civil committed
466

467
468
  // This constructor allows us to turn an Action<Func> object into an
  // Action<F>, as long as F's arguments can be implicitly converted
Abseil Team's avatar
Abseil Team committed
469
  // to Func's and Func's return type can be implicitly converted to F's.
470
  template <typename Func>
Abseil Team's avatar
Abseil Team committed
471
  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
472

473
  // Returns true if and only if this is the DoDefault() action.
Abseil Team's avatar
Abseil Team committed
474
  bool IsDoDefault() const { return fun_ == nullptr; }
475
476
477
478
479
480
481

  // Performs the action.  Note that this method is const even though
  // the corresponding method in ActionInterface is not.  The reason
  // is that a const Action<F> means that it cannot be re-bound to
  // another concrete action, not that the concrete action it binds to
  // cannot change state.  (Think of the difference between a const
  // pointer and a pointer to const.)
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
482
483
484
485
  Result Perform(ArgumentTuple args) const {
    if (IsDoDefault()) {
      internal::IllegalDoDefault(__FILE__, __LINE__);
    }
Abseil Team's avatar
Abseil Team committed
486
    return internal::Apply(fun_, ::std::move(args));
487
  }
488

489
 private:
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
490
491
492
  template <typename G>
  friend class Action;

493
  // fun_ is an empty function if and only if this is the DoDefault() action.
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
494
  ::std::function<F> fun_;
495
496
497
498
499
500
501
502
503
504
505
506
507
508
};

// The PolymorphicAction class template makes it easy to implement a
// polymorphic action (i.e. an action that can be used in mock
// functions of than one type, e.g. Return()).
//
// To define a polymorphic action, a user first provides a COPYABLE
// implementation class that has a Perform() method template:
//
//   class FooAction {
//    public:
//     template <typename Result, typename ArgumentTuple>
//     Result Perform(const ArgumentTuple& args) const {
//       // Processes the arguments and returns a result, using
Abseil Team's avatar
Abseil Team committed
509
//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
//     }
//     ...
//   };
//
// Then the user creates the polymorphic action using
// MakePolymorphicAction(object) where object has type FooAction.  See
// the definition of Return(void) and SetArgumentPointee<N>(value) for
// complete examples.
template <typename Impl>
class PolymorphicAction {
 public:
  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}

  template <typename F>
  operator Action<F>() const {
    return Action<F>(new MonomorphicImpl<F>(impl_));
  }
527

528
529
530
531
532
533
534
535
536
 private:
  template <typename F>
  class MonomorphicImpl : public ActionInterface<F> {
   public:
    typedef typename internal::Function<F>::Result Result;
    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}

Abseil Team's avatar
Abseil Team committed
537
    Result Perform(const ArgumentTuple& args) override {
538
539
540
541
542
      return impl_.template Perform<Result>(args);
    }

   private:
    Impl impl_;
543
544

    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
545
546
547
  };

  Impl impl_;
548
549

  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
};

// Creates an Action from its implementation and returns it.  The
// created Action object owns the implementation.
template <typename F>
Action<F> MakeAction(ActionInterface<F>* impl) {
  return Action<F>(impl);
}

// Creates a polymorphic action from its implementation.  This is
// easier to use than the PolymorphicAction<Impl> constructor as it
// doesn't require you to explicitly write the template argument, e.g.
//
//   MakePolymorphicAction(foo);
// vs
//   PolymorphicAction<TypeOfFoo>(foo);
template <typename Impl>
inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
  return PolymorphicAction<Impl>(impl);
}

namespace internal {

573
574
575
576
// Helper struct to specialize ReturnAction to execute a move instead of a copy
// on return. Useful for move-only types, but could be used on any type.
template <typename T>
struct ByMoveWrapper {
Abseil Team's avatar
Abseil Team committed
577
  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
578
579
580
  T payload;
};

581
582
583
// Implements the polymorphic Return(x) action, which can be used in
// any function that returns the type of x, regardless of the argument
// types.
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
//
// Note: The value passed into Return must be converted into
// Function<F>::Result when this action is cast to Action<F> rather than
// when that action is performed. This is important in scenarios like
//
// MOCK_METHOD1(Method, T(U));
// ...
// {
//   Foo foo;
//   X x(&foo);
//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
// }
//
// In the example above the variable x holds reference to foo which leaves
// scope and gets destroyed.  If copying X just copies a reference to foo,
// that copy will be left with a hanging reference.  If conversion to T
// makes a copy of foo, the above code is safe. To support that scenario, we
// need to make sure that the type conversion happens inside the EXPECT_CALL
// statement, and conversion of the result of Return to Action<T(U)> is a
// good place for that.
//
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
605
606
607
// The real life example of the above scenario happens when an invocation
// of gtl::Container() is passed into Return.
//
608
609
610
611
612
613
template <typename R>
class ReturnAction {
 public:
  // Constructs a ReturnAction object from the value to be returned.
  // 'value' is passed by value instead of by const reference in order
  // to allow Return("string literal") to compile.
Abseil Team's avatar
Abseil Team committed
614
  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
615
616
617
618

  // This template type conversion operator allows Return(x) to be
  // used in ANY function that returns x's type.
  template <typename F>
Abseil Team's avatar
Abseil Team committed
619
  operator Action<F>() const {  // NOLINT
620
621
622
623
624
625
626
627
628
    // Assert statement belongs here because this is the best place to verify
    // conditions on F. It produces the clearest error messages
    // in most compilers.
    // Impl really belongs in this scope as a local class but can't
    // because MSVC produces duplicate symbols in different translation units
    // in this case. Until MS fixes that bug we put Impl into the class scope
    // and put the typedef both here (for use in assert statement) and
    // in the Impl class. But both definitions must be the same.
    typedef typename Function<F>::Result Result;
629
    GTEST_COMPILE_ASSERT_(
630
        !std::is_reference<Result>::value,
631
        use_ReturnRef_instead_of_Return_to_return_a_reference);
Abseil Team's avatar
Abseil Team committed
632
633
    static_assert(!std::is_void<Result>::value,
                  "Can't use Return() on an action expected to return `void`.");
634
    return Action<F>(new Impl<R, F>(value_));
635
  }
636

637
638
 private:
  // Implements the Return(x) action for a particular function type F.
639
  template <typename R_, typename F>
640
641
642
643
644
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

645
646
647
648
    // The implicit cast is necessary when Result has more than one
    // single-argument constructor (e.g. Result is std::vector<int>) and R
    // has a type conversion operator template.  In that case, value_(value)
    // won't compile as the compiler doesn't known which constructor of
649
    // Result to call.  ImplicitCast_ forces the compiler to convert R to
650
651
    // Result without considering explicit constructors, thus resolving the
    // ambiguity. value_ is then initialized using its copy constructor.
misterg's avatar
misterg committed
652
    explicit Impl(const std::shared_ptr<R>& value)
653
654
        : value_before_cast_(*value),
          value_(ImplicitCast_<Result>(value_before_cast_)) {}
655

Abseil Team's avatar
Abseil Team committed
656
    Result Perform(const ArgumentTuple&) override { return value_; }
657
658

   private:
659
    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
660
                          Result_cannot_be_a_reference_type);
661
662
663
    // We save the value before casting just in case it is being cast to a
    // wrapper type.
    R value_before_cast_;
664
    Result value_;
665

666
    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
667
668
  };

669
670
671
672
673
674
675
676
  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
  // move its contents instead.
  template <typename R_, typename F>
  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

misterg's avatar
misterg committed
677
    explicit Impl(const std::shared_ptr<R>& wrapper)
678
679
        : performed_(false), wrapper_(wrapper) {}

Abseil Team's avatar
Abseil Team committed
680
    Result Perform(const ArgumentTuple&) override {
681
682
683
      GTEST_CHECK_(!performed_)
          << "A ByMove() action should only be performed once.";
      performed_ = true;
Abseil Team's avatar
Abseil Team committed
684
      return std::move(wrapper_->payload);
685
686
687
688
    }

   private:
    bool performed_;
misterg's avatar
misterg committed
689
    const std::shared_ptr<R> wrapper_;
690
691
692
693

    GTEST_DISALLOW_ASSIGN_(Impl);
  };

misterg's avatar
misterg committed
694
  const std::shared_ptr<R> value_;
695
696

  GTEST_DISALLOW_ASSIGN_(ReturnAction);
697
698
699
700
701
};

// Implements the ReturnNull() action.
class ReturnNullAction {
 public:
702
703
704
  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
  // this is enforced by returning nullptr, and in non-C++11 by asserting a
  // pointer type on compile time.
705
706
  template <typename Result, typename ArgumentTuple>
  static Result Perform(const ArgumentTuple&) {
707
    return nullptr;
708
709
710
711
712
713
714
715
716
  }
};

// Implements the Return() action.
class ReturnVoidAction {
 public:
  // Allows Return() to be used in any void-returning function.
  template <typename Result, typename ArgumentTuple>
  static void Perform(const ArgumentTuple&) {
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
717
    static_assert(std::is_void<Result>::value, "Result should be void.");
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
  }
};

// Implements the polymorphic ReturnRef(x) action, which can be used
// in any function that returns a reference to the type of x,
// regardless of the argument types.
template <typename T>
class ReturnRefAction {
 public:
  // Constructs a ReturnRefAction object from the reference to be returned.
  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT

  // This template type conversion operator allows ReturnRef(x) to be
  // used in ANY function that returns a reference to x's type.
  template <typename F>
  operator Action<F>() const {
    typedef typename Function<F>::Result Result;
    // Asserts that the function return type is a reference.  This
    // catches the user error of using ReturnRef(x) when Return(x)
    // should be used, and generates some helpful error message.
738
    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
739
                          use_Return_instead_of_ReturnRef_to_return_a_value);
740
741
    return Action<F>(new Impl<F>(ref_));
  }
742

743
744
745
746
747
748
749
750
751
752
 private:
  // Implements the ReturnRef(x) action for a particular function type F.
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT

Abseil Team's avatar
Abseil Team committed
753
    Result Perform(const ArgumentTuple&) override { return ref_; }
754

755
756
   private:
    T& ref_;
757
758

    GTEST_DISALLOW_ASSIGN_(Impl);
759
760
761
  };

  T& ref_;
762
763

  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
764
765
};

766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
// used in any function that returns a reference to the type of x,
// regardless of the argument types.
template <typename T>
class ReturnRefOfCopyAction {
 public:
  // Constructs a ReturnRefOfCopyAction object from the reference to
  // be returned.
  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT

  // This template type conversion operator allows ReturnRefOfCopy(x) to be
  // used in ANY function that returns a reference to x's type.
  template <typename F>
  operator Action<F>() const {
    typedef typename Function<F>::Result Result;
    // Asserts that the function return type is a reference.  This
    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
    // should be used, and generates some helpful error message.
    GTEST_COMPILE_ASSERT_(
785
        std::is_reference<Result>::value,
786
787
788
789
790
791
792
793
794
795
796
797
798
799
        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
    return Action<F>(new Impl<F>(value_));
  }

 private:
  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const T& value) : value_(value) {}  // NOLINT

Abseil Team's avatar
Abseil Team committed
800
    Result Perform(const ArgumentTuple&) override { return value_; }
801
802
803
804
805
806
807
808
809
810
811
812

   private:
    T value_;

    GTEST_DISALLOW_ASSIGN_(Impl);
  };

  const T value_;

  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
};

Abseil Team's avatar
Abseil Team committed
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
// Implements the polymorphic ReturnRoundRobin(v) action, which can be
// used in any function that returns the element_type of v.
template <typename T>
class ReturnRoundRobinAction {
 public:
  explicit ReturnRoundRobinAction(std::vector<T> values) {
    GTEST_CHECK_(!values.empty())
        << "ReturnRoundRobin requires at least one element.";
    state_->values = std::move(values);
  }

  template <typename... Args>
  T operator()(Args&&...) const {
     return state_->Next();
  }

 private:
  struct State {
    T Next() {
      T ret_val = values[i++];
      if (i == values.size()) i = 0;
      return ret_val;
    }

    std::vector<T> values;
    size_t i = 0;
  };
  std::shared_ptr<State> state_ = std::make_shared<State>();
};

843
844
845
846
847
848
// Implements the polymorphic DoDefault() action.
class DoDefaultAction {
 public:
  // This template type conversion operator allows DoDefault() to be
  // used in any function.
  template <typename F>
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
849
  operator Action<F>() const { return Action<F>(); }  // NOLINT
850
851
852
853
854
855
856
857
858
859
};

// Implements the Assign action to set a given pointer referent to a
// particular value.
template <typename T1, typename T2>
class AssignAction {
 public:
  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}

  template <typename Result, typename ArgumentTuple>
860
  void Perform(const ArgumentTuple& /* args */) const {
861
862
    *ptr_ = value_;
  }
863

864
865
866
 private:
  T1* const ptr_;
  const T2 value_;
867
868

  GTEST_DISALLOW_ASSIGN_(AssignAction);
869
870
};

871
#if !GTEST_OS_WINDOWS_MOBILE
872

873
874
875
876
877
878
879
880
881
// Implements the SetErrnoAndReturn action to simulate return from
// various system calls and libc functions.
template <typename T>
class SetErrnoAndReturnAction {
 public:
  SetErrnoAndReturnAction(int errno_value, T result)
      : errno_(errno_value),
        result_(result) {}
  template <typename Result, typename ArgumentTuple>
882
  Result Perform(const ArgumentTuple& /* args */) const {
883
884
885
    errno = errno_;
    return result_;
  }
886

887
888
889
 private:
  const int errno_;
  const T result_;
890
891

  GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
892
893
};

894
#endif  // !GTEST_OS_WINDOWS_MOBILE
895

896
// Implements the SetArgumentPointee<N>(x) action for any function
Abseil Team's avatar
Abseil Team committed
897
898
899
900
// whose N-th argument (0-based) is a pointer to x's type.
template <size_t N, typename A, typename = void>
struct SetArgumentPointeeAction {
  A value;
901

Abseil Team's avatar
Abseil Team committed
902
903
904
  template <typename... Args>
  void operator()(const Args&... args) const {
    *::std::get<N>(std::tie(args...)) = value;
905
906
907
  }
};

Abseil Team's avatar
Abseil Team committed
908
909
910
911
912
913
914
915
916
917
918
919
920
// Implements the Invoke(object_ptr, &Class::Method) action.
template <class Class, typename MethodPtr>
struct InvokeMethodAction {
  Class* const obj_ptr;
  const MethodPtr method_ptr;

  template <typename... Args>
  auto operator()(Args&&... args) const
      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
  }
};

921
922
923
// Implements the InvokeWithoutArgs(f) action.  The template argument
// FunctionImpl is the implementation type of f, which can be either a
// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
Abseil Team's avatar
Abseil Team committed
924
// Action<F> as long as f's type is compatible with F.
925
template <typename FunctionImpl>
Abseil Team's avatar
Abseil Team committed
926
927
struct InvokeWithoutArgsAction {
  FunctionImpl function_impl;
928
929
930

  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
  // compatible with f.
Abseil Team's avatar
Abseil Team committed
931
932
933
934
  template <typename... Args>
  auto operator()(const Args&...) -> decltype(function_impl()) {
    return function_impl();
  }
935
936
937
938
};

// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
template <class Class, typename MethodPtr>
Abseil Team's avatar
Abseil Team committed
939
940
941
struct InvokeMethodWithoutArgsAction {
  Class* const obj_ptr;
  const MethodPtr method_ptr;
942

Abseil Team's avatar
Abseil Team committed
943
  using ReturnType = typename std::result_of<MethodPtr(Class*)>::type;
944

Abseil Team's avatar
Abseil Team committed
945
946
947
  template <typename... Args>
  ReturnType operator()(const Args&...) const {
    return (obj_ptr->*method_ptr)();
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
948
949
950
  }
};

951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
// Implements the IgnoreResult(action) action.
template <typename A>
class IgnoreResultAction {
 public:
  explicit IgnoreResultAction(const A& action) : action_(action) {}

  template <typename F>
  operator Action<F>() const {
    // Assert statement belongs here because this is the best place to verify
    // conditions on F. It produces the clearest error messages
    // in most compilers.
    // Impl really belongs in this scope as a local class but can't
    // because MSVC produces duplicate symbols in different translation units
    // in this case. Until MS fixes that bug we put Impl into the class scope
    // and put the typedef both here (for use in assert statement) and
    // in the Impl class. But both definitions must be the same.
    typedef typename internal::Function<F>::Result Result;

    // Asserts at compile time that F returns void.
Hosein Ghahremanzadeh's avatar
Hosein Ghahremanzadeh committed
970
    static_assert(std::is_void<Result>::value, "Result type should be void.");
971
972
973

    return Action<F>(new Impl<F>(action_));
  }
974

975
976
977
978
979
980
981
982
983
 private:
  template <typename F>
  class Impl : public ActionInterface<F> {
   public:
    typedef typename internal::Function<F>::Result Result;
    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;

    explicit Impl(const A& action) : action_(action) {}

Abseil Team's avatar
Abseil Team committed
984
    void Perform(const ArgumentTuple& args) override {
985
986
987
988
989
990
991
992
993
994
995
      // Performs the action and ignores its result.
      action_.Perform(args);
    }

   private:
    // Type OriginalFunction is the same as F except that its return
    // type is IgnoredValue.
    typedef typename internal::Function<F>::MakeResultIgnoredValue
        OriginalFunction;

    const Action<OriginalFunction> action_;
996
997

    GTEST_DISALLOW_ASSIGN_(Impl);
998
999
1000
  };

  const A action_;
1001
1002

  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
1003
1004
};

Abseil Team's avatar
Abseil Team committed
1005
1006
1007
1008
1009
1010
1011
1012
template <typename InnerAction, size_t... I>
struct WithArgsAction {
  InnerAction action;

  // The inner action could be anything convertible to Action<X>.
  // We use the conversion operator to detect the signature of the inner Action.
  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
1013
1014
    using TupleType = std::tuple<Args...>;
    Action<R(typename std::tuple_element<I, TupleType>::type...)>
Abseil Team's avatar
Abseil Team committed
1015
1016
1017
1018
1019
1020
1021
1022
1023
        converted(action);

    return [converted](Args... args) -> R {
      return converted.Perform(std::forward_as_tuple(
        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
    };
  }
};

Abseil Team's avatar
Abseil Team committed
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
template <typename... Actions>
struct DoAllAction {
 private:
  template <typename... Args, size_t... I>
  std::vector<Action<void(Args...)>> Convert(IndexSequence<I...>) const {
    return {std::get<I>(actions)...};
  }

 public:
  std::tuple<Actions...> actions;

  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
    struct Op {
      std::vector<Action<void(Args...)>> converted;
      Action<R(Args...)> last;
      R operator()(Args... args) const {
        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
        for (auto& a : converted) {
          a.Perform(tuple_args);
        }
        return last.Perform(tuple_args);
      }
    };
    return Op{Convert<Args...>(MakeIndexSequence<sizeof...(Actions) - 1>()),
              std::get<sizeof...(Actions) - 1>(actions)};
  }
};

1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
}  // namespace internal

// An Unused object can be implicitly constructed from ANY value.
// This is handy when defining actions that ignore some or all of the
// mock function arguments.  For example, given
//
//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
//   MOCK_METHOD3(Bar, double(int index, double x, double y));
//
// instead of
//
//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   double DistanceToOriginWithIndex(int index, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   ...
Hector Dearman's avatar
Hector Dearman committed
1071
//   EXPECT_CALL(mock, Foo("abc", _, _))
1072
//       .WillOnce(Invoke(DistanceToOriginWithLabel));
Hector Dearman's avatar
Hector Dearman committed
1073
//   EXPECT_CALL(mock, Bar(5, _, _))
1074
1075
1076
1077
1078
1079
1080
1081
1082
//       .WillOnce(Invoke(DistanceToOriginWithIndex));
//
// you could write
//
//   // We can declare any uninteresting argument as Unused.
//   double DistanceToOrigin(Unused, double x, double y) {
//     return sqrt(x*x + y*y);
//   }
//   ...
Hector Dearman's avatar
Hector Dearman committed
1083
1084
//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
1085
1086
typedef internal::IgnoredValue Unused;

Abseil Team's avatar
Abseil Team committed
1087
1088
1089
1090
1091
1092
1093
1094
// Creates an action that does actions a1, a2, ..., sequentially in
// each invocation.
template <typename... Action>
internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
    Action&&... action) {
  return {std::forward_as_tuple(std::forward<Action>(action)...)};
}

Abseil Team's avatar
Abseil Team committed
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
// WithArg<k>(an_action) creates an action that passes the k-th
// (0-based) argument of the mock function to an_action and performs
// it.  It adapts an action accepting one argument to one that accepts
// multiple arguments.  For convenience, we also provide
// WithArgs<k>(an_action) (defined below) as a synonym.
template <size_t k, typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
WithArg(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
// the selected arguments of the mock function to an_action and
// performs it.  It serves as an adaptor between actions with
// different argument lists.
template <size_t k, size_t... ks, typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
WithArgs(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

// WithoutArgs(inner_action) can be used in a mock function with a
// non-empty argument list to perform inner_action, which takes no
// argument.  In other words, it adapts an action accepting no
// argument to one that accepts (and ignores) arguments.
template <typename InnerAction>
internal::WithArgsAction<typename std::decay<InnerAction>::type>
WithoutArgs(InnerAction&& action) {
  return {std::forward<InnerAction>(action)};
}

1126
1127
1128
1129
1130
// Creates an action that returns 'value'.  'value' is passed by value
// instead of const reference - otherwise Return("string literal")
// will trigger a compiler error about using array as initializer.
template <typename R>
internal::ReturnAction<R> Return(R value) {
Abseil Team's avatar
Abseil Team committed
1131
  return internal::ReturnAction<R>(std::move(value));
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
}

// Creates an action that returns NULL.
inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
  return MakePolymorphicAction(internal::ReturnNullAction());
}

// Creates an action that returns from a void function.
inline PolymorphicAction<internal::ReturnVoidAction> Return() {
  return MakePolymorphicAction(internal::ReturnVoidAction());
}

// Creates an action that returns the reference to a variable.
template <typename R>
inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
  return internal::ReturnRefAction<R>(x);
}

1150
// Prevent using ReturnRef on reference to temporary.
1151
template <typename R, R* = nullptr>
1152
1153
internal::ReturnRefAction<R> ReturnRef(R&&) = delete;

1154
1155
1156
1157
1158
1159
1160
1161
// Creates an action that returns the reference to a copy of the
// argument.  The copy is created when the action is constructed and
// lives as long as the action.
template <typename R>
inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
  return internal::ReturnRefOfCopyAction<R>(x);
}

1162
1163
1164
1165
1166
1167
// Modifies the parent action (a Return() action) to perform a move of the
// argument instead of a copy.
// Return(ByMove()) actions can only be executed once and will assert this
// invariant.
template <typename R>
internal::ByMoveWrapper<R> ByMove(R x) {
Abseil Team's avatar
Abseil Team committed
1168
  return internal::ByMoveWrapper<R>(std::move(x));
1169
1170
}

Abseil Team's avatar
Abseil Team committed
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
// Creates an action that returns an element of `vals`. Calling this action will
// repeatedly return the next value from `vals` until it reaches the end and
// will restart from the beginning.
template <typename T>
internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
  return internal::ReturnRoundRobinAction<T>(std::move(vals));
}

// Creates an action that returns an element of `vals`. Calling this action will
// repeatedly return the next value from `vals` until it reaches the end and
// will restart from the beginning.
template <typename T>
internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
    std::initializer_list<T> vals) {
  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
}

1188
1189
1190
1191
1192
1193
1194
1195
// Creates an action that does the default action for the give mock function.
inline internal::DoDefaultAction DoDefault() {
  return internal::DoDefaultAction();
}

// Creates an action that sets the variable pointed by the N-th
// (0-based) function argument to 'value'.
template <size_t N, typename T>
Abseil Team's avatar
Abseil Team committed
1196
1197
internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
  return {std::move(value)};
1198
1199
}

1200
1201
// The following version is DEPRECATED.
template <size_t N, typename T>
Abseil Team's avatar
Abseil Team committed
1202
1203
internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
  return {std::move(value)};
1204
1205
1206
1207
1208
1209
1210
1211
}

// Creates an action that sets a pointer referent to a given value.
template <typename T1, typename T2>
PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
}

1212
#if !GTEST_OS_WINDOWS_MOBILE
1213

1214
1215
1216
1217
1218
1219
1220
1221
// Creates an action that sets errno and returns the appropriate error.
template <typename T>
PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
SetErrnoAndReturn(int errval, T result) {
  return MakePolymorphicAction(
      internal::SetErrnoAndReturnAction<T>(errval, result));
}

1222
#endif  // !GTEST_OS_WINDOWS_MOBILE
1223

Abseil Team's avatar
Abseil Team committed
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
// Various overloads for Invoke().

// Legacy function.
// Actions can now be implicitly constructed from callables. No need to create
// wrapper objects.
// This function exists for backwards compatibility.
template <typename FunctionImpl>
typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
  return std::forward<FunctionImpl>(function_impl);
}

// Creates an action that invokes the given method on the given object
// with the mock function's arguments.
template <class Class, typename MethodPtr>
internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
                                                      MethodPtr method_ptr) {
  return {obj_ptr, method_ptr};
}
1242
1243
1244

// Creates an action that invokes 'function_impl' with no argument.
template <typename FunctionImpl>
Abseil Team's avatar
Abseil Team committed
1245
internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
1246
InvokeWithoutArgs(FunctionImpl function_impl) {
Abseil Team's avatar
Abseil Team committed
1247
  return {std::move(function_impl)};
1248
1249
1250
1251
1252
}

// Creates an action that invokes the given method on the given object
// with no argument.
template <class Class, typename MethodPtr>
Abseil Team's avatar
Abseil Team committed
1253
1254
1255
internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
    Class* obj_ptr, MethodPtr method_ptr) {
  return {obj_ptr, method_ptr};
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
}

// Creates an action that performs an_action and throws away its
// result.  In other words, it changes the return type of an_action to
// void.  an_action MUST NOT return void, or the code won't compile.
template <typename A>
inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
  return internal::IgnoreResultAction<A>(an_action);
}

1266
1267
1268
1269
1270
1271
1272
// Creates a reference wrapper for the given L-value.  If necessary,
// you can explicitly specify the type of the reference.  For example,
// suppose 'derived' is an object of type Derived, ByRef(derived)
// would wrap a Derived&.  If you want to wrap a const Base& instead,
// where Base is a base class of Derived, just write:
//
//   ByRef<const Base>(derived)
Abseil Team's avatar
Abseil Team committed
1273
1274
1275
//
// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
// However, it may still be used for consistency with ByMove().
1276
template <typename T>
Abseil Team's avatar
Abseil Team committed
1277
1278
inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
  return ::std::reference_wrapper<T>(l_value);
1279
1280
}

Abseil Team's avatar
Abseil Team committed
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
namespace internal {

// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
// defines an action that can be used in a mock function.  Typically,
// these actions only care about a subset of the arguments of the mock
// function.  For example, if such an action only uses the second
// argument, it can be used in any mock function that takes >= 2
// arguments where the type of the second argument is compatible.
//
// Therefore, the action implementation must be prepared to take more
// arguments than it needs.  The ExcessiveArg type is used to
// represent those excessive arguments.  In order to keep the compiler
// error messages tractable, we define it in the testing namespace
// instead of testing::internal.  However, this is an INTERNAL TYPE
// and subject to change without notice, so a user MUST NOT USE THIS
// TYPE DIRECTLY.
struct ExcessiveArg {};

// A helper class needed for implementing the ACTION* macros.
template <typename Result, class Impl>
class ActionHelper {
 public:
  template <typename... Ts>
  static Result Perform(Impl* impl, const std::tuple<Ts...>& args) {
    return Apply(impl, args, MakeIndexSequence<sizeof...(Ts)>{},
                 MakeIndexSequence<10 - sizeof...(Ts)>{});
  }

 private:
  template <typename... Ts, std::size_t... tuple_ids, std::size_t... rest_ids>
  static Result Apply(Impl* impl, const std::tuple<Ts...>& args,
                      IndexSequence<tuple_ids...>, IndexSequence<rest_ids...>) {
    return impl->template gmock_PerformImpl<Ts...>(
        args, std::get<tuple_ids>(args)...,
        ((void)rest_ids, ExcessiveArg())...);
  }
};

Abseil Team's avatar
Abseil Team committed
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
// A helper base class needed for implementing the ACTION* macros.
// Implements constructor and conversion operator for Action.
//
// Template specialization for parameterless Action.
template <typename Derived>
class ActionImpl {
 public:
  ActionImpl() = default;

  template <typename F>
  operator ::testing::Action<F>() const {  // NOLINT(runtime/explicit)
    return ::testing::Action<F>(new typename Derived::template gmock_Impl<F>());
  }
};

// Template specialization for parameterized Action.
template <template <typename...> class Derived, typename... Ts>
class ActionImpl<Derived<Ts...>> {
 public:
  explicit ActionImpl(Ts... params) : params_(std::forward<Ts>(params)...) {}

  template <typename F>
  operator ::testing::Action<F>() const {  // NOLINT(runtime/explicit)
    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
  }

 private:
  template <typename F, std::size_t... tuple_ids>
  ::testing::Action<F> Apply(IndexSequence<tuple_ids...>) const {
    return ::testing::Action<F>(new
                                typename Derived<Ts...>::template gmock_Impl<F>(
                                    std::get<tuple_ids>(params_)...));
  }

  std::tuple<Ts...> params_;
};

Abseil Team's avatar
Abseil Team committed
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
namespace invoke_argument {

// Appears in InvokeArgumentAdl's argument list to help avoid
// accidental calls to user functions of the same name.
struct AdlTag {};

// InvokeArgumentAdl - a helper for InvokeArgument.
// The basic overloads are provided here for generic functors.
// Overloads for other custom-callables are provided in the
// internal/custom/gmock-generated-actions.h header.
template <typename F, typename... Args>
auto InvokeArgumentAdl(AdlTag, F f, Args... args) -> decltype(f(args...)) {
  return f(args...);
}

}  // namespace invoke_argument
Abseil Team's avatar
Abseil Team committed
1372

Abseil Team's avatar
Abseil Team committed
1373
1374
#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
Abseil Team's avatar
Abseil Team committed
1375
1376
1377
1378
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                 \
  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

Abseil Team's avatar
Abseil Team committed
1379
#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
Abseil Team's avatar
Abseil Team committed
1380
1381
1382
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)

Abseil Team's avatar
Abseil Team committed
1383
#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
Abseil Team's avatar
Abseil Team committed
1384
1385
1386
#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))

Abseil Team's avatar
Abseil Team committed
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
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
1452
1453
1454
1455
1456
1457
1458
1459
1460
#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))

#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
#define GMOCK_ACTION_TYPE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))

#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
  , param##_type gmock_p##i
#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))

#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
  , std::forward<param##_type>(gmock_p##i)
#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))

#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
  , param(::std::forward<param##_type>(gmock_p##i))
#define GMOCK_ACTION_INIT_PARAMS_(params) \
  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))

#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
#define GMOCK_ACTION_FIELD_PARAMS_(params) \
  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)

#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  class full_name : public ::testing::internal::ActionImpl<                   \
                        full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>> {       \
    using base_type = ::testing::internal::ActionImpl<full_name>;             \
                                                                              \
   public:                                                                    \
    using base_type::base_type;                                               \
    template <typename F>                                                     \
    class gmock_Impl : public ::testing::ActionInterface<F> {                 \
     public:                                                                  \
      typedef F function_type;                                                \
      typedef typename ::testing::internal::Function<F>::Result return_type;  \
      typedef                                                                 \
          typename ::testing::internal::Function<F>::ArgumentTuple args_type; \
      gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))                    \
          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
      return_type Perform(const args_type& args) override {                   \
        return ::testing::internal::ActionHelper<return_type,                 \
                                                 gmock_Impl>::Perform(this,   \
                                                                      args);  \
      }                                                                       \
      template <GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                            \
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
                                                                              \
     private:                                                                 \
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);                                     \
    };                                                                        \
                                                                              \
   private:                                                                   \
    GTEST_DISALLOW_ASSIGN_(full_name);                                        \
  };                                                                          \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
  }                                                                           \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
  template <typename F>                                                       \
  template <GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
  typename ::testing::internal::Function<F>::Result                           \
      full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl<               \
          F>::gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_)     \
          const

Abseil Team's avatar
Abseil Team committed
1461
1462
}  // namespace internal

Abseil Team's avatar
Abseil Team committed
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
#define ACTION(name)                                                          \
  class name##Action : public ::testing::internal::ActionImpl<name##Action> { \
    using base_type = ::testing::internal::ActionImpl<name##Action>;          \
                                                                              \
   public:                                                                    \
    using base_type::base_type;                                               \
    template <typename F>                                                     \
    class gmock_Impl : public ::testing::ActionInterface<F> {                 \
     public:                                                                  \
      typedef F function_type;                                                \
      typedef typename ::testing::internal::Function<F>::Result return_type;  \
      typedef                                                                 \
          typename ::testing::internal::Function<F>::ArgumentTuple args_type; \
      gmock_Impl() {}                                                         \
      return_type Perform(const args_type& args) override {                   \
        return ::testing::internal::ActionHelper<return_type,                 \
                                                 gmock_Impl>::Perform(this,   \
                                                                      args);  \
      }                                                                       \
      template <GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                            \
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
                                                                              \
     private:                                                                 \
      GTEST_DISALLOW_ASSIGN_(gmock_Impl);                                     \
    };                                                                        \
                                                                              \
   private:                                                                   \
    GTEST_DISALLOW_ASSIGN_(name##Action);                                     \
  };                                                                          \
  inline name##Action name() { return name##Action(); }                       \
  template <typename F>                                                       \
  template <GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
  typename ::testing::internal::Function<F>::Result                           \
      name##Action::gmock_Impl<F>::gmock_PerformImpl(                         \
          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const

#define ACTION_P(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))

#define ACTION_P2(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))

#define ACTION_P3(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))

#define ACTION_P4(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))

#define ACTION_P5(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))

#define ACTION_P6(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))

#define ACTION_P7(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))

#define ACTION_P8(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))

#define ACTION_P9(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))

#define ACTION_P10(name, ...) \
  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))

1529
1530
}  // namespace testing

misterg's avatar
misterg committed
1531
1532
1533
1534
1535
#ifdef _MSC_VER
# pragma warning(pop)
#endif


1536
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_