Sacado Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
gmock-spec-builders.h
Go to the documentation of this file.
1// Copyright 2007, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31// Google Mock - a framework for writing C++ mock classes.
32//
33// This file implements the ON_CALL() and EXPECT_CALL() macros.
34//
35// A user can use the ON_CALL() macro to specify the default action of
36// a mock method. The syntax is:
37//
38// ON_CALL(mock_object, Method(argument-matchers))
39// .With(multi-argument-matcher)
40// .WillByDefault(action);
41//
42// where the .With() clause is optional.
43//
44// A user can use the EXPECT_CALL() macro to specify an expectation on
45// a mock method. The syntax is:
46//
47// EXPECT_CALL(mock_object, Method(argument-matchers))
48// .With(multi-argument-matchers)
49// .Times(cardinality)
50// .InSequence(sequences)
51// .After(expectations)
52// .WillOnce(action)
53// .WillRepeatedly(action)
54// .RetiresOnSaturation();
55//
56// where all clauses are optional, and .InSequence()/.After()/
57// .WillOnce() can appear any number of times.
58
59// GOOGLETEST_CM0002 DO NOT DELETE
60
61#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
62#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
63
64#include <functional>
65#include <map>
66#include <memory>
67#include <set>
68#include <sstream>
69#include <string>
70#include <type_traits>
71#include <utility>
72#include <vector>
73#include "gmock/gmock-actions.h"
78#include "gtest/gtest.h"
79
80#if GTEST_HAS_EXCEPTIONS
81# include <stdexcept> // NOLINT
82#endif
83
85/* class A needs to have dll-interface to be used by clients of class B */)
86
87namespace testing {
88
89// An abstract handle of an expectation.
90class Expectation;
91
92// A set of expectation handles.
93class ExpectationSet;
94
95// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
96// and MUST NOT BE USED IN USER CODE!!!
97namespace internal {
98
99// Implements a mock function.
100template <typename F> class FunctionMocker;
101
102// Base class for expectations.
103class ExpectationBase;
104
105// Implements an expectation.
106template <typename F> class TypedExpectation;
107
108// Helper class for testing the Expectation class template.
109class ExpectationTester;
110
111// Protects the mock object registry (in class Mock), all function
112// mockers, and all expectations.
113//
114// The reason we don't use more fine-grained protection is: when a
115// mock function Foo() is called, it needs to consult its expectations
116// to see which one should be picked. If another thread is allowed to
117// call a mock function (either Foo() or a different one) at the same
118// time, it could affect the "retired" attributes of Foo()'s
119// expectations when InSequence() is used, and thus affect which
120// expectation gets picked. Therefore, we sequence all mock function
121// calls to ensure the integrity of the mock objects' states.
123
124// Untyped base class for ActionResultHolder<R>.
125class UntypedActionResultHolderBase;
126
127// Abstract base class of FunctionMocker. This is the
128// type-agnostic part of the function mocker interface. Its pure
129// virtual methods are implemented by FunctionMocker.
130class GTEST_API_ UntypedFunctionMockerBase {
131 public:
132 UntypedFunctionMockerBase();
133 virtual ~UntypedFunctionMockerBase();
134
135 // Verifies that all expectations on this mock function have been
136 // satisfied. Reports one or more Google Test non-fatal failures
137 // and returns false if not.
138 bool VerifyAndClearExpectationsLocked()
139 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
140
141 // Clears the ON_CALL()s set on this mock function.
142 virtual void ClearDefaultActionsLocked()
143 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
144
145 // In all of the following Untyped* functions, it's the caller's
146 // responsibility to guarantee the correctness of the arguments'
147 // types.
148
149 // Performs the default action with the given arguments and returns
150 // the action's result. The call description string will be used in
151 // the error message to describe the call in the case the default
152 // action fails.
153 // L = *
154 virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
155 void* untyped_args, const std::string& call_description) const = 0;
156
157 // Performs the given action with the given arguments and returns
158 // the action's result.
159 // L = *
160 virtual UntypedActionResultHolderBase* UntypedPerformAction(
161 const void* untyped_action, void* untyped_args) const = 0;
162
163 // Writes a message that the call is uninteresting (i.e. neither
164 // explicitly expected nor explicitly unexpected) to the given
165 // ostream.
166 virtual void UntypedDescribeUninterestingCall(
167 const void* untyped_args,
168 ::std::ostream* os) const
169 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
170
171 // Returns the expectation that matches the given function arguments
172 // (or NULL is there's no match); when a match is found,
173 // untyped_action is set to point to the action that should be
174 // performed (or NULL if the action is "do default"), and
175 // is_excessive is modified to indicate whether the call exceeds the
176 // expected number.
177 virtual const ExpectationBase* UntypedFindMatchingExpectation(
178 const void* untyped_args,
179 const void** untyped_action, bool* is_excessive,
180 ::std::ostream* what, ::std::ostream* why)
181 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
182
183 // Prints the given function arguments to the ostream.
184 virtual void UntypedPrintArgs(const void* untyped_args,
185 ::std::ostream* os) const = 0;
186
187 // Sets the mock object this mock method belongs to, and registers
188 // this information in the global mock registry. Will be called
189 // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
190 // method.
191 void RegisterOwner(const void* mock_obj)
192 GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
193
194 // Sets the mock object this mock method belongs to, and sets the
195 // name of the mock function. Will be called upon each invocation
196 // of this mock function.
197 void SetOwnerAndName(const void* mock_obj, const char* name)
198 GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
199
200 // Returns the mock object this mock method belongs to. Must be
201 // called after RegisterOwner() or SetOwnerAndName() has been
202 // called.
203 const void* MockObject() const
204 GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
205
206 // Returns the name of this mock method. Must be called after
207 // SetOwnerAndName() has been called.
208 const char* Name() const
209 GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
210
211 // Returns the result of invoking this mock function with the given
212 // arguments. This function can be safely called from multiple
213 // threads concurrently. The caller is responsible for deleting the
214 // result.
215 UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
216 GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
217
218 protected:
219 typedef std::vector<const void*> UntypedOnCallSpecs;
220
221 using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
222
223 // Returns an Expectation object that references and co-owns exp,
224 // which must be an expectation on this mock function.
225 Expectation GetHandleOf(ExpectationBase* exp);
226
227 // Address of the mock object this mock method belongs to. Only
228 // valid after this mock method has been called or
229 // ON_CALL/EXPECT_CALL has been invoked on it.
230 const void* mock_obj_; // Protected by g_gmock_mutex.
231
232 // Name of the function being mocked. Only valid after this mock
233 // method has been called.
234 const char* name_; // Protected by g_gmock_mutex.
235
236 // All default action specs for this function mocker.
237 UntypedOnCallSpecs untyped_on_call_specs_;
238
239 // All expectations for this function mocker.
240 //
241 // It's undefined behavior to interleave expectations (EXPECT_CALLs
242 // or ON_CALLs) and mock function calls. Also, the order of
243 // expectations is important. Therefore it's a logic race condition
244 // to read/write untyped_expectations_ concurrently. In order for
245 // tools like tsan to catch concurrent read/write accesses to
246 // untyped_expectations, we deliberately leave accesses to it
247 // unprotected.
248 UntypedExpectations untyped_expectations_;
249}; // class UntypedFunctionMockerBase
250
251// Untyped base class for OnCallSpec<F>.
252class UntypedOnCallSpecBase {
253 public:
254 // The arguments are the location of the ON_CALL() statement.
255 UntypedOnCallSpecBase(const char* a_file, int a_line)
256 : file_(a_file), line_(a_line), last_clause_(kNone) {}
257
258 // Where in the source file was the default action spec defined?
259 const char* file() const { return file_; }
260 int line() const { return line_; }
261
262 protected:
263 // Gives each clause in the ON_CALL() statement a name.
264 enum Clause {
265 // Do not change the order of the enum members! The run-time
266 // syntax checking relies on it.
267 kNone,
268 kWith,
269 kWillByDefault
270 };
271
272 // Asserts that the ON_CALL() statement has a certain property.
273 void AssertSpecProperty(bool property,
274 const std::string& failure_message) const {
275 Assert(property, file_, line_, failure_message);
276 }
277
278 // Expects that the ON_CALL() statement has a certain property.
279 void ExpectSpecProperty(bool property,
280 const std::string& failure_message) const {
281 Expect(property, file_, line_, failure_message);
282 }
283
284 const char* file_;
285 int line_;
286
287 // The last clause in the ON_CALL() statement as seen so far.
288 // Initially kNone and changes as the statement is parsed.
289 Clause last_clause_;
290}; // class UntypedOnCallSpecBase
291
292// This template class implements an ON_CALL spec.
293template <typename F>
294class OnCallSpec : public UntypedOnCallSpecBase {
295 public:
296 typedef typename Function<F>::ArgumentTuple ArgumentTuple;
297 typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
298
299 // Constructs an OnCallSpec object from the information inside
300 // the parenthesis of an ON_CALL() statement.
301 OnCallSpec(const char* a_file, int a_line,
302 const ArgumentMatcherTuple& matchers)
303 : UntypedOnCallSpecBase(a_file, a_line),
304 matchers_(matchers),
305 // By default, extra_matcher_ should match anything. However,
306 // we cannot initialize it with _ as that causes ambiguity between
307 // Matcher's copy and move constructor for some argument types.
308 extra_matcher_(A<const ArgumentTuple&>()) {}
309
310 // Implements the .With() clause.
311 OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
312 // Makes sure this is called at most once.
313 ExpectSpecProperty(last_clause_ < kWith,
314 ".With() cannot appear "
315 "more than once in an ON_CALL().");
316 last_clause_ = kWith;
317
318 extra_matcher_ = m;
319 return *this;
320 }
321
322 // Implements the .WillByDefault() clause.
323 OnCallSpec& WillByDefault(const Action<F>& action) {
324 ExpectSpecProperty(last_clause_ < kWillByDefault,
325 ".WillByDefault() must appear "
326 "exactly once in an ON_CALL().");
327 last_clause_ = kWillByDefault;
328
329 ExpectSpecProperty(!action.IsDoDefault(),
330 "DoDefault() cannot be used in ON_CALL().");
331 action_ = action;
332 return *this;
333 }
334
335 // Returns true if and only if the given arguments match the matchers.
336 bool Matches(const ArgumentTuple& args) const {
337 return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
338 }
339
340 // Returns the action specified by the user.
341 const Action<F>& GetAction() const {
342 AssertSpecProperty(last_clause_ == kWillByDefault,
343 ".WillByDefault() must appear exactly "
344 "once in an ON_CALL().");
345 return action_;
346 }
347
348 private:
349 // The information in statement
350 //
351 // ON_CALL(mock_object, Method(matchers))
352 // .With(multi-argument-matcher)
353 // .WillByDefault(action);
354 //
355 // is recorded in the data members like this:
356 //
357 // source file that contains the statement => file_
358 // line number of the statement => line_
359 // matchers => matchers_
360 // multi-argument-matcher => extra_matcher_
361 // action => action_
362 ArgumentMatcherTuple matchers_;
363 Matcher<const ArgumentTuple&> extra_matcher_;
364 Action<F> action_;
365}; // class OnCallSpec
366
367// Possible reactions on uninteresting calls.
368enum CallReaction {
369 kAllow,
370 kWarn,
371 kFail,
372};
373
374} // namespace internal
375
376// Utilities for manipulating mock objects.
377class GTEST_API_ Mock {
378 public:
379 // The following public methods can be called concurrently.
380
381 // Tells Google Mock to ignore mock_obj when checking for leaked
382 // mock objects.
383 static void AllowLeak(const void* mock_obj)
384 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
385
386 // Verifies and clears all expectations on the given mock object.
387 // If the expectations aren't satisfied, generates one or more
388 // Google Test non-fatal failures and returns false.
389 static bool VerifyAndClearExpectations(void* mock_obj)
390 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
391
392 // Verifies all expectations on the given mock object and clears its
393 // default actions and expectations. Returns true if and only if the
394 // verification was successful.
395 static bool VerifyAndClear(void* mock_obj)
396 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
397
398 // Returns whether the mock was created as a naggy mock (default)
399 static bool IsNaggy(void* mock_obj)
400 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
401 // Returns whether the mock was created as a nice mock
402 static bool IsNice(void* mock_obj)
403 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
404 // Returns whether the mock was created as a strict mock
405 static bool IsStrict(void* mock_obj)
406 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
407
408 private:
409 friend class internal::UntypedFunctionMockerBase;
410
411 // Needed for a function mocker to register itself (so that we know
412 // how to clear a mock object).
413 template <typename F>
414 friend class internal::FunctionMocker;
415
416 template <typename M>
417 friend class NiceMock;
418
419 template <typename M>
420 friend class NaggyMock;
421
422 template <typename M>
423 friend class StrictMock;
424
425 // Tells Google Mock to allow uninteresting calls on the given mock
426 // object.
427 static void AllowUninterestingCalls(const void* mock_obj)
428 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
429
430 // Tells Google Mock to warn the user about uninteresting calls on
431 // the given mock object.
432 static void WarnUninterestingCalls(const void* mock_obj)
433 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
434
435 // Tells Google Mock to fail uninteresting calls on the given mock
436 // object.
437 static void FailUninterestingCalls(const void* mock_obj)
438 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
439
440 // Tells Google Mock the given mock object is being destroyed and
441 // its entry in the call-reaction table should be removed.
442 static void UnregisterCallReaction(const void* mock_obj)
443 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
444
445 // Returns the reaction Google Mock will have on uninteresting calls
446 // made on the given mock object.
447 static internal::CallReaction GetReactionOnUninterestingCalls(
448 const void* mock_obj)
449 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
450
451 // Verifies that all expectations on the given mock object have been
452 // satisfied. Reports one or more Google Test non-fatal failures
453 // and returns false if not.
454 static bool VerifyAndClearExpectationsLocked(void* mock_obj)
455 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
456
457 // Clears all ON_CALL()s set on the given mock object.
458 static void ClearDefaultActionsLocked(void* mock_obj)
459 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
460
461 // Registers a mock object and a mock method it owns.
462 static void Register(
463 const void* mock_obj,
464 internal::UntypedFunctionMockerBase* mocker)
465 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
466
467 // Tells Google Mock where in the source code mock_obj is used in an
468 // ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this
469 // information helps the user identify which object it is.
470 static void RegisterUseByOnCallOrExpectCall(
471 const void* mock_obj, const char* file, int line)
472 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
473
474 // Unregisters a mock method; removes the owning mock object from
475 // the registry when the last mock method associated with it has
476 // been unregistered. This is called only in the destructor of
477 // FunctionMocker.
478 static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
479 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
480}; // class Mock
481
482// An abstract handle of an expectation. Useful in the .After()
483// clause of EXPECT_CALL() for setting the (partial) order of
484// expectations. The syntax:
485//
486// Expectation e1 = EXPECT_CALL(...)...;
487// EXPECT_CALL(...).After(e1)...;
488//
489// sets two expectations where the latter can only be matched after
490// the former has been satisfied.
491//
492// Notes:
493// - This class is copyable and has value semantics.
494// - Constness is shallow: a const Expectation object itself cannot
495// be modified, but the mutable methods of the ExpectationBase
496// object it references can be called via expectation_base().
497
498class GTEST_API_ Expectation {
499 public:
500 // Constructs a null object that doesn't reference any expectation.
501 Expectation();
502 Expectation(Expectation&&) = default;
503 Expectation(const Expectation&) = default;
504 Expectation& operator=(Expectation&&) = default;
505 Expectation& operator=(const Expectation&) = default;
506 ~Expectation();
507
508 // This single-argument ctor must not be explicit, in order to support the
509 // Expectation e = EXPECT_CALL(...);
510 // syntax.
511 //
512 // A TypedExpectation object stores its pre-requisites as
513 // Expectation objects, and needs to call the non-const Retire()
514 // method on the ExpectationBase objects they reference. Therefore
515 // Expectation must receive a *non-const* reference to the
516 // ExpectationBase object.
517 Expectation(internal::ExpectationBase& exp); // NOLINT
518
519 // The compiler-generated copy ctor and operator= work exactly as
520 // intended, so we don't need to define our own.
521
522 // Returns true if and only if rhs references the same expectation as this
523 // object does.
524 bool operator==(const Expectation& rhs) const {
525 return expectation_base_ == rhs.expectation_base_;
526 }
527
528 bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
529
530 private:
531 friend class ExpectationSet;
532 friend class Sequence;
533 friend class ::testing::internal::ExpectationBase;
534 friend class ::testing::internal::UntypedFunctionMockerBase;
535
536 template <typename F>
537 friend class ::testing::internal::FunctionMocker;
538
539 template <typename F>
540 friend class ::testing::internal::TypedExpectation;
541
542 // This comparator is needed for putting Expectation objects into a set.
543 class Less {
544 public:
545 bool operator()(const Expectation& lhs, const Expectation& rhs) const {
546 return lhs.expectation_base_.get() < rhs.expectation_base_.get();
547 }
548 };
549
550 typedef ::std::set<Expectation, Less> Set;
551
552 Expectation(
553 const std::shared_ptr<internal::ExpectationBase>& expectation_base);
554
555 // Returns the expectation this object references.
556 const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
557 return expectation_base_;
558 }
559
560 // A shared_ptr that co-owns the expectation this handle references.
561 std::shared_ptr<internal::ExpectationBase> expectation_base_;
562};
563
564// A set of expectation handles. Useful in the .After() clause of
565// EXPECT_CALL() for setting the (partial) order of expectations. The
566// syntax:
567//
568// ExpectationSet es;
569// es += EXPECT_CALL(...)...;
570// es += EXPECT_CALL(...)...;
571// EXPECT_CALL(...).After(es)...;
572//
573// sets three expectations where the last one can only be matched
574// after the first two have both been satisfied.
575//
576// This class is copyable and has value semantics.
577class ExpectationSet {
578 public:
579 // A bidirectional iterator that can read a const element in the set.
580 typedef Expectation::Set::const_iterator const_iterator;
581
582 // An object stored in the set. This is an alias of Expectation.
583 typedef Expectation::Set::value_type value_type;
584
585 // Constructs an empty set.
586 ExpectationSet() {}
587
588 // This single-argument ctor must not be explicit, in order to support the
589 // ExpectationSet es = EXPECT_CALL(...);
590 // syntax.
591 ExpectationSet(internal::ExpectationBase& exp) { // NOLINT
592 *this += Expectation(exp);
593 }
594
595 // This single-argument ctor implements implicit conversion from
596 // Expectation and thus must not be explicit. This allows either an
597 // Expectation or an ExpectationSet to be used in .After().
598 ExpectationSet(const Expectation& e) { // NOLINT
599 *this += e;
600 }
601
602 // The compiler-generator ctor and operator= works exactly as
603 // intended, so we don't need to define our own.
604
605 // Returns true if and only if rhs contains the same set of Expectation
606 // objects as this does.
607 bool operator==(const ExpectationSet& rhs) const {
608 return expectations_ == rhs.expectations_;
609 }
610
611 bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
612
613 // Implements the syntax
614 // expectation_set += EXPECT_CALL(...);
615 ExpectationSet& operator+=(const Expectation& e) {
616 expectations_.insert(e);
617 return *this;
618 }
619
620 int size() const { return static_cast<int>(expectations_.size()); }
621
622 const_iterator begin() const { return expectations_.begin(); }
623 const_iterator end() const { return expectations_.end(); }
624
625 private:
626 Expectation::Set expectations_;
627};
628
629
630// Sequence objects are used by a user to specify the relative order
631// in which the expectations should match. They are copyable (we rely
632// on the compiler-defined copy constructor and assignment operator).
633class GTEST_API_ Sequence {
634 public:
635 // Constructs an empty sequence.
636 Sequence() : last_expectation_(new Expectation) {}
637
638 // Adds an expectation to this sequence. The caller must ensure
639 // that no other thread is accessing this Sequence object.
640 void AddExpectation(const Expectation& expectation) const;
641
642 private:
643 // The last expectation in this sequence.
644 std::shared_ptr<Expectation> last_expectation_;
645}; // class Sequence
646
647// An object of this type causes all EXPECT_CALL() statements
648// encountered in its scope to be put in an anonymous sequence. The
649// work is done in the constructor and destructor. You should only
650// create an InSequence object on the stack.
651//
652// The sole purpose for this class is to support easy definition of
653// sequential expectations, e.g.
654//
655// {
656// InSequence dummy; // The name of the object doesn't matter.
657//
658// // The following expectations must match in the order they appear.
659// EXPECT_CALL(a, Bar())...;
660// EXPECT_CALL(a, Baz())...;
661// ...
662// EXPECT_CALL(b, Xyz())...;
663// }
664//
665// You can create InSequence objects in multiple threads, as long as
666// they are used to affect different mock objects. The idea is that
667// each thread can create and set up its own mocks as if it's the only
668// thread. However, for clarity of your tests we recommend you to set
669// up mocks in the main thread unless you have a good reason not to do
670// so.
671class GTEST_API_ InSequence {
672 public:
673 InSequence();
674 ~InSequence();
675 private:
676 bool sequence_created_;
677
678 GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence); // NOLINT
680
681namespace internal {
682
683// Points to the implicit sequence introduced by a living InSequence
684// object (if any) in the current thread or NULL.
685GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
686
687// Base class for implementing expectations.
688//
689// There are two reasons for having a type-agnostic base class for
690// Expectation:
691//
692// 1. We need to store collections of expectations of different
693// types (e.g. all pre-requisites of a particular expectation, all
694// expectations in a sequence). Therefore these expectation objects
695// must share a common base class.
696//
697// 2. We can avoid binary code bloat by moving methods not depending
698// on the template argument of Expectation to the base class.
699//
700// This class is internal and mustn't be used by user code directly.
701class GTEST_API_ ExpectationBase {
702 public:
703 // source_text is the EXPECT_CALL(...) source that created this Expectation.
704 ExpectationBase(const char* file, int line, const std::string& source_text);
705
706 virtual ~ExpectationBase();
707
708 // Where in the source file was the expectation spec defined?
709 const char* file() const { return file_; }
710 int line() const { return line_; }
711 const char* source_text() const { return source_text_.c_str(); }
712 // Returns the cardinality specified in the expectation spec.
713 const Cardinality& cardinality() const { return cardinality_; }
714
715 // Describes the source file location of this expectation.
716 void DescribeLocationTo(::std::ostream* os) const {
717 *os << FormatFileLocation(file(), line()) << " ";
718 }
719
720 // Describes how many times a function call matching this
721 // expectation has occurred.
722 void DescribeCallCountTo(::std::ostream* os) const
723 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
724
725 // If this mock method has an extra matcher (i.e. .With(matcher)),
726 // describes it to the ostream.
727 virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
728
729 protected:
730 friend class ::testing::Expectation;
731 friend class UntypedFunctionMockerBase;
732
733 enum Clause {
734 // Don't change the order of the enum members!
735 kNone,
736 kWith,
737 kTimes,
738 kInSequence,
739 kAfter,
740 kWillOnce,
741 kWillRepeatedly,
742 kRetiresOnSaturation
743 };
744
745 typedef std::vector<const void*> UntypedActions;
746
747 // Returns an Expectation object that references and co-owns this
748 // expectation.
749 virtual Expectation GetHandle() = 0;
750
751 // Asserts that the EXPECT_CALL() statement has the given property.
752 void AssertSpecProperty(bool property,
753 const std::string& failure_message) const {
754 Assert(property, file_, line_, failure_message);
755 }
756
757 // Expects that the EXPECT_CALL() statement has the given property.
758 void ExpectSpecProperty(bool property,
759 const std::string& failure_message) const {
760 Expect(property, file_, line_, failure_message);
761 }
762
763 // Explicitly specifies the cardinality of this expectation. Used
764 // by the subclasses to implement the .Times() clause.
765 void SpecifyCardinality(const Cardinality& cardinality);
766
767 // Returns true if and only if the user specified the cardinality
768 // explicitly using a .Times().
769 bool cardinality_specified() const { return cardinality_specified_; }
770
771 // Sets the cardinality of this expectation spec.
772 void set_cardinality(const Cardinality& a_cardinality) {
773 cardinality_ = a_cardinality;
774 }
775
776 // The following group of methods should only be called after the
777 // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
778 // the current thread.
779
780 // Retires all pre-requisites of this expectation.
781 void RetireAllPreRequisites()
782 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
783
784 // Returns true if and only if this expectation is retired.
785 bool is_retired() const
786 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
787 g_gmock_mutex.AssertHeld();
788 return retired_;
789 }
790
791 // Retires this expectation.
792 void Retire()
793 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
794 g_gmock_mutex.AssertHeld();
795 retired_ = true;
796 }
797
798 // Returns true if and only if this expectation is satisfied.
799 bool IsSatisfied() const
800 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
801 g_gmock_mutex.AssertHeld();
802 return cardinality().IsSatisfiedByCallCount(call_count_);
803 }
804
805 // Returns true if and only if this expectation is saturated.
806 bool IsSaturated() const
807 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
808 g_gmock_mutex.AssertHeld();
809 return cardinality().IsSaturatedByCallCount(call_count_);
810 }
811
812 // Returns true if and only if this expectation is over-saturated.
813 bool IsOverSaturated() const
814 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
815 g_gmock_mutex.AssertHeld();
816 return cardinality().IsOverSaturatedByCallCount(call_count_);
817 }
818
819 // Returns true if and only if all pre-requisites of this expectation are
820 // satisfied.
821 bool AllPrerequisitesAreSatisfied() const
822 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
823
824 // Adds unsatisfied pre-requisites of this expectation to 'result'.
825 void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
826 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
827
828 // Returns the number this expectation has been invoked.
829 int call_count() const
830 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
831 g_gmock_mutex.AssertHeld();
832 return call_count_;
833 }
834
835 // Increments the number this expectation has been invoked.
836 void IncrementCallCount()
837 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
838 g_gmock_mutex.AssertHeld();
839 call_count_++;
840 }
841
842 // Checks the action count (i.e. the number of WillOnce() and
843 // WillRepeatedly() clauses) against the cardinality if this hasn't
844 // been done before. Prints a warning if there are too many or too
845 // few actions.
846 void CheckActionCountIfNotDone() const
847 GTEST_LOCK_EXCLUDED_(mutex_);
848
849 friend class ::testing::Sequence;
850 friend class ::testing::internal::ExpectationTester;
851
852 template <typename Function>
853 friend class TypedExpectation;
854
855 // Implements the .Times() clause.
856 void UntypedTimes(const Cardinality& a_cardinality);
857
858 // This group of fields are part of the spec and won't change after
859 // an EXPECT_CALL() statement finishes.
860 const char* file_; // The file that contains the expectation.
861 int line_; // The line number of the expectation.
862 const std::string source_text_; // The EXPECT_CALL(...) source text.
863 // True if and only if the cardinality is specified explicitly.
864 bool cardinality_specified_;
865 Cardinality cardinality_; // The cardinality of the expectation.
866 // The immediate pre-requisites (i.e. expectations that must be
867 // satisfied before this expectation can be matched) of this
868 // expectation. We use std::shared_ptr in the set because we want an
869 // Expectation object to be co-owned by its FunctionMocker and its
870 // successors. This allows multiple mock objects to be deleted at
871 // different times.
872 ExpectationSet immediate_prerequisites_;
873
874 // This group of fields are the current state of the expectation,
875 // and can change as the mock function is called.
876 int call_count_; // How many times this expectation has been invoked.
877 bool retired_; // True if and only if this expectation has retired.
878 UntypedActions untyped_actions_;
879 bool extra_matcher_specified_;
880 bool repeated_action_specified_; // True if a WillRepeatedly() was specified.
881 bool retires_on_saturation_;
882 Clause last_clause_;
883 mutable bool action_count_checked_; // Under mutex_.
884 mutable Mutex mutex_; // Protects action_count_checked_.
885}; // class ExpectationBase
886
887// Impements an expectation for the given function type.
888template <typename F>
889class TypedExpectation : public ExpectationBase {
890 public:
891 typedef typename Function<F>::ArgumentTuple ArgumentTuple;
892 typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
893 typedef typename Function<F>::Result Result;
894
895 TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
896 const std::string& a_source_text,
897 const ArgumentMatcherTuple& m)
898 : ExpectationBase(a_file, a_line, a_source_text),
899 owner_(owner),
900 matchers_(m),
901 // By default, extra_matcher_ should match anything. However,
902 // we cannot initialize it with _ as that causes ambiguity between
903 // Matcher's copy and move constructor for some argument types.
904 extra_matcher_(A<const ArgumentTuple&>()),
905 repeated_action_(DoDefault()) {}
906
907 ~TypedExpectation() override {
908 // Check the validity of the action count if it hasn't been done
909 // yet (for example, if the expectation was never used).
910 CheckActionCountIfNotDone();
911 for (UntypedActions::const_iterator it = untyped_actions_.begin();
912 it != untyped_actions_.end(); ++it) {
913 delete static_cast<const Action<F>*>(*it);
914 }
915 }
916
917 // Implements the .With() clause.
918 TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
919 if (last_clause_ == kWith) {
920 ExpectSpecProperty(false,
921 ".With() cannot appear "
922 "more than once in an EXPECT_CALL().");
923 } else {
924 ExpectSpecProperty(last_clause_ < kWith,
925 ".With() must be the first "
926 "clause in an EXPECT_CALL().");
927 }
928 last_clause_ = kWith;
929
930 extra_matcher_ = m;
931 extra_matcher_specified_ = true;
932 return *this;
933 }
934
935 // Implements the .Times() clause.
936 TypedExpectation& Times(const Cardinality& a_cardinality) {
937 ExpectationBase::UntypedTimes(a_cardinality);
938 return *this;
939 }
940
941 // Implements the .Times() clause.
942 TypedExpectation& Times(int n) {
943 return Times(Exactly(n));
944 }
945
946 // Implements the .InSequence() clause.
947 TypedExpectation& InSequence(const Sequence& s) {
948 ExpectSpecProperty(last_clause_ <= kInSequence,
949 ".InSequence() cannot appear after .After(),"
950 " .WillOnce(), .WillRepeatedly(), or "
951 ".RetiresOnSaturation().");
952 last_clause_ = kInSequence;
953
954 s.AddExpectation(GetHandle());
955 return *this;
956 }
957 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
958 return InSequence(s1).InSequence(s2);
959 }
960 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
961 const Sequence& s3) {
962 return InSequence(s1, s2).InSequence(s3);
963 }
964 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
965 const Sequence& s3, const Sequence& s4) {
966 return InSequence(s1, s2, s3).InSequence(s4);
967 }
968 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
969 const Sequence& s3, const Sequence& s4,
970 const Sequence& s5) {
971 return InSequence(s1, s2, s3, s4).InSequence(s5);
972 }
973
974 // Implements that .After() clause.
975 TypedExpectation& After(const ExpectationSet& s) {
976 ExpectSpecProperty(last_clause_ <= kAfter,
977 ".After() cannot appear after .WillOnce(),"
978 " .WillRepeatedly(), or "
979 ".RetiresOnSaturation().");
980 last_clause_ = kAfter;
981
982 for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
983 immediate_prerequisites_ += *it;
984 }
985 return *this;
986 }
987 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
988 return After(s1).After(s2);
989 }
990 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
991 const ExpectationSet& s3) {
992 return After(s1, s2).After(s3);
993 }
994 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
995 const ExpectationSet& s3, const ExpectationSet& s4) {
996 return After(s1, s2, s3).After(s4);
997 }
998 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
999 const ExpectationSet& s3, const ExpectationSet& s4,
1000 const ExpectationSet& s5) {
1001 return After(s1, s2, s3, s4).After(s5);
1002 }
1003
1004 // Implements the .WillOnce() clause.
1005 TypedExpectation& WillOnce(const Action<F>& action) {
1006 ExpectSpecProperty(last_clause_ <= kWillOnce,
1007 ".WillOnce() cannot appear after "
1008 ".WillRepeatedly() or .RetiresOnSaturation().");
1009 last_clause_ = kWillOnce;
1010
1011 untyped_actions_.push_back(new Action<F>(action));
1012 if (!cardinality_specified()) {
1013 set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
1014 }
1015 return *this;
1016 }
1017
1018 // Implements the .WillRepeatedly() clause.
1019 TypedExpectation& WillRepeatedly(const Action<F>& action) {
1020 if (last_clause_ == kWillRepeatedly) {
1021 ExpectSpecProperty(false,
1022 ".WillRepeatedly() cannot appear "
1023 "more than once in an EXPECT_CALL().");
1024 } else {
1025 ExpectSpecProperty(last_clause_ < kWillRepeatedly,
1026 ".WillRepeatedly() cannot appear "
1027 "after .RetiresOnSaturation().");
1028 }
1029 last_clause_ = kWillRepeatedly;
1030 repeated_action_specified_ = true;
1031
1032 repeated_action_ = action;
1033 if (!cardinality_specified()) {
1034 set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
1035 }
1036
1037 // Now that no more action clauses can be specified, we check
1038 // whether their count makes sense.
1039 CheckActionCountIfNotDone();
1040 return *this;
1041 }
1042
1043 // Implements the .RetiresOnSaturation() clause.
1044 TypedExpectation& RetiresOnSaturation() {
1045 ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
1046 ".RetiresOnSaturation() cannot appear "
1047 "more than once.");
1048 last_clause_ = kRetiresOnSaturation;
1049 retires_on_saturation_ = true;
1050
1051 // Now that no more action clauses can be specified, we check
1052 // whether their count makes sense.
1053 CheckActionCountIfNotDone();
1054 return *this;
1055 }
1056
1057 // Returns the matchers for the arguments as specified inside the
1058 // EXPECT_CALL() macro.
1059 const ArgumentMatcherTuple& matchers() const {
1060 return matchers_;
1061 }
1062
1063 // Returns the matcher specified by the .With() clause.
1064 const Matcher<const ArgumentTuple&>& extra_matcher() const {
1065 return extra_matcher_;
1066 }
1067
1068 // Returns the action specified by the .WillRepeatedly() clause.
1069 const Action<F>& repeated_action() const { return repeated_action_; }
1070
1071 // If this mock method has an extra matcher (i.e. .With(matcher)),
1072 // describes it to the ostream.
1073 void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
1074 if (extra_matcher_specified_) {
1075 *os << " Expected args: ";
1076 extra_matcher_.DescribeTo(os);
1077 *os << "\n";
1078 }
1079 }
1080
1081 private:
1082 template <typename Function>
1083 friend class FunctionMocker;
1084
1085 // Returns an Expectation object that references and co-owns this
1086 // expectation.
1087 Expectation GetHandle() override { return owner_->GetHandleOf(this); }
1088
1089 // The following methods will be called only after the EXPECT_CALL()
1090 // statement finishes and when the current thread holds
1091 // g_gmock_mutex.
1092
1093 // Returns true if and only if this expectation matches the given arguments.
1094 bool Matches(const ArgumentTuple& args) const
1095 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1096 g_gmock_mutex.AssertHeld();
1097 return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
1098 }
1099
1100 // Returns true if and only if this expectation should handle the given
1101 // arguments.
1102 bool ShouldHandleArguments(const ArgumentTuple& args) const
1103 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1104 g_gmock_mutex.AssertHeld();
1105
1106 // In case the action count wasn't checked when the expectation
1107 // was defined (e.g. if this expectation has no WillRepeatedly()
1108 // or RetiresOnSaturation() clause), we check it when the
1109 // expectation is used for the first time.
1110 CheckActionCountIfNotDone();
1111 return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
1112 }
1113
1114 // Describes the result of matching the arguments against this
1115 // expectation to the given ostream.
1116 void ExplainMatchResultTo(
1117 const ArgumentTuple& args,
1118 ::std::ostream* os) const
1119 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1120 g_gmock_mutex.AssertHeld();
1121
1122 if (is_retired()) {
1123 *os << " Expected: the expectation is active\n"
1124 << " Actual: it is retired\n";
1125 } else if (!Matches(args)) {
1126 if (!TupleMatches(matchers_, args)) {
1127 ExplainMatchFailureTupleTo(matchers_, args, os);
1128 }
1129 StringMatchResultListener listener;
1130 if (!extra_matcher_.MatchAndExplain(args, &listener)) {
1131 *os << " Expected args: ";
1132 extra_matcher_.DescribeTo(os);
1133 *os << "\n Actual: don't match";
1134
1135 internal::PrintIfNotEmpty(listener.str(), os);
1136 *os << "\n";
1137 }
1138 } else if (!AllPrerequisitesAreSatisfied()) {
1139 *os << " Expected: all pre-requisites are satisfied\n"
1140 << " Actual: the following immediate pre-requisites "
1141 << "are not satisfied:\n";
1142 ExpectationSet unsatisfied_prereqs;
1143 FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
1144 int i = 0;
1145 for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
1146 it != unsatisfied_prereqs.end(); ++it) {
1147 it->expectation_base()->DescribeLocationTo(os);
1148 *os << "pre-requisite #" << i++ << "\n";
1149 }
1150 *os << " (end of pre-requisites)\n";
1151 } else {
1152 // This line is here just for completeness' sake. It will never
1153 // be executed as currently the ExplainMatchResultTo() function
1154 // is called only when the mock function call does NOT match the
1155 // expectation.
1156 *os << "The call matches the expectation.\n";
1157 }
1158 }
1159
1160 // Returns the action that should be taken for the current invocation.
1161 const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
1162 const ArgumentTuple& args) const
1163 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1164 g_gmock_mutex.AssertHeld();
1165 const int count = call_count();
1166 Assert(count >= 1, __FILE__, __LINE__,
1167 "call_count() is <= 0 when GetCurrentAction() is "
1168 "called - this should never happen.");
1169
1170 const int action_count = static_cast<int>(untyped_actions_.size());
1171 if (action_count > 0 && !repeated_action_specified_ &&
1172 count > action_count) {
1173 // If there is at least one WillOnce() and no WillRepeatedly(),
1174 // we warn the user when the WillOnce() clauses ran out.
1175 ::std::stringstream ss;
1176 DescribeLocationTo(&ss);
1177 ss << "Actions ran out in " << source_text() << "...\n"
1178 << "Called " << count << " times, but only "
1179 << action_count << " WillOnce()"
1180 << (action_count == 1 ? " is" : "s are") << " specified - ";
1181 mocker->DescribeDefaultActionTo(args, &ss);
1182 Log(kWarning, ss.str(), 1);
1183 }
1184
1185 return count <= action_count
1186 ? *static_cast<const Action<F>*>(
1187 untyped_actions_[static_cast<size_t>(count - 1)])
1188 : repeated_action();
1189 }
1190
1191 // Given the arguments of a mock function call, if the call will
1192 // over-saturate this expectation, returns the default action;
1193 // otherwise, returns the next action in this expectation. Also
1194 // describes *what* happened to 'what', and explains *why* Google
1195 // Mock does it to 'why'. This method is not const as it calls
1196 // IncrementCallCount(). A return value of NULL means the default
1197 // action.
1198 const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
1199 const ArgumentTuple& args,
1200 ::std::ostream* what,
1201 ::std::ostream* why)
1202 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1203 g_gmock_mutex.AssertHeld();
1204 if (IsSaturated()) {
1205 // We have an excessive call.
1206 IncrementCallCount();
1207 *what << "Mock function called more times than expected - ";
1208 mocker->DescribeDefaultActionTo(args, what);
1209 DescribeCallCountTo(why);
1210
1211 return nullptr;
1212 }
1213
1214 IncrementCallCount();
1215 RetireAllPreRequisites();
1216
1217 if (retires_on_saturation_ && IsSaturated()) {
1218 Retire();
1219 }
1220
1221 // Must be done after IncrementCount()!
1222 *what << "Mock function call matches " << source_text() <<"...\n";
1223 return &(GetCurrentAction(mocker, args));
1224 }
1225
1226 // All the fields below won't change once the EXPECT_CALL()
1227 // statement finishes.
1228 FunctionMocker<F>* const owner_;
1229 ArgumentMatcherTuple matchers_;
1230 Matcher<const ArgumentTuple&> extra_matcher_;
1231 Action<F> repeated_action_;
1232
1233 GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
1234}; // class TypedExpectation
1235
1236// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
1237// specifying the default behavior of, or expectation on, a mock
1238// function.
1239
1240// Note: class MockSpec really belongs to the ::testing namespace.
1241// However if we define it in ::testing, MSVC will complain when
1242// classes in ::testing::internal declare it as a friend class
1243// template. To workaround this compiler bug, we define MockSpec in
1244// ::testing::internal and import it into ::testing.
1245
1246// Logs a message including file and line number information.
1247GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
1248 const char* file, int line,
1249 const std::string& message);
1250
1251template <typename F>
1252class MockSpec {
1253 public:
1254 typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
1255 typedef typename internal::Function<F>::ArgumentMatcherTuple
1256 ArgumentMatcherTuple;
1257
1258 // Constructs a MockSpec object, given the function mocker object
1259 // that the spec is associated with.
1260 MockSpec(internal::FunctionMocker<F>* function_mocker,
1261 const ArgumentMatcherTuple& matchers)
1262 : function_mocker_(function_mocker), matchers_(matchers) {}
1263
1264 // Adds a new default action spec to the function mocker and returns
1265 // the newly created spec.
1266 internal::OnCallSpec<F>& InternalDefaultActionSetAt(
1267 const char* file, int line, const char* obj, const char* call) {
1268 LogWithLocation(internal::kInfo, file, line,
1269 std::string("ON_CALL(") + obj + ", " + call + ") invoked");
1270 return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
1271 }
1272
1273 // Adds a new expectation spec to the function mocker and returns
1274 // the newly created spec.
1275 internal::TypedExpectation<F>& InternalExpectedAt(
1276 const char* file, int line, const char* obj, const char* call) {
1277 const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
1278 call + ")");
1279 LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
1280 return function_mocker_->AddNewExpectation(
1281 file, line, source_text, matchers_);
1282 }
1283
1284 // This operator overload is used to swallow the superfluous parameter list
1285 // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
1286 // explanation.
1287 MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
1288 return *this;
1289 }
1290
1291 private:
1292 template <typename Function>
1293 friend class internal::FunctionMocker;
1294
1295 // The function mocker that owns this spec.
1296 internal::FunctionMocker<F>* const function_mocker_;
1297 // The argument matchers specified in the spec.
1298 ArgumentMatcherTuple matchers_;
1299}; // class MockSpec
1300
1301// Wrapper type for generically holding an ordinary value or lvalue reference.
1302// If T is not a reference type, it must be copyable or movable.
1303// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
1304// T is a move-only value type (which means that it will always be copyable
1305// if the current platform does not support move semantics).
1306//
1307// The primary template defines handling for values, but function header
1308// comments describe the contract for the whole template (including
1309// specializations).
1310template <typename T>
1311class ReferenceOrValueWrapper {
1312 public:
1313 // Constructs a wrapper from the given value/reference.
1314 explicit ReferenceOrValueWrapper(T value)
1315 : value_(std::move(value)) {
1316 }
1317
1318 // Unwraps and returns the underlying value/reference, exactly as
1319 // originally passed. The behavior of calling this more than once on
1320 // the same object is unspecified.
1321 T Unwrap() { return std::move(value_); }
1322
1323 // Provides nondestructive access to the underlying value/reference.
1324 // Always returns a const reference (more precisely,
1325 // const std::add_lvalue_reference<T>::type). The behavior of calling this
1326 // after calling Unwrap on the same object is unspecified.
1327 const T& Peek() const {
1328 return value_;
1329 }
1330
1331 private:
1332 T value_;
1333};
1334
1335// Specialization for lvalue reference types. See primary template
1336// for documentation.
1337template <typename T>
1338class ReferenceOrValueWrapper<T&> {
1339 public:
1340 // Workaround for debatable pass-by-reference lint warning (c-library-team
1341 // policy precludes NOLINT in this context)
1342 typedef T& reference;
1343 explicit ReferenceOrValueWrapper(reference ref)
1344 : value_ptr_(&ref) {}
1345 T& Unwrap() { return *value_ptr_; }
1346 const T& Peek() const { return *value_ptr_; }
1347
1348 private:
1349 T* value_ptr_;
1350};
1351
1352// C++ treats the void type specially. For example, you cannot define
1353// a void-typed variable or pass a void value to a function.
1354// ActionResultHolder<T> holds a value of type T, where T must be a
1355// copyable type or void (T doesn't need to be default-constructable).
1356// It hides the syntactic difference between void and other types, and
1357// is used to unify the code for invoking both void-returning and
1358// non-void-returning mock functions.
1359
1360// Untyped base class for ActionResultHolder<T>.
1361class UntypedActionResultHolderBase {
1362 public:
1363 virtual ~UntypedActionResultHolderBase() {}
1364
1365 // Prints the held value as an action's result to os.
1366 virtual void PrintAsActionResult(::std::ostream* os) const = 0;
1367};
1368
1369// This generic definition is used when T is not void.
1370template <typename T>
1371class ActionResultHolder : public UntypedActionResultHolderBase {
1372 public:
1373 // Returns the held value. Must not be called more than once.
1374 T Unwrap() {
1375 return result_.Unwrap();
1376 }
1377
1378 // Prints the held value as an action's result to os.
1379 void PrintAsActionResult(::std::ostream* os) const override {
1380 *os << "\n Returns: ";
1381 // T may be a reference type, so we don't use UniversalPrint().
1382 UniversalPrinter<T>::Print(result_.Peek(), os);
1383 }
1384
1385 // Performs the given mock function's default action and returns the
1386 // result in a new-ed ActionResultHolder.
1387 template <typename F>
1388 static ActionResultHolder* PerformDefaultAction(
1389 const FunctionMocker<F>* func_mocker,
1390 typename Function<F>::ArgumentTuple&& args,
1391 const std::string& call_description) {
1392 return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
1393 std::move(args), call_description)));
1394 }
1395
1396 // Performs the given action and returns the result in a new-ed
1397 // ActionResultHolder.
1398 template <typename F>
1399 static ActionResultHolder* PerformAction(
1400 const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
1401 return new ActionResultHolder(
1402 Wrapper(action.Perform(std::move(args))));
1403 }
1404
1405 private:
1406 typedef ReferenceOrValueWrapper<T> Wrapper;
1407
1408 explicit ActionResultHolder(Wrapper result)
1409 : result_(std::move(result)) {
1410 }
1411
1412 Wrapper result_;
1413
1414 GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
1415};
1416
1417// Specialization for T = void.
1418template <>
1419class ActionResultHolder<void> : public UntypedActionResultHolderBase {
1420 public:
1421 void Unwrap() { }
1422
1423 void PrintAsActionResult(::std::ostream* /* os */) const override {}
1424
1425 // Performs the given mock function's default action and returns ownership
1426 // of an empty ActionResultHolder*.
1427 template <typename F>
1428 static ActionResultHolder* PerformDefaultAction(
1429 const FunctionMocker<F>* func_mocker,
1430 typename Function<F>::ArgumentTuple&& args,
1431 const std::string& call_description) {
1432 func_mocker->PerformDefaultAction(std::move(args), call_description);
1433 return new ActionResultHolder;
1434 }
1435
1436 // Performs the given action and returns ownership of an empty
1437 // ActionResultHolder*.
1438 template <typename F>
1439 static ActionResultHolder* PerformAction(
1440 const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
1441 action.Perform(std::move(args));
1442 return new ActionResultHolder;
1443 }
1444
1445 private:
1446 ActionResultHolder() {}
1447 GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
1448};
1449
1450template <typename F>
1451class FunctionMocker;
1452
1453template <typename R, typename... Args>
1454class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
1455 using F = R(Args...);
1456
1457 public:
1458 using Result = R;
1459 using ArgumentTuple = std::tuple<Args...>;
1460 using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
1461
1462 FunctionMocker() {}
1463
1464 // There is no generally useful and implementable semantics of
1465 // copying a mock object, so copying a mock is usually a user error.
1466 // Thus we disallow copying function mockers. If the user really
1467 // wants to copy a mock object, they should implement their own copy
1468 // operation, for example:
1469 //
1470 // class MockFoo : public Foo {
1471 // public:
1472 // // Defines a copy constructor explicitly.
1473 // MockFoo(const MockFoo& src) {}
1474 // ...
1475 // };
1476 FunctionMocker(const FunctionMocker&) = delete;
1477 FunctionMocker& operator=(const FunctionMocker&) = delete;
1478
1479 // The destructor verifies that all expectations on this mock
1480 // function have been satisfied. If not, it will report Google Test
1481 // non-fatal failures for the violations.
1482 ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1483 MutexLock l(&g_gmock_mutex);
1484 VerifyAndClearExpectationsLocked();
1485 Mock::UnregisterLocked(this);
1486 ClearDefaultActionsLocked();
1487 }
1488
1489 // Returns the ON_CALL spec that matches this mock function with the
1490 // given arguments; returns NULL if no matching ON_CALL is found.
1491 // L = *
1492 const OnCallSpec<F>* FindOnCallSpec(
1493 const ArgumentTuple& args) const {
1494 for (UntypedOnCallSpecs::const_reverse_iterator it
1495 = untyped_on_call_specs_.rbegin();
1496 it != untyped_on_call_specs_.rend(); ++it) {
1497 const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
1498 if (spec->Matches(args))
1499 return spec;
1500 }
1501
1502 return nullptr;
1503 }
1504
1505 // Performs the default action of this mock function on the given
1506 // arguments and returns the result. Asserts (or throws if
1507 // exceptions are enabled) with a helpful call descrption if there
1508 // is no valid return value. This method doesn't depend on the
1509 // mutable state of this object, and thus can be called concurrently
1510 // without locking.
1511 // L = *
1512 Result PerformDefaultAction(ArgumentTuple&& args,
1513 const std::string& call_description) const {
1514 const OnCallSpec<F>* const spec =
1515 this->FindOnCallSpec(args);
1516 if (spec != nullptr) {
1517 return spec->GetAction().Perform(std::move(args));
1518 }
1519 const std::string message =
1520 call_description +
1521 "\n The mock function has no default action "
1522 "set, and its return type has no default value set.";
1523#if GTEST_HAS_EXCEPTIONS
1524 if (!DefaultValue<Result>::Exists()) {
1525 throw std::runtime_error(message);
1526 }
1527#else
1528 Assert(DefaultValue<Result>::Exists(), "", -1, message);
1529#endif
1530 return DefaultValue<Result>::Get();
1531 }
1532
1533 // Performs the default action with the given arguments and returns
1534 // the action's result. The call description string will be used in
1535 // the error message to describe the call in the case the default
1536 // action fails. The caller is responsible for deleting the result.
1537 // L = *
1538 UntypedActionResultHolderBase* UntypedPerformDefaultAction(
1539 void* untyped_args, // must point to an ArgumentTuple
1540 const std::string& call_description) const override {
1541 ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
1542 return ResultHolder::PerformDefaultAction(this, std::move(*args),
1543 call_description);
1544 }
1545
1546 // Performs the given action with the given arguments and returns
1547 // the action's result. The caller is responsible for deleting the
1548 // result.
1549 // L = *
1550 UntypedActionResultHolderBase* UntypedPerformAction(
1551 const void* untyped_action, void* untyped_args) const override {
1552 // Make a copy of the action before performing it, in case the
1553 // action deletes the mock object (and thus deletes itself).
1554 const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
1555 ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
1556 return ResultHolder::PerformAction(action, std::move(*args));
1557 }
1558
1559 // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
1560 // clears the ON_CALL()s set on this mock function.
1561 void ClearDefaultActionsLocked() override
1562 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1563 g_gmock_mutex.AssertHeld();
1564
1565 // Deleting our default actions may trigger other mock objects to be
1566 // deleted, for example if an action contains a reference counted smart
1567 // pointer to that mock object, and that is the last reference. So if we
1568 // delete our actions within the context of the global mutex we may deadlock
1569 // when this method is called again. Instead, make a copy of the set of
1570 // actions to delete, clear our set within the mutex, and then delete the
1571 // actions outside of the mutex.
1572 UntypedOnCallSpecs specs_to_delete;
1573 untyped_on_call_specs_.swap(specs_to_delete);
1574
1575 g_gmock_mutex.Unlock();
1576 for (UntypedOnCallSpecs::const_iterator it =
1577 specs_to_delete.begin();
1578 it != specs_to_delete.end(); ++it) {
1579 delete static_cast<const OnCallSpec<F>*>(*it);
1580 }
1581
1582 // Lock the mutex again, since the caller expects it to be locked when we
1583 // return.
1584 g_gmock_mutex.Lock();
1585 }
1586
1587 // Returns the result of invoking this mock function with the given
1588 // arguments. This function can be safely called from multiple
1589 // threads concurrently.
1590 Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1591 ArgumentTuple tuple(std::forward<Args>(args)...);
1592 std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
1593 this->UntypedInvokeWith(static_cast<void*>(&tuple))));
1594 return holder->Unwrap();
1595 }
1596
1597 MockSpec<F> With(Matcher<Args>... m) {
1598 return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
1599 }
1600
1601 protected:
1602 template <typename Function>
1603 friend class MockSpec;
1604
1605 typedef ActionResultHolder<Result> ResultHolder;
1606
1607 // Adds and returns a default action spec for this mock function.
1608 OnCallSpec<F>& AddNewOnCallSpec(
1609 const char* file, int line,
1610 const ArgumentMatcherTuple& m)
1611 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1612 Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
1613 OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
1614 untyped_on_call_specs_.push_back(on_call_spec);
1615 return *on_call_spec;
1616 }
1617
1618 // Adds and returns an expectation spec for this mock function.
1619 TypedExpectation<F>& AddNewExpectation(const char* file, int line,
1620 const std::string& source_text,
1621 const ArgumentMatcherTuple& m)
1622 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1623 Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
1624 TypedExpectation<F>* const expectation =
1625 new TypedExpectation<F>(this, file, line, source_text, m);
1626 const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
1627 // See the definition of untyped_expectations_ for why access to
1628 // it is unprotected here.
1629 untyped_expectations_.push_back(untyped_expectation);
1630
1631 // Adds this expectation into the implicit sequence if there is one.
1632 Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
1633 if (implicit_sequence != nullptr) {
1634 implicit_sequence->AddExpectation(Expectation(untyped_expectation));
1635 }
1636
1637 return *expectation;
1638 }
1639
1640 private:
1641 template <typename Func> friend class TypedExpectation;
1642
1643 // Some utilities needed for implementing UntypedInvokeWith().
1644
1645 // Describes what default action will be performed for the given
1646 // arguments.
1647 // L = *
1648 void DescribeDefaultActionTo(const ArgumentTuple& args,
1649 ::std::ostream* os) const {
1650 const OnCallSpec<F>* const spec = FindOnCallSpec(args);
1651
1652 if (spec == nullptr) {
1653 *os << (std::is_void<Result>::value ? "returning directly.\n"
1654 : "returning default value.\n");
1655 } else {
1656 *os << "taking default action specified at:\n"
1657 << FormatFileLocation(spec->file(), spec->line()) << "\n";
1658 }
1659 }
1660
1661 // Writes a message that the call is uninteresting (i.e. neither
1662 // explicitly expected nor explicitly unexpected) to the given
1663 // ostream.
1664 void UntypedDescribeUninterestingCall(const void* untyped_args,
1665 ::std::ostream* os) const override
1666 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1667 const ArgumentTuple& args =
1668 *static_cast<const ArgumentTuple*>(untyped_args);
1669 *os << "Uninteresting mock function call - ";
1670 DescribeDefaultActionTo(args, os);
1671 *os << " Function call: " << Name();
1672 UniversalPrint(args, os);
1673 }
1674
1675 // Returns the expectation that matches the given function arguments
1676 // (or NULL is there's no match); when a match is found,
1677 // untyped_action is set to point to the action that should be
1678 // performed (or NULL if the action is "do default"), and
1679 // is_excessive is modified to indicate whether the call exceeds the
1680 // expected number.
1681 //
1682 // Critical section: We must find the matching expectation and the
1683 // corresponding action that needs to be taken in an ATOMIC
1684 // transaction. Otherwise another thread may call this mock
1685 // method in the middle and mess up the state.
1686 //
1687 // However, performing the action has to be left out of the critical
1688 // section. The reason is that we have no control on what the
1689 // action does (it can invoke an arbitrary user function or even a
1690 // mock function) and excessive locking could cause a dead lock.
1691 const ExpectationBase* UntypedFindMatchingExpectation(
1692 const void* untyped_args, const void** untyped_action, bool* is_excessive,
1693 ::std::ostream* what, ::std::ostream* why) override
1694 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
1695 const ArgumentTuple& args =
1696 *static_cast<const ArgumentTuple*>(untyped_args);
1697 MutexLock l(&g_gmock_mutex);
1698 TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
1699 if (exp == nullptr) { // A match wasn't found.
1700 this->FormatUnexpectedCallMessageLocked(args, what, why);
1701 return nullptr;
1702 }
1703
1704 // This line must be done before calling GetActionForArguments(),
1705 // which will increment the call count for *exp and thus affect
1706 // its saturation status.
1707 *is_excessive = exp->IsSaturated();
1708 const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
1709 if (action != nullptr && action->IsDoDefault())
1710 action = nullptr; // Normalize "do default" to NULL.
1711 *untyped_action = action;
1712 return exp;
1713 }
1714
1715 // Prints the given function arguments to the ostream.
1716 void UntypedPrintArgs(const void* untyped_args,
1717 ::std::ostream* os) const override {
1718 const ArgumentTuple& args =
1719 *static_cast<const ArgumentTuple*>(untyped_args);
1720 UniversalPrint(args, os);
1721 }
1722
1723 // Returns the expectation that matches the arguments, or NULL if no
1724 // expectation matches them.
1725 TypedExpectation<F>* FindMatchingExpectationLocked(
1726 const ArgumentTuple& args) const
1727 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1728 g_gmock_mutex.AssertHeld();
1729 // See the definition of untyped_expectations_ for why access to
1730 // it is unprotected here.
1731 for (typename UntypedExpectations::const_reverse_iterator it =
1732 untyped_expectations_.rbegin();
1733 it != untyped_expectations_.rend(); ++it) {
1734 TypedExpectation<F>* const exp =
1735 static_cast<TypedExpectation<F>*>(it->get());
1736 if (exp->ShouldHandleArguments(args)) {
1737 return exp;
1738 }
1739 }
1740 return nullptr;
1741 }
1742
1743 // Returns a message that the arguments don't match any expectation.
1744 void FormatUnexpectedCallMessageLocked(
1745 const ArgumentTuple& args,
1746 ::std::ostream* os,
1747 ::std::ostream* why) const
1748 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1749 g_gmock_mutex.AssertHeld();
1750 *os << "\nUnexpected mock function call - ";
1751 DescribeDefaultActionTo(args, os);
1752 PrintTriedExpectationsLocked(args, why);
1753 }
1754
1755 // Prints a list of expectations that have been tried against the
1756 // current mock function call.
1757 void PrintTriedExpectationsLocked(
1758 const ArgumentTuple& args,
1759 ::std::ostream* why) const
1760 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
1761 g_gmock_mutex.AssertHeld();
1762 const size_t count = untyped_expectations_.size();
1763 *why << "Google Mock tried the following " << count << " "
1764 << (count == 1 ? "expectation, but it didn't match" :
1765 "expectations, but none matched")
1766 << ":\n";
1767 for (size_t i = 0; i < count; i++) {
1768 TypedExpectation<F>* const expectation =
1769 static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
1770 *why << "\n";
1771 expectation->DescribeLocationTo(why);
1772 if (count > 1) {
1773 *why << "tried expectation #" << i << ": ";
1774 }
1775 *why << expectation->source_text() << "...\n";
1776 expectation->ExplainMatchResultTo(args, why);
1777 expectation->DescribeCallCountTo(why);
1778 }
1779 }
1780}; // class FunctionMocker
1781
1782// Reports an uninteresting call (whose description is in msg) in the
1783// manner specified by 'reaction'.
1784void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
1785
1786} // namespace internal
1787
1788namespace internal {
1789
1790template <typename F>
1791class MockFunction;
1792
1793template <typename R, typename... Args>
1794class MockFunction<R(Args...)> {
1795 public:
1796 MockFunction(const MockFunction&) = delete;
1797 MockFunction& operator=(const MockFunction&) = delete;
1798
1799 std::function<R(Args...)> AsStdFunction() {
1800 return [this](Args... args) -> R {
1801 return this->Call(std::forward<Args>(args)...);
1802 };
1803 }
1804
1805 // Implementation detail: the expansion of the MOCK_METHOD macro.
1806 R Call(Args... args) {
1807 mock_.SetOwnerAndName(this, "Call");
1808 return mock_.Invoke(std::forward<Args>(args)...);
1809 }
1810
1811 MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
1812 mock_.RegisterOwner(this);
1813 return mock_.With(std::move(m)...);
1814 }
1815
1816 MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
1817 return this->gmock_Call(::testing::A<Args>()...);
1818 }
1819
1820 protected:
1821 MockFunction() = default;
1822 ~MockFunction() = default;
1823
1824 private:
1825 FunctionMocker<R(Args...)> mock_;
1826};
1827
1828/*
1829The SignatureOf<F> struct is a meta-function returning function signature
1830corresponding to the provided F argument.
1831
1832It makes use of MockFunction easier by allowing it to accept more F arguments
1833than just function signatures.
1834
1835Specializations provided here cover only a signature type itself and
1836std::function. However, if need be it can be easily extended to cover also other
1837types (like for example boost::function).
1838*/
1839
1840template <typename F>
1841struct SignatureOf;
1842
1843template <typename R, typename... Args>
1844struct SignatureOf<R(Args...)> {
1845 using type = R(Args...);
1846};
1847
1848template <typename F>
1849struct SignatureOf<std::function<F>> : SignatureOf<F> {};
1850
1851template <typename F>
1852using SignatureOfT = typename SignatureOf<F>::type;
1853
1854} // namespace internal
1855
1856// A MockFunction<F> type has one mock method whose type is
1857// internal::SignatureOfT<F>. It is useful when you just want your
1858// test code to emit some messages and have Google Mock verify the
1859// right messages are sent (and perhaps at the right times). For
1860// example, if you are exercising code:
1861//
1862// Foo(1);
1863// Foo(2);
1864// Foo(3);
1865//
1866// and want to verify that Foo(1) and Foo(3) both invoke
1867// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
1868//
1869// TEST(FooTest, InvokesBarCorrectly) {
1870// MyMock mock;
1871// MockFunction<void(string check_point_name)> check;
1872// {
1873// InSequence s;
1874//
1875// EXPECT_CALL(mock, Bar("a"));
1876// EXPECT_CALL(check, Call("1"));
1877// EXPECT_CALL(check, Call("2"));
1878// EXPECT_CALL(mock, Bar("a"));
1879// }
1880// Foo(1);
1881// check.Call("1");
1882// Foo(2);
1883// check.Call("2");
1884// Foo(3);
1885// }
1886//
1887// The expectation spec says that the first Bar("a") must happen
1888// before check point "1", the second Bar("a") must happen after check
1889// point "2", and nothing should happen between the two check
1890// points. The explicit check points make it easy to tell which
1891// Bar("a") is called by which call to Foo().
1892//
1893// MockFunction<F> can also be used to exercise code that accepts
1894// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
1895// AsStdFunction() method to create std::function proxy forwarding to
1896// original object's Call. Example:
1897//
1898// TEST(FooTest, RunsCallbackWithBarArgument) {
1899// MockFunction<int(string)> callback;
1900// EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
1901// Foo(callback.AsStdFunction());
1902// }
1903//
1904// The internal::SignatureOfT<F> indirection allows to use other types
1905// than just function signature type. This is typically useful when
1906// providing a mock for a predefined std::function type. Example:
1907//
1908// using FilterPredicate = std::function<bool(string)>;
1909// void MyFilterAlgorithm(FilterPredicate predicate);
1910//
1911// TEST(FooTest, FilterPredicateAlwaysAccepts) {
1912// MockFunction<FilterPredicate> predicateMock;
1913// EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
1914// MyFilterAlgorithm(predicateMock.AsStdFunction());
1915// }
1916template <typename F>
1917class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
1918 using Base = internal::MockFunction<internal::SignatureOfT<F>>;
1919
1920 public:
1921 using Base::Base;
1922};
1923
1924// The style guide prohibits "using" statements in a namespace scope
1925// inside a header file. However, the MockSpec class template is
1926// meant to be defined in the ::testing namespace. The following line
1927// is just a trick for working around a bug in MSVC 8.0, which cannot
1928// handle it if we define MockSpec in ::testing.
1929using internal::MockSpec;
1930
1931// Const(x) is a convenient function for obtaining a const reference
1932// to x. This is useful for setting expectations on an overloaded
1933// const mock method, e.g.
1934//
1935// class MockFoo : public FooInterface {
1936// public:
1937// MOCK_METHOD0(Bar, int());
1938// MOCK_CONST_METHOD0(Bar, int&());
1939// };
1940//
1941// MockFoo foo;
1942// // Expects a call to non-const MockFoo::Bar().
1943// EXPECT_CALL(foo, Bar());
1944// // Expects a call to const MockFoo::Bar().
1945// EXPECT_CALL(Const(foo), Bar());
1946template <typename T>
1947inline const T& Const(const T& x) { return x; }
1948
1949// Constructs an Expectation object that references and co-owns exp.
1950inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT
1951 : expectation_base_(exp.GetHandle().expectation_base()) {}
1952
1953} // namespace testing
1954
1956
1957// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
1958// required to avoid compile errors when the name of the method used in call is
1959// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
1960// tests in internal/gmock-spec-builders_test.cc for more details.
1961//
1962// This macro supports statements both with and without parameter matchers. If
1963// the parameter list is omitted, gMock will accept any parameters, which allows
1964// tests to be written that don't need to encode the number of method
1965// parameter. This technique may only be used for non-overloaded methods.
1966//
1967// // These are the same:
1968// ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
1969// ON_CALL(mock, NoArgsMethod).WillByDefault(...);
1970//
1971// // As are these:
1972// ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
1973// ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
1974//
1975// // Can also specify args if you want, of course:
1976// ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
1977//
1978// // Overloads work as long as you specify parameters:
1979// ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
1980// ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
1981//
1982// // Oops! Which overload did you want?
1983// ON_CALL(mock, OverloadedMethod).WillByDefault(...);
1984// => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
1985//
1986// How this works: The mock class uses two overloads of the gmock_Method
1987// expectation setter method plus an operator() overload on the MockSpec object.
1988// In the matcher list form, the macro expands to:
1989//
1990// // This statement:
1991// ON_CALL(mock, TwoArgsMethod(_, 45))...
1992//
1993// // ...expands to:
1994// mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
1995// |-------------v---------------||------------v-------------|
1996// invokes first overload swallowed by operator()
1997//
1998// // ...which is essentially:
1999// mock.gmock_TwoArgsMethod(_, 45)...
2000//
2001// Whereas the form without a matcher list:
2002//
2003// // This statement:
2004// ON_CALL(mock, TwoArgsMethod)...
2005//
2006// // ...expands to:
2007// mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
2008// |-----------------------v--------------------------|
2009// invokes second overload
2010//
2011// // ...which is essentially:
2012// mock.gmock_TwoArgsMethod(_, _)...
2013//
2014// The WithoutMatchers() argument is used to disambiguate overloads and to
2015// block the caller from accidentally invoking the second overload directly. The
2016// second argument is an internal type derived from the method signature. The
2017// failure to disambiguate two overloads of this method in the ON_CALL statement
2018// is how we block callers from setting expectations on overloaded methods.
2019#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \
2020 ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
2021 nullptr) \
2022 .Setter(__FILE__, __LINE__, #mock_expr, #call)
2023
2024#define ON_CALL(obj, call) \
2025 GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
2026
2027#define EXPECT_CALL(obj, call) \
2028 GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
2029
2030#endif // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
exp(expr.val())
#define R
int * count
#define GTEST_ATTRIBUTE_UNUSED_
Definition gtest-port.h:665
#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
#define GTEST_LOCK_EXCLUDED_(locks)
#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
Definition gtest-port.h:323
#define GTEST_API_
Definition gtest-port.h:775
#define GTEST_DISABLE_MSC_WARNINGS_POP_()
Definition gtest-port.h:324
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
Definition gtest-port.h:693
#define GTEST_DECLARE_STATIC_MUTEX_(mutex)
std::string name_
Definition gtest.cc:2817