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" 74 #include "gmock/gmock-cardinalities.h" 75 #include "gmock/gmock-matchers.h" 76 #include "gmock/internal/gmock-internal-utils.h" 77 #include "gmock/internal/gmock-port.h" 78 #include "gtest/gtest.h" 79 80 #if GTEST_HAS_EXCEPTIONS 81 # include <stdexcept> // NOLINT 82 #endif 83 84 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 85 /* class A needs to have dll-interface to be used by clients of class B */) 86 87 namespace testing { 88 89 // An abstract handle of an expectation. 90 class Expectation; 91 92 // A set of expectation handles. 93 class ExpectationSet; 94 95 // Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION 96 // and MUST NOT BE USED IN USER CODE!!! 97 namespace internal { 98 99 // Implements a mock function. 100 template <typename F> class FunctionMocker; 101 102 // Base class for expectations. 103 class ExpectationBase; 104 105 // Implements an expectation. 106 template <typename F> class TypedExpectation; 107 108 // Helper class for testing the Expectation class template. 109 class 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. 122 GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex); 123 124 // Untyped base class for ActionResultHolder<R>. 125 class 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. 130 class 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>. 252 class UntypedOnCallSpecBase { 253 public: 254 // The arguments are the location of the ON_CALL() statement. UntypedOnCallSpecBase(const char * a_file,int a_line)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? file()259 const char* file() const { return file_; } line()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. AssertSpecProperty(bool property,const std::string & failure_message)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. ExpectSpecProperty(bool property,const std::string & failure_message)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. 293 template <typename F> 294 class 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. OnCallSpec(const char * a_file,int a_line,const ArgumentMatcherTuple & matchers)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. With(const Matcher<const ArgumentTuple &> & m)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. WillByDefault(const Action<F> & action)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. Matches(const ArgumentTuple & args)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. GetAction()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. 368 enum CallReaction { 369 kAllow, 370 kWarn, 371 kFail, 372 }; 373 374 } // namespace internal 375 376 // Utilities for manipulating mock objects. 377 class 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 498 class 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: operator()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. expectation_base()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. 577 class 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. ExpectationSet()586 ExpectationSet() {} 587 588 // This single-argument ctor must not be explicit, in order to support the 589 // ExpectationSet es = EXPECT_CALL(...); 590 // syntax. ExpectationSet(internal::ExpectationBase & exp)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(). ExpectationSet(const Expectation & e)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 size()620 int size() const { return static_cast<int>(expectations_.size()); } 621 begin()622 const_iterator begin() const { return expectations_.begin(); } end()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). 633 class GTEST_API_ Sequence { 634 public: 635 // Constructs an empty sequence. 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. 671 class GTEST_API_ InSequence { 672 public: 673 InSequence(); 674 ~InSequence(); 675 private: 676 bool sequence_created_; 677 678 GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence); // NOLINT 679 } GTEST_ATTRIBUTE_UNUSED_; 680 681 namespace internal { 682 683 // Points to the implicit sequence introduced by a living InSequence 684 // object (if any) in the current thread or NULL. 685 GTEST_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. 701 class 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? file()709 const char* file() const { return file_; } line()710 int line() const { return line_; } source_text()711 const char* source_text() const { return source_text_.c_str(); } 712 // Returns the cardinality specified in the expectation spec. cardinality()713 const Cardinality& cardinality() const { return cardinality_; } 714 715 // Describes the source file location of this expectation. DescribeLocationTo(::std::ostream * os)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. AssertSpecProperty(bool property,const std::string & failure_message)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. ExpectSpecProperty(bool property,const std::string & failure_message)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(). cardinality_specified()769 bool cardinality_specified() const { return cardinality_specified_; } 770 771 // Sets the cardinality of this expectation spec. set_cardinality(const Cardinality & a_cardinality)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. 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. Retire()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. IsSatisfied()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. IsSaturated()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. IsOverSaturated()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. call_count()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. IncrementCallCount()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. 888 template <typename F> 889 class 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 TypedExpectation(FunctionMocker<F> * owner,const char * a_file,int a_line,const std::string & a_source_text,const ArgumentMatcherTuple & m)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 ~TypedExpectation()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. With(const Matcher<const ArgumentTuple &> & m)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. Times(const Cardinality & a_cardinality)936 TypedExpectation& Times(const Cardinality& a_cardinality) { 937 ExpectationBase::UntypedTimes(a_cardinality); 938 return *this; 939 } 940 941 // Implements the .Times() clause. Times(int n)942 TypedExpectation& Times(int n) { 943 return Times(Exactly(n)); 944 } 945 946 // Implements the .InSequence() clause. InSequence(const Sequence & s)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 } InSequence(const Sequence & s1,const Sequence & s2)957 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) { 958 return InSequence(s1).InSequence(s2); 959 } InSequence(const Sequence & s1,const Sequence & s2,const Sequence & s3)960 TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2, 961 const Sequence& s3) { 962 return InSequence(s1, s2).InSequence(s3); 963 } InSequence(const Sequence & s1,const Sequence & s2,const Sequence & s3,const Sequence & s4)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 } InSequence(const Sequence & s1,const Sequence & s2,const Sequence & s3,const Sequence & s4,const Sequence & s5)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. After(const ExpectationSet & s)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 } After(const ExpectationSet & s1,const ExpectationSet & s2)987 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) { 988 return After(s1).After(s2); 989 } After(const ExpectationSet & s1,const ExpectationSet & s2,const ExpectationSet & s3)990 TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2, 991 const ExpectationSet& s3) { 992 return After(s1, s2).After(s3); 993 } After(const ExpectationSet & s1,const ExpectationSet & s2,const ExpectationSet & s3,const ExpectationSet & s4)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 } After(const ExpectationSet & s1,const ExpectationSet & s2,const ExpectationSet & s3,const ExpectationSet & s4,const ExpectationSet & s5)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. WillOnce(const Action<F> & action)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. WillRepeatedly(const Action<F> & action)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. RetiresOnSaturation()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. matchers()1059 const ArgumentMatcherTuple& matchers() const { 1060 return matchers_; 1061 } 1062 1063 // Returns the matcher specified by the .With() clause. extra_matcher()1064 const Matcher<const ArgumentTuple&>& extra_matcher() const { 1065 return extra_matcher_; 1066 } 1067 1068 // Returns the action specified by the .WillRepeatedly() clause. repeated_action()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. MaybeDescribeExtraMatcherTo(::std::ostream * os)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. GetHandle()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. Matches(const ArgumentTuple & args)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. ShouldHandleArguments(const ArgumentTuple & args)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. ExplainMatchResultTo(const ArgumentTuple & args,::std::ostream * os)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. GetCurrentAction(const FunctionMocker<F> * mocker,const ArgumentTuple & args)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. GetActionForArguments(const FunctionMocker<F> * mocker,const ArgumentTuple & args,::std::ostream * what,::std::ostream * why)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. 1247 GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, 1248 const char* file, int line, 1249 const std::string& message); 1250 1251 template <typename F> 1252 class 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. MockSpec(internal::FunctionMocker<F> * function_mocker,const ArgumentMatcherTuple & matchers)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. InternalDefaultActionSetAt(const char * file,int line,const char * obj,const char * call)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. InternalExpectedAt(const char * file,int line,const char * obj,const char * call)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. operator()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). 1310 template <typename T> 1311 class ReferenceOrValueWrapper { 1312 public: 1313 // Constructs a wrapper from the given value/reference. ReferenceOrValueWrapper(T value)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. Unwrap()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. Peek()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. 1337 template <typename T> 1338 class 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; ReferenceOrValueWrapper(reference ref)1343 explicit ReferenceOrValueWrapper(reference ref) 1344 : value_ptr_(&ref) {} Unwrap()1345 T& Unwrap() { return *value_ptr_; } Peek()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>. 1361 class UntypedActionResultHolderBase { 1362 public: ~UntypedActionResultHolderBase()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. 1370 template <typename T> 1371 class ActionResultHolder : public UntypedActionResultHolderBase { 1372 public: 1373 // Returns the held value. Must not be called more than once. Unwrap()1374 T Unwrap() { 1375 return result_.Unwrap(); 1376 } 1377 1378 // Prints the held value as an action's result to os. PrintAsActionResult(::std::ostream * 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> PerformDefaultAction(const FunctionMocker<F> * func_mocker,typename Function<F>::ArgumentTuple && args,const std::string & call_description)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> PerformAction(const Action<F> & action,typename Function<F>::ArgumentTuple && args)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 ActionResultHolder(Wrapper result)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. 1418 template <> 1419 class ActionResultHolder<void> : public UntypedActionResultHolderBase { 1420 public: Unwrap()1421 void Unwrap() { } 1422 PrintAsActionResult(::std::ostream *)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> PerformDefaultAction(const FunctionMocker<F> * func_mocker,typename Function<F>::ArgumentTuple && args,const std::string & call_description)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> PerformAction(const Action<F> & action,typename Function<F>::ArgumentTuple && args)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: ActionResultHolder()1446 ActionResultHolder() {} 1447 GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder); 1448 }; 1449 1450 template <typename F> 1451 class FunctionMocker; 1452 1453 template <typename R, typename... Args> 1454 class 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 FunctionMocker()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. ~FunctionMocker()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 = * FindOnCallSpec(const ArgumentTuple & args)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 = * PerformDefaultAction(ArgumentTuple && args,const std::string & call_description)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 = * UntypedPerformDefaultAction(void * untyped_args,const std::string & call_description)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 = * UntypedPerformAction(const void * untyped_action,void * untyped_args)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. ClearDefaultActionsLocked()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. Invoke(Args...args)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 With(Matcher<Args>...m)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. AddNewOnCallSpec(const char * file,int line,const ArgumentMatcherTuple & m)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. AddNewExpectation(const char * file,int line,const std::string & source_text,const ArgumentMatcherTuple & m)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 = * DescribeDefaultActionTo(const ArgumentTuple & args,::std::ostream * os)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. UntypedDescribeUninterestingCall(const void * untyped_args,::std::ostream * os)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. UntypedFindMatchingExpectation(const void * untyped_args,const void ** untyped_action,bool * is_excessive,::std::ostream * what,::std::ostream * why)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. UntypedPrintArgs(const void * untyped_args,::std::ostream * os)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. FindMatchingExpectationLocked(const ArgumentTuple & args)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. FormatUnexpectedCallMessageLocked(const ArgumentTuple & args,::std::ostream * os,::std::ostream * why)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. PrintTriedExpectationsLocked(const ArgumentTuple & args,::std::ostream * why)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'. 1784 void ReportUninterestingCall(CallReaction reaction, const std::string& msg); 1785 1786 } // namespace internal 1787 1788 namespace internal { 1789 1790 template <typename F> 1791 class MockFunction; 1792 1793 template <typename R, typename... Args> 1794 class MockFunction<R(Args...)> { 1795 public: 1796 MockFunction(const MockFunction&) = delete; 1797 MockFunction& operator=(const MockFunction&) = delete; 1798 AsStdFunction()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. Call(Args...args)1806 R Call(Args... args) { 1807 mock_.SetOwnerAndName(this, "Call"); 1808 return mock_.Invoke(std::forward<Args>(args)...); 1809 } 1810 gmock_Call(Matcher<Args>...m)1811 MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) { 1812 mock_.RegisterOwner(this); 1813 return mock_.With(std::move(m)...); 1814 } 1815 gmock_Call(const WithoutMatchers &,R (*)(Args...))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 /* 1829 The SignatureOf<F> struct is a meta-function returning function signature 1830 corresponding to the provided F argument. 1831 1832 It makes use of MockFunction easier by allowing it to accept more F arguments 1833 than just function signatures. 1834 1835 Specializations provided here cover only a signature type itself and 1836 std::function. However, if need be it can be easily extended to cover also other 1837 types (like for example boost::function). 1838 */ 1839 1840 template <typename F> 1841 struct SignatureOf; 1842 1843 template <typename R, typename... Args> 1844 struct SignatureOf<R(Args...)> { 1845 using type = R(Args...); 1846 }; 1847 1848 template <typename F> 1849 struct SignatureOf<std::function<F>> : SignatureOf<F> {}; 1850 1851 template <typename F> 1852 using 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 // } 1916 template <typename F> 1917 class 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. 1929 using 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()); 1946 template <typename T> 1947 inline const T& Const(const T& x) { return x; } 1948 1949 // Constructs an Expectation object that references and co-owns exp. 1950 inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT 1951 : expectation_base_(exp.GetHandle().expectation_base()) {} 1952 1953 } // namespace testing 1954 1955 GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 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_ 2031