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

// Google Mock - a framework for writing C++ mock classes.
//
// This file implements some commonly used actions.

Gennadiy Civil's avatar
 
Gennadiy Civil committed
35
36
// GOOGLETEST_CM0002 DO NOT DELETE

37
38
39
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_

40
#ifndef _WIN32_WCE
41
# include <errno.h>
42
43
#endif

44
#include <algorithm>
Abseil Team's avatar
Abseil Team committed
45
#include <functional>
misterg's avatar
misterg committed
46
#include <memory>
47
#include <string>
Abseil Team's avatar
Abseil Team committed
48
#include <type_traits>
Abseil Team's avatar
Abseil Team committed
49
#include <utility>
50

51
52
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
Abseil Team's avatar
Abseil Team committed
53
#include "gmock/internal/gmock-pp.h"
54

misterg's avatar
misterg committed
55
56
57
58
59
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4100)
#endif

60
61
62
63
64
65
66
67
68
69
70
71
72
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 {

73
74
75
76
77
78
79
80
81
// 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(); }
};
82
template <typename T>
83
struct BuiltInDefaultValueGetter<T, false> {
84
85
86
87
88
89
90
91
92
  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.
  }
};

93
94
95
96
97
98
99
100
101
102
// 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:
103
104
  // This function returns true if and only if type T has a built-in default
  // value.
105
106
107
108
109
110
111
112
113
114
  static bool Exists() {
    return ::std::is_default_constructible<T>::value;
  }

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

115
116
117
118
119
// 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:
120
  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
121
122
123
124
125
126
127
128
  static T Get() { return BuiltInDefaultValue<T>::Get(); }
};

// This partial specialization defines the default values for pointer
// types.
template <typename T>
class BuiltInDefaultValue<T*> {
 public:
129
  static bool Exists() { return true; }
130
  static T* Get() { return nullptr; }
131
132
133
134
};

// The following specializations define the default values for
// specific types we care about.
135
#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
136
137
138
  template <> \
  class BuiltInDefaultValue<type> { \
   public: \
139
    static bool Exists() { return true; } \
140
141
142
    static type Get() { return value; } \
  }

143
144
145
146
147
148
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');
149
150
151
152
153
154
155

// 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.
156
#if GMOCK_WCHAR_T_IS_NATIVE_
157
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
158
159
#endif

160
161
162
163
164
165
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
166
167
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
168
169
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
170

171
#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193

}  // 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) {
194
195
196
197
198
199
200
201
202
203
204
    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);
205
206
207
208
  }

  // Unsets the default value for type T.
  static void Clear() {
209
    delete producer_;
210
    producer_ = nullptr;
211
212
  }

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

216
217
218
219
220
221
  // 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();
  }

222
  // Returns the default value for type T if the user has set one;
223
224
  // otherwise returns the built-in default value. Requires that Exists()
  // is true, which ensures that the return value is well-defined.
225
  static T Get() {
226
227
    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
                                : producer_->Produce();
228
  }
229

230
 private:
231
232
233
234
235
236
237
238
239
  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
240
    T Produce() override { return value_; }
241
242
243
244
245
246
247
248
249
250

   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
251
    T Produce() override { return factory_(); }
252
253
254
255
256
257
258

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

  static ValueProducer* producer_;
259
260
261
262
263
264
265
266
267
268
269
270
271
};

// 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&.
272
  static void Clear() { address_ = nullptr; }
273

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

277
278
279
280
281
282
  // 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();
  }

283
284
285
286
  // 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() {
287
288
    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
                               : *address_;
289
  }
290

291
292
293
294
295
296
297
298
299
 private:
  static T* address_;
};

// This specialization allows DefaultValue<void>::Get() to
// compile.
template <>
class DefaultValue<void> {
 public:
300
  static bool Exists() { return true; }
301
302
303
304
305
  static void Get() {}
};

// Points to the user-set default value for type T.
template <typename T>
306
typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
307
308
309

// Points to the user-set default value for type T&.
template <typename T>
310
T* DefaultValue<T&>::address_ = nullptr;
311
312
313
314
315
316
317
318

// 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;

319
  ActionInterface() {}
320
321
322
323
324
325
326
327
328
  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:
329
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
330
331
332
333
334
};

// 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
335
// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
336
337
338
339
340
// 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
341
342
343
344
345
346
347
348
349
350
351
352
353
  // 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)...));
    }
  };

354
355
356
357
358
359
 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
360
  Action() {}
361

Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
362
363
364
365
366
367
368
  // 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
369

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

374
375
  // 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
376
  // to Func's and Func's return type can be implicitly converted to F's.
377
  template <typename Func>
Abseil Team's avatar
Abseil Team committed
378
  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
379

380
  // Returns true if and only if this is the DoDefault() action.
Abseil Team's avatar
Abseil Team committed
381
  bool IsDoDefault() const { return fun_ == nullptr; }
382
383
384
385
386
387
388

  // 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
389
390
391
392
  Result Perform(ArgumentTuple args) const {
    if (IsDoDefault()) {
      internal::IllegalDoDefault(__FILE__, __LINE__);
    }
Abseil Team's avatar
Abseil Team committed
393
    return internal::Apply(fun_, ::std::move(args));
394
  }
395

396
 private:
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
397
398
399
  template <typename G>
  friend class Action;

400
  // fun_ is an empty function if and only if this is the DoDefault() action.
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
401
  ::std::function<F> fun_;
402
403
404
405
406
407
408
409
410
411
412
413
414
415
};

// 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
416
//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
//     }
//     ...
//   };
//
// 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_));
  }
434

435
436
437
438
439
440
441
442
443
 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
444
    Result Perform(const ArgumentTuple& args) override {
445
446
447
448
449
      return impl_.template Perform<Result>(args);
    }

   private:
    Impl impl_;
450
451

    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
452
453
454
  };

  Impl impl_;
455
456

  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
};

// 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 {

480
481
482
483
// 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
484
  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
485
486
487
  T payload;
};

488
489
490
// Implements the polymorphic Return(x) action, which can be used in
// any function that returns the type of x, regardless of the argument
// types.
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
//
// 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
512
513
514
// The real life example of the above scenario happens when an invocation
// of gtl::Container() is passed into Return.
//
515
516
517
518
519
520
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
521
  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
522
523
524
525

  // 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
526
  operator Action<F>() const {  // NOLINT
527
528
529
530
531
532
533
534
535
    // 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;
536
    GTEST_COMPILE_ASSERT_(
537
        !std::is_reference<Result>::value,
538
        use_ReturnRef_instead_of_Return_to_return_a_reference);
Abseil Team's avatar
Abseil Team committed
539
540
    static_assert(!std::is_void<Result>::value,
                  "Can't use Return() on an action expected to return `void`.");
541
    return Action<F>(new Impl<R, F>(value_));
542
  }
543

544
545
 private:
  // Implements the Return(x) action for a particular function type F.
546
  template <typename R_, typename F>
547
548
549
550
551
  class Impl : public ActionInterface<F> {
   public:
    typedef typename Function<F>::Result Result;
    typedef typename Function<F>::ArgumentTuple ArgumentTuple;

552
553
554
555
    // 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
556
    // Result to call.  ImplicitCast_ forces the compiler to convert R to
557
558
    // Result without considering explicit constructors, thus resolving the
    // ambiguity. value_ is then initialized using its copy constructor.
misterg's avatar
misterg committed
559
    explicit Impl(const std::shared_ptr<R>& value)
560
561
        : value_before_cast_(*value),
          value_(ImplicitCast_<Result>(value_before_cast_)) {}
562

Abseil Team's avatar
Abseil Team committed
563
    Result Perform(const ArgumentTuple&) override { return value_; }
564
565

   private:
566
    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
567
                          Result_cannot_be_a_reference_type);
568
569
570
    // We save the value before casting just in case it is being cast to a
    // wrapper type.
    R value_before_cast_;
571
    Result value_;
572

573
    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
574
575
  };

576
577
578
579
580
581
582
583
  // 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
584
    explicit Impl(const std::shared_ptr<R>& wrapper)
585
586
        : performed_(false), wrapper_(wrapper) {}

Abseil Team's avatar
Abseil Team committed
587
    Result Perform(const ArgumentTuple&) override {
588
589
590
      GTEST_CHECK_(!performed_)
          << "A ByMove() action should only be performed once.";
      performed_ = true;
Abseil Team's avatar
Abseil Team committed
591
      return std::move(wrapper_->payload);
592
593
594
595
    }

   private:
    bool performed_;
misterg's avatar
misterg committed
596
    const std::shared_ptr<R> wrapper_;
597
598
599
600

    GTEST_DISALLOW_ASSIGN_(Impl);
  };

misterg's avatar
misterg committed
601
  const std::shared_ptr<R> value_;
602
603

  GTEST_DISALLOW_ASSIGN_(ReturnAction);
604
605
606
607
608
};

// Implements the ReturnNull() action.
class ReturnNullAction {
 public:
609
610
611
  // 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.
612
613
  template <typename Result, typename ArgumentTuple>
  static Result Perform(const ArgumentTuple&) {
614
    return nullptr;
615
616
617
618
619
620
621
622
623
  }
};

// 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
624
    static_assert(std::is_void<Result>::value, "Result should be void.");
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
  }
};

// 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.
645
    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
646
                          use_Return_instead_of_ReturnRef_to_return_a_value);
647
648
    return Action<F>(new Impl<F>(ref_));
  }
649

650
651
652
653
654
655
656
657
658
659
 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
660
    Result Perform(const ArgumentTuple&) override { return ref_; }
661

662
663
   private:
    T& ref_;
664
665

    GTEST_DISALLOW_ASSIGN_(Impl);
666
667
668
  };

  T& ref_;
669
670

  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
671
672
};

673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
// 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_(
692
        std::is_reference<Result>::value,
693
694
695
696
697
698
699
700
701
702
703
704
705
706
        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
707
    Result Perform(const ArgumentTuple&) override { return value_; }
708
709
710
711
712
713
714
715
716
717
718
719

   private:
    T value_;

    GTEST_DISALLOW_ASSIGN_(Impl);
  };

  const T value_;

  GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction);
};

Abseil Team's avatar
Abseil Team committed
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
// 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>();
};

750
751
752
753
754
755
// 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
756
  operator Action<F>() const { return Action<F>(); }  // NOLINT
757
758
759
760
761
762
763
764
765
766
};

// 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>
767
  void Perform(const ArgumentTuple& /* args */) const {
768
769
    *ptr_ = value_;
  }
770

771
772
773
 private:
  T1* const ptr_;
  const T2 value_;
774
775

  GTEST_DISALLOW_ASSIGN_(AssignAction);
776
777
};

778
#if !GTEST_OS_WINDOWS_MOBILE
779

780
781
782
783
784
785
786
787
788
// 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>
789
  Result Perform(const ArgumentTuple& /* args */) const {
790
791
792
    errno = errno_;
    return result_;
  }
793

794
795
796
 private:
  const int errno_;
  const T result_;
797
798

  GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
799
800
};

801
#endif  // !GTEST_OS_WINDOWS_MOBILE
802

803
// Implements the SetArgumentPointee<N>(x) action for any function
Abseil Team's avatar
Abseil Team committed
804
805
806
807
// 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;
808

Abseil Team's avatar
Abseil Team committed
809
810
811
  template <typename... Args>
  void operator()(const Args&... args) const {
    *::std::get<N>(std::tie(args...)) = value;
812
813
814
  }
};

Abseil Team's avatar
Abseil Team committed
815
816
817
818
819
820
821
822
823
824
825
826
827
// 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)...);
  }
};

828
829
830
// 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
831
// Action<F> as long as f's type is compatible with F.
832
template <typename FunctionImpl>
Abseil Team's avatar
Abseil Team committed
833
834
struct InvokeWithoutArgsAction {
  FunctionImpl function_impl;
835
836
837

  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
  // compatible with f.
Abseil Team's avatar
Abseil Team committed
838
839
840
841
  template <typename... Args>
  auto operator()(const Args&...) -> decltype(function_impl()) {
    return function_impl();
  }
842
843
844
845
};

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

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

Abseil Team's avatar
Abseil Team committed
852
853
854
  template <typename... Args>
  ReturnType operator()(const Args&...) const {
    return (obj_ptr->*method_ptr)();
Gennadiy Civil's avatar
merging  
Gennadiy Civil committed
855
856
857
  }
};

858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
// 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
877
    static_assert(std::is_void<Result>::value, "Result type should be void.");
878
879
880

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

882
883
884
885
886
887
888
889
890
 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
891
    void Perform(const ArgumentTuple& args) override {
892
893
894
895
896
897
898
899
900
901
902
      // 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_;
903
904

    GTEST_DISALLOW_ASSIGN_(Impl);
905
906
907
  };

  const A action_;
908
909

  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
910
911
};

Abseil Team's avatar
Abseil Team committed
912
913
914
915
916
917
918
919
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
920
921
    using TupleType = std::tuple<Args...>;
    Action<R(typename std::tuple_element<I, TupleType>::type...)>
Abseil Team's avatar
Abseil Team committed
922
923
924
925
926
927
928
929
930
        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
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
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)};
  }
};

960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
}  // 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
978
//   EXPECT_CALL(mock, Foo("abc", _, _))
979
//       .WillOnce(Invoke(DistanceToOriginWithLabel));
Hector Dearman's avatar
Hector Dearman committed
980
//   EXPECT_CALL(mock, Bar(5, _, _))
981
982
983
984
985
986
987
988
989
//       .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
990
991
//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
992
993
typedef internal::IgnoredValue Unused;

Abseil Team's avatar
Abseil Team committed
994
995
996
997
998
999
1000
1001
// 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
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
// 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)};
}

1033
1034
1035
1036
1037
// 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
1038
  return internal::ReturnAction<R>(std::move(value));
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
}

// 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);
}

1057
// Prevent using ReturnRef on reference to temporary.
1058
template <typename R, R* = nullptr>
1059
1060
internal::ReturnRefAction<R> ReturnRef(R&&) = delete;

1061
1062
1063
1064
1065
1066
1067
1068
// 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);
}

1069
1070
1071
1072
1073
1074
// 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
1075
  return internal::ByMoveWrapper<R>(std::move(x));
1076
1077
}

Abseil Team's avatar
Abseil Team committed
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
// 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));
}

1095
1096
1097
1098
1099
1100
1101
1102
// 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
1103
1104
internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
  return {std::move(value)};
1105
1106
}

1107
1108
// The following version is DEPRECATED.
template <size_t N, typename T>
Abseil Team's avatar
Abseil Team committed
1109
1110
internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
  return {std::move(value)};
1111
1112
1113
1114
1115
1116
1117
1118
}

// 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));
}

1119
#if !GTEST_OS_WINDOWS_MOBILE
1120

1121
1122
1123
1124
1125
1126
1127
1128
// 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));
}

1129
#endif  // !GTEST_OS_WINDOWS_MOBILE
1130

Abseil Team's avatar
Abseil Team committed
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
// 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};
}
1149
1150
1151

// Creates an action that invokes 'function_impl' with no argument.
template <typename FunctionImpl>
Abseil Team's avatar
Abseil Team committed
1152
internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
1153
InvokeWithoutArgs(FunctionImpl function_impl) {
Abseil Team's avatar
Abseil Team committed
1154
  return {std::move(function_impl)};
1155
1156
1157
1158
1159
}

// 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
1160
1161
1162
internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
    Class* obj_ptr, MethodPtr method_ptr) {
  return {obj_ptr, method_ptr};
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
}

// 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);
}

1173
1174
1175
1176
1177
1178
1179
// 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
1180
1181
1182
//
// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
// However, it may still be used for consistency with ByMove().
1183
template <typename T>
Abseil Team's avatar
Abseil Team committed
1184
1185
inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
  return ::std::reference_wrapper<T>(l_value);
1186
1187
}

Abseil Team's avatar
Abseil Team committed
1188
1189
1190
1191
1192
1193
1194
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
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
1226
1227
1228
1229
1230
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
// 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
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
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
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293

#define GMOCK_INTERNAL_ARG_UNUSED(N, data, el) \
  , const arg##N##_type& arg##N GTEST_ATTRIBUTE_UNUSED_
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                 \
  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

#define GMOCK_INTERNAL_ARG(N, data, el) , const arg##N##_type& arg##N
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)

#define GMOCK_INTERNAL_TEMPLATE_ARG(N, data, el) , typename arg##N##_type
#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))

Abseil Team's avatar
Abseil Team committed
1294
1295
}  // namespace internal

1296
1297
}  // namespace testing

misterg's avatar
misterg committed
1298
1299
1300
1301
1302
#ifdef _MSC_VER
# pragma warning(pop)
#endif


1303
#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_