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 // Author: wan (at) google.com (Zhanyong Wan) 31 32 // Google Mock - a framework for writing C++ mock classes. 33 // 34 // This file implements the spec builder syntax (ON_CALL and 35 // EXPECT_CALL). 36 37 #include "gmock/gmock-spec-builders.h" 38 39 #include <stdlib.h> 40 #include <iostream> // NOLINT 41 #include <map> 42 #include <set> 43 #include <string> 44 #include "gmock/gmock.h" 45 #include "gtest/gtest.h" 46 47 #if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC 48 # include <unistd.h> // NOLINT 49 #endif 50 51 namespace testing { 52 namespace internal { 53 54 // Protects the mock object registry (in class Mock), all function 55 // mockers, and all expectations. 56 GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex); 57 58 // Logs a message including file and line number information. 59 GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity, 60 const char* file, int line, 61 const std::string& message) { 62 ::std::ostringstream s; 63 s << file << ":" << line << ": " << message << ::std::endl; 64 Log(severity, s.str(), 0); 65 } 66 67 // Constructs an ExpectationBase object. 68 ExpectationBase::ExpectationBase(const char* a_file, int a_line, 69 const std::string& a_source_text) 70 : file_(a_file), 71 line_(a_line), 72 source_text_(a_source_text), 73 cardinality_specified_(false), 74 cardinality_(Exactly(1)), 75 call_count_(0), 76 retired_(false), 77 extra_matcher_specified_(false), 78 repeated_action_specified_(false), 79 retires_on_saturation_(false), 80 last_clause_(kNone), 81 action_count_checked_(false) {} 82 83 // Destructs an ExpectationBase object. 84 ExpectationBase::~ExpectationBase() {} 85 86 // Explicitly specifies the cardinality of this expectation. Used by 87 // the subclasses to implement the .Times() clause. 88 void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) { 89 cardinality_specified_ = true; 90 cardinality_ = a_cardinality; 91 } 92 93 // Retires all pre-requisites of this expectation. 94 void ExpectationBase::RetireAllPreRequisites() 95 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 96 if (is_retired()) { 97 // We can take this short-cut as we never retire an expectation 98 // until we have retired all its pre-requisites. 99 return; 100 } 101 102 for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin(); 103 it != immediate_prerequisites_.end(); ++it) { 104 ExpectationBase* const prerequisite = it->expectation_base().get(); 105 if (!prerequisite->is_retired()) { 106 prerequisite->RetireAllPreRequisites(); 107 prerequisite->Retire(); 108 } 109 } 110 } 111 112 // Returns true iff all pre-requisites of this expectation have been 113 // satisfied. 114 bool ExpectationBase::AllPrerequisitesAreSatisfied() const 115 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 116 g_gmock_mutex.AssertHeld(); 117 for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin(); 118 it != immediate_prerequisites_.end(); ++it) { 119 if (!(it->expectation_base()->IsSatisfied()) || 120 !(it->expectation_base()->AllPrerequisitesAreSatisfied())) 121 return false; 122 } 123 return true; 124 } 125 126 // Adds unsatisfied pre-requisites of this expectation to 'result'. 127 void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const 128 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 129 g_gmock_mutex.AssertHeld(); 130 for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin(); 131 it != immediate_prerequisites_.end(); ++it) { 132 if (it->expectation_base()->IsSatisfied()) { 133 // If *it is satisfied and has a call count of 0, some of its 134 // pre-requisites may not be satisfied yet. 135 if (it->expectation_base()->call_count_ == 0) { 136 it->expectation_base()->FindUnsatisfiedPrerequisites(result); 137 } 138 } else { 139 // Now that we know *it is unsatisfied, we are not so interested 140 // in whether its pre-requisites are satisfied. Therefore we 141 // don't recursively call FindUnsatisfiedPrerequisites() here. 142 *result += *it; 143 } 144 } 145 } 146 147 // Describes how many times a function call matching this 148 // expectation has occurred. 149 void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const 150 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 151 g_gmock_mutex.AssertHeld(); 152 153 // Describes how many times the function is expected to be called. 154 *os << " Expected: to be "; 155 cardinality().DescribeTo(os); 156 *os << "\n Actual: "; 157 Cardinality::DescribeActualCallCountTo(call_count(), os); 158 159 // Describes the state of the expectation (e.g. is it satisfied? 160 // is it active?). 161 *os << " - " << (IsOverSaturated() ? "over-saturated" : 162 IsSaturated() ? "saturated" : 163 IsSatisfied() ? "satisfied" : "unsatisfied") 164 << " and " 165 << (is_retired() ? "retired" : "active"); 166 } 167 168 // Checks the action count (i.e. the number of WillOnce() and 169 // WillRepeatedly() clauses) against the cardinality if this hasn't 170 // been done before. Prints a warning if there are too many or too 171 // few actions. 172 void ExpectationBase::CheckActionCountIfNotDone() const 173 GTEST_LOCK_EXCLUDED_(mutex_) { 174 bool should_check = false; 175 { 176 MutexLock l(&mutex_); 177 if (!action_count_checked_) { 178 action_count_checked_ = true; 179 should_check = true; 180 } 181 } 182 183 if (should_check) { 184 if (!cardinality_specified_) { 185 // The cardinality was inferred - no need to check the action 186 // count against it. 187 return; 188 } 189 190 // The cardinality was explicitly specified. 191 const int action_count = static_cast<int>(untyped_actions_.size()); 192 const int upper_bound = cardinality().ConservativeUpperBound(); 193 const int lower_bound = cardinality().ConservativeLowerBound(); 194 bool too_many; // True if there are too many actions, or false 195 // if there are too few. 196 if (action_count > upper_bound || 197 (action_count == upper_bound && repeated_action_specified_)) { 198 too_many = true; 199 } else if (0 < action_count && action_count < lower_bound && 200 !repeated_action_specified_) { 201 too_many = false; 202 } else { 203 return; 204 } 205 206 ::std::stringstream ss; 207 DescribeLocationTo(&ss); 208 ss << "Too " << (too_many ? "many" : "few") 209 << " actions specified in " << source_text() << "...\n" 210 << "Expected to be "; 211 cardinality().DescribeTo(&ss); 212 ss << ", but has " << (too_many ? "" : "only ") 213 << action_count << " WillOnce()" 214 << (action_count == 1 ? "" : "s"); 215 if (repeated_action_specified_) { 216 ss << " and a WillRepeatedly()"; 217 } 218 ss << "."; 219 Log(kWarning, ss.str(), -1); // -1 means "don't print stack trace". 220 } 221 } 222 223 // Implements the .Times() clause. 224 void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) { 225 if (last_clause_ == kTimes) { 226 ExpectSpecProperty(false, 227 ".Times() cannot appear " 228 "more than once in an EXPECT_CALL()."); 229 } else { 230 ExpectSpecProperty(last_clause_ < kTimes, 231 ".Times() cannot appear after " 232 ".InSequence(), .WillOnce(), .WillRepeatedly(), " 233 "or .RetiresOnSaturation()."); 234 } 235 last_clause_ = kTimes; 236 237 SpecifyCardinality(a_cardinality); 238 } 239 240 // Points to the implicit sequence introduced by a living InSequence 241 // object (if any) in the current thread or NULL. 242 GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence; 243 244 // Reports an uninteresting call (whose description is in msg) in the 245 // manner specified by 'reaction'. 246 void ReportUninterestingCall(CallReaction reaction, const std::string& msg) { 247 // Include a stack trace only if --gmock_verbose=info is specified. 248 const int stack_frames_to_skip = 249 GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1; 250 switch (reaction) { 251 case kAllow: 252 Log(kInfo, msg, stack_frames_to_skip); 253 break; 254 case kWarn: 255 Log(kWarning, 256 msg + 257 "\nNOTE: You can safely ignore the above warning unless this " 258 "call should not happen. Do not suppress it by blindly adding " 259 "an EXPECT_CALL() if you don't mean to enforce the call. " 260 "See https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md#" 261 "knowing-when-to-expect for details.\n", 262 stack_frames_to_skip); 263 break; 264 default: // FAIL 265 Expect(false, NULL, -1, msg); 266 } 267 } 268 269 UntypedFunctionMockerBase::UntypedFunctionMockerBase() 270 : mock_obj_(NULL), name_("") {} 271 272 UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {} 273 274 // Sets the mock object this mock method belongs to, and registers 275 // this information in the global mock registry. Will be called 276 // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock 277 // method. 278 void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj) 279 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 280 { 281 MutexLock l(&g_gmock_mutex); 282 mock_obj_ = mock_obj; 283 } 284 Mock::Register(mock_obj, this); 285 } 286 287 // Sets the mock object this mock method belongs to, and sets the name 288 // of the mock function. Will be called upon each invocation of this 289 // mock function. 290 void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj, 291 const char* name) 292 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 293 // We protect name_ under g_gmock_mutex in case this mock function 294 // is called from two threads concurrently. 295 MutexLock l(&g_gmock_mutex); 296 mock_obj_ = mock_obj; 297 name_ = name; 298 } 299 300 // Returns the name of the function being mocked. Must be called 301 // after RegisterOwner() or SetOwnerAndName() has been called. 302 const void* UntypedFunctionMockerBase::MockObject() const 303 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 304 const void* mock_obj; 305 { 306 // We protect mock_obj_ under g_gmock_mutex in case this mock 307 // function is called from two threads concurrently. 308 MutexLock l(&g_gmock_mutex); 309 Assert(mock_obj_ != NULL, __FILE__, __LINE__, 310 "MockObject() must not be called before RegisterOwner() or " 311 "SetOwnerAndName() has been called."); 312 mock_obj = mock_obj_; 313 } 314 return mock_obj; 315 } 316 317 // Returns the name of this mock method. Must be called after 318 // SetOwnerAndName() has been called. 319 const char* UntypedFunctionMockerBase::Name() const 320 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 321 const char* name; 322 { 323 // We protect name_ under g_gmock_mutex in case this mock 324 // function is called from two threads concurrently. 325 MutexLock l(&g_gmock_mutex); 326 Assert(name_ != NULL, __FILE__, __LINE__, 327 "Name() must not be called before SetOwnerAndName() has " 328 "been called."); 329 name = name_; 330 } 331 return name; 332 } 333 334 // Calculates the result of invoking this mock function with the given 335 // arguments, prints it, and returns it. The caller is responsible 336 // for deleting the result. 337 UntypedActionResultHolderBase* 338 UntypedFunctionMockerBase::UntypedInvokeWith(const void* const untyped_args) 339 GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 340 if (untyped_expectations_.size() == 0) { 341 // No expectation is set on this mock method - we have an 342 // uninteresting call. 343 344 // We must get Google Mock's reaction on uninteresting calls 345 // made on this mock object BEFORE performing the action, 346 // because the action may DELETE the mock object and make the 347 // following expression meaningless. 348 const CallReaction reaction = 349 Mock::GetReactionOnUninterestingCalls(MockObject()); 350 351 // True iff we need to print this call's arguments and return 352 // value. This definition must be kept in sync with 353 // the behavior of ReportUninterestingCall(). 354 const bool need_to_report_uninteresting_call = 355 // If the user allows this uninteresting call, we print it 356 // only when he wants informational messages. 357 reaction == kAllow ? LogIsVisible(kInfo) : 358 // If the user wants this to be a warning, we print it only 359 // when he wants to see warnings. 360 reaction == kWarn ? LogIsVisible(kWarning) : 361 // Otherwise, the user wants this to be an error, and we 362 // should always print detailed information in the error. 363 true; 364 365 if (!need_to_report_uninteresting_call) { 366 // Perform the action without printing the call information. 367 return this->UntypedPerformDefaultAction(untyped_args, ""); 368 } 369 370 // Warns about the uninteresting call. 371 ::std::stringstream ss; 372 this->UntypedDescribeUninterestingCall(untyped_args, &ss); 373 374 // Calculates the function result. 375 UntypedActionResultHolderBase* const result = 376 this->UntypedPerformDefaultAction(untyped_args, ss.str()); 377 378 // Prints the function result. 379 if (result != NULL) 380 result->PrintAsActionResult(&ss); 381 382 ReportUninterestingCall(reaction, ss.str()); 383 return result; 384 } 385 386 bool is_excessive = false; 387 ::std::stringstream ss; 388 ::std::stringstream why; 389 ::std::stringstream loc; 390 const void* untyped_action = NULL; 391 392 // The UntypedFindMatchingExpectation() function acquires and 393 // releases g_gmock_mutex. 394 const ExpectationBase* const untyped_expectation = 395 this->UntypedFindMatchingExpectation( 396 untyped_args, &untyped_action, &is_excessive, 397 &ss, &why); 398 const bool found = untyped_expectation != NULL; 399 400 // True iff we need to print the call's arguments and return value. 401 // This definition must be kept in sync with the uses of Expect() 402 // and Log() in this function. 403 const bool need_to_report_call = 404 !found || is_excessive || LogIsVisible(kInfo); 405 if (!need_to_report_call) { 406 // Perform the action without printing the call information. 407 return 408 untyped_action == NULL ? 409 this->UntypedPerformDefaultAction(untyped_args, "") : 410 this->UntypedPerformAction(untyped_action, untyped_args); 411 } 412 413 ss << " Function call: " << Name(); 414 this->UntypedPrintArgs(untyped_args, &ss); 415 416 // In case the action deletes a piece of the expectation, we 417 // generate the message beforehand. 418 if (found && !is_excessive) { 419 untyped_expectation->DescribeLocationTo(&loc); 420 } 421 422 UntypedActionResultHolderBase* const result = 423 untyped_action == NULL ? 424 this->UntypedPerformDefaultAction(untyped_args, ss.str()) : 425 this->UntypedPerformAction(untyped_action, untyped_args); 426 if (result != NULL) 427 result->PrintAsActionResult(&ss); 428 ss << "\n" << why.str(); 429 430 if (!found) { 431 // No expectation matches this call - reports a failure. 432 Expect(false, NULL, -1, ss.str()); 433 } else if (is_excessive) { 434 // We had an upper-bound violation and the failure message is in ss. 435 Expect(false, untyped_expectation->file(), 436 untyped_expectation->line(), ss.str()); 437 } else { 438 // We had an expected call and the matching expectation is 439 // described in ss. 440 Log(kInfo, loc.str() + ss.str(), 2); 441 } 442 443 return result; 444 } 445 446 // Returns an Expectation object that references and co-owns exp, 447 // which must be an expectation on this mock function. 448 Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) { 449 for (UntypedExpectations::const_iterator it = 450 untyped_expectations_.begin(); 451 it != untyped_expectations_.end(); ++it) { 452 if (it->get() == exp) { 453 return Expectation(*it); 454 } 455 } 456 457 Assert(false, __FILE__, __LINE__, "Cannot find expectation."); 458 return Expectation(); 459 // The above statement is just to make the code compile, and will 460 // never be executed. 461 } 462 463 // Verifies that all expectations on this mock function have been 464 // satisfied. Reports one or more Google Test non-fatal failures 465 // and returns false if not. 466 bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked() 467 GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 468 g_gmock_mutex.AssertHeld(); 469 bool expectations_met = true; 470 for (UntypedExpectations::const_iterator it = 471 untyped_expectations_.begin(); 472 it != untyped_expectations_.end(); ++it) { 473 ExpectationBase* const untyped_expectation = it->get(); 474 if (untyped_expectation->IsOverSaturated()) { 475 // There was an upper-bound violation. Since the error was 476 // already reported when it occurred, there is no need to do 477 // anything here. 478 expectations_met = false; 479 } else if (!untyped_expectation->IsSatisfied()) { 480 expectations_met = false; 481 ::std::stringstream ss; 482 ss << "Actual function call count doesn't match " 483 << untyped_expectation->source_text() << "...\n"; 484 // No need to show the source file location of the expectation 485 // in the description, as the Expect() call that follows already 486 // takes care of it. 487 untyped_expectation->MaybeDescribeExtraMatcherTo(&ss); 488 untyped_expectation->DescribeCallCountTo(&ss); 489 Expect(false, untyped_expectation->file(), 490 untyped_expectation->line(), ss.str()); 491 } 492 } 493 494 // Deleting our expectations may trigger other mock objects to be deleted, for 495 // example if an action contains a reference counted smart pointer to that 496 // mock object, and that is the last reference. So if we delete our 497 // expectations within the context of the global mutex we may deadlock when 498 // this method is called again. Instead, make a copy of the set of 499 // expectations to delete, clear our set within the mutex, and then clear the 500 // copied set outside of it. 501 UntypedExpectations expectations_to_delete; 502 untyped_expectations_.swap(expectations_to_delete); 503 504 g_gmock_mutex.Unlock(); 505 expectations_to_delete.clear(); 506 g_gmock_mutex.Lock(); 507 508 return expectations_met; 509 } 510 511 } // namespace internal 512 513 // Class Mock. 514 515 namespace { 516 517 typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers; 518 519 // The current state of a mock object. Such information is needed for 520 // detecting leaked mock objects and explicitly verifying a mock's 521 // expectations. 522 struct MockObjectState { 523 MockObjectState() 524 : first_used_file(NULL), first_used_line(-1), leakable(false) {} 525 526 // Where in the source file an ON_CALL or EXPECT_CALL is first 527 // invoked on this mock object. 528 const char* first_used_file; 529 int first_used_line; 530 ::std::string first_used_test_case; 531 ::std::string first_used_test; 532 bool leakable; // true iff it's OK to leak the object. 533 FunctionMockers function_mockers; // All registered methods of the object. 534 }; 535 536 // A global registry holding the state of all mock objects that are 537 // alive. A mock object is added to this registry the first time 538 // Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it. It 539 // is removed from the registry in the mock object's destructor. 540 class MockObjectRegistry { 541 public: 542 // Maps a mock object (identified by its address) to its state. 543 typedef std::map<const void*, MockObjectState> StateMap; 544 545 // This destructor will be called when a program exits, after all 546 // tests in it have been run. By then, there should be no mock 547 // object alive. Therefore we report any living object as test 548 // failure, unless the user explicitly asked us to ignore it. 549 ~MockObjectRegistry() { 550 // "using ::std::cout;" doesn't work with Symbian's STLport, where cout is 551 // a macro. 552 553 if (!GMOCK_FLAG(catch_leaked_mocks)) 554 return; 555 556 int leaked_count = 0; 557 for (StateMap::const_iterator it = states_.begin(); it != states_.end(); 558 ++it) { 559 if (it->second.leakable) // The user said it's fine to leak this object. 560 continue; 561 562 // TODO(wan (at) google.com): Print the type of the leaked object. 563 // This can help the user identify the leaked object. 564 std::cout << "\n"; 565 const MockObjectState& state = it->second; 566 std::cout << internal::FormatFileLocation(state.first_used_file, 567 state.first_used_line); 568 std::cout << " ERROR: this mock object"; 569 if (state.first_used_test != "") { 570 std::cout << " (used in test " << state.first_used_test_case << "." 571 << state.first_used_test << ")"; 572 } 573 std::cout << " should be deleted but never is. Its address is @" 574 << it->first << "."; 575 leaked_count++; 576 } 577 if (leaked_count > 0) { 578 std::cout << "\nERROR: " << leaked_count 579 << " leaked mock " << (leaked_count == 1 ? "object" : "objects") 580 << " found at program exit.\n"; 581 std::cout.flush(); 582 ::std::cerr.flush(); 583 // RUN_ALL_TESTS() has already returned when this destructor is 584 // called. Therefore we cannot use the normal Google Test 585 // failure reporting mechanism. 586 _exit(1); // We cannot call exit() as it is not reentrant and 587 // may already have been called. 588 } 589 } 590 591 StateMap& states() { return states_; } 592 593 private: 594 StateMap states_; 595 }; 596 597 // Protected by g_gmock_mutex. 598 MockObjectRegistry g_mock_object_registry; 599 600 // Maps a mock object to the reaction Google Mock should have when an 601 // uninteresting method is called. Protected by g_gmock_mutex. 602 std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction; 603 604 // Sets the reaction Google Mock should have when an uninteresting 605 // method of the given mock object is called. 606 void SetReactionOnUninterestingCalls(const void* mock_obj, 607 internal::CallReaction reaction) 608 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 609 internal::MutexLock l(&internal::g_gmock_mutex); 610 g_uninteresting_call_reaction[mock_obj] = reaction; 611 } 612 613 } // namespace 614 615 // Tells Google Mock to allow uninteresting calls on the given mock 616 // object. 617 void Mock::AllowUninterestingCalls(const void* mock_obj) 618 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 619 SetReactionOnUninterestingCalls(mock_obj, internal::kAllow); 620 } 621 622 // Tells Google Mock to warn the user about uninteresting calls on the 623 // given mock object. 624 void Mock::WarnUninterestingCalls(const void* mock_obj) 625 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 626 SetReactionOnUninterestingCalls(mock_obj, internal::kWarn); 627 } 628 629 // Tells Google Mock to fail uninteresting calls on the given mock 630 // object. 631 void Mock::FailUninterestingCalls(const void* mock_obj) 632 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 633 SetReactionOnUninterestingCalls(mock_obj, internal::kFail); 634 } 635 636 // Tells Google Mock the given mock object is being destroyed and its 637 // entry in the call-reaction table should be removed. 638 void Mock::UnregisterCallReaction(const void* mock_obj) 639 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 640 internal::MutexLock l(&internal::g_gmock_mutex); 641 g_uninteresting_call_reaction.erase(mock_obj); 642 } 643 644 // Returns the reaction Google Mock will have on uninteresting calls 645 // made on the given mock object. 646 internal::CallReaction Mock::GetReactionOnUninterestingCalls( 647 const void* mock_obj) 648 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 649 internal::MutexLock l(&internal::g_gmock_mutex); 650 return (g_uninteresting_call_reaction.count(mock_obj) == 0) ? 651 internal::kDefault : g_uninteresting_call_reaction[mock_obj]; 652 } 653 654 // Tells Google Mock to ignore mock_obj when checking for leaked mock 655 // objects. 656 void Mock::AllowLeak(const void* mock_obj) 657 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 658 internal::MutexLock l(&internal::g_gmock_mutex); 659 g_mock_object_registry.states()[mock_obj].leakable = true; 660 } 661 662 // Verifies and clears all expectations on the given mock object. If 663 // the expectations aren't satisfied, generates one or more Google 664 // Test non-fatal failures and returns false. 665 bool Mock::VerifyAndClearExpectations(void* mock_obj) 666 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 667 internal::MutexLock l(&internal::g_gmock_mutex); 668 return VerifyAndClearExpectationsLocked(mock_obj); 669 } 670 671 // Verifies all expectations on the given mock object and clears its 672 // default actions and expectations. Returns true iff the 673 // verification was successful. 674 bool Mock::VerifyAndClear(void* mock_obj) 675 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 676 internal::MutexLock l(&internal::g_gmock_mutex); 677 ClearDefaultActionsLocked(mock_obj); 678 return VerifyAndClearExpectationsLocked(mock_obj); 679 } 680 681 // Verifies and clears all expectations on the given mock object. If 682 // the expectations aren't satisfied, generates one or more Google 683 // Test non-fatal failures and returns false. 684 bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj) 685 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { 686 internal::g_gmock_mutex.AssertHeld(); 687 if (g_mock_object_registry.states().count(mock_obj) == 0) { 688 // No EXPECT_CALL() was set on the given mock object. 689 return true; 690 } 691 692 // Verifies and clears the expectations on each mock method in the 693 // given mock object. 694 bool expectations_met = true; 695 FunctionMockers& mockers = 696 g_mock_object_registry.states()[mock_obj].function_mockers; 697 for (FunctionMockers::const_iterator it = mockers.begin(); 698 it != mockers.end(); ++it) { 699 if (!(*it)->VerifyAndClearExpectationsLocked()) { 700 expectations_met = false; 701 } 702 } 703 704 // We don't clear the content of mockers, as they may still be 705 // needed by ClearDefaultActionsLocked(). 706 return expectations_met; 707 } 708 709 // Registers a mock object and a mock method it owns. 710 void Mock::Register(const void* mock_obj, 711 internal::UntypedFunctionMockerBase* mocker) 712 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 713 internal::MutexLock l(&internal::g_gmock_mutex); 714 g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker); 715 } 716 717 // Tells Google Mock where in the source code mock_obj is used in an 718 // ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this 719 // information helps the user identify which object it is. 720 void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj, 721 const char* file, int line) 722 GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 723 internal::MutexLock l(&internal::g_gmock_mutex); 724 MockObjectState& state = g_mock_object_registry.states()[mock_obj]; 725 if (state.first_used_file == NULL) { 726 state.first_used_file = file; 727 state.first_used_line = line; 728 const TestInfo* const test_info = 729 UnitTest::GetInstance()->current_test_info(); 730 if (test_info != NULL) { 731 // TODO(wan (at) google.com): record the test case name when the 732 // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or 733 // TearDownTestCase(). 734 state.first_used_test_case = test_info->test_case_name(); 735 state.first_used_test = test_info->name(); 736 } 737 } 738 } 739 740 // Unregisters a mock method; removes the owning mock object from the 741 // registry when the last mock method associated with it has been 742 // unregistered. This is called only in the destructor of 743 // FunctionMockerBase. 744 void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker) 745 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { 746 internal::g_gmock_mutex.AssertHeld(); 747 for (MockObjectRegistry::StateMap::iterator it = 748 g_mock_object_registry.states().begin(); 749 it != g_mock_object_registry.states().end(); ++it) { 750 FunctionMockers& mockers = it->second.function_mockers; 751 if (mockers.erase(mocker) > 0) { 752 // mocker was in mockers and has been just removed. 753 if (mockers.empty()) { 754 g_mock_object_registry.states().erase(it); 755 } 756 return; 757 } 758 } 759 } 760 761 // Clears all ON_CALL()s set on the given mock object. 762 void Mock::ClearDefaultActionsLocked(void* mock_obj) 763 GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) { 764 internal::g_gmock_mutex.AssertHeld(); 765 766 if (g_mock_object_registry.states().count(mock_obj) == 0) { 767 // No ON_CALL() was set on the given mock object. 768 return; 769 } 770 771 // Clears the default actions for each mock method in the given mock 772 // object. 773 FunctionMockers& mockers = 774 g_mock_object_registry.states()[mock_obj].function_mockers; 775 for (FunctionMockers::const_iterator it = mockers.begin(); 776 it != mockers.end(); ++it) { 777 (*it)->ClearDefaultActionsLocked(); 778 } 779 780 // We don't clear the content of mockers, as they may still be 781 // needed by VerifyAndClearExpectationsLocked(). 782 } 783 784 Expectation::Expectation() {} 785 786 Expectation::Expectation( 787 const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base) 788 : expectation_base_(an_expectation_base) {} 789 790 Expectation::~Expectation() {} 791 792 // Adds an expectation to a sequence. 793 void Sequence::AddExpectation(const Expectation& expectation) const { 794 if (*last_expectation_ != expectation) { 795 if (last_expectation_->expectation_base() != NULL) { 796 expectation.expectation_base()->immediate_prerequisites_ 797 += *last_expectation_; 798 } 799 *last_expectation_ = expectation; 800 } 801 } 802 803 // Creates the implicit sequence if there isn't one. 804 InSequence::InSequence() { 805 if (internal::g_gmock_implicit_sequence.get() == NULL) { 806 internal::g_gmock_implicit_sequence.set(new Sequence); 807 sequence_created_ = true; 808 } else { 809 sequence_created_ = false; 810 } 811 } 812 813 // Deletes the implicit sequence if it was created by the constructor 814 // of this object. 815 InSequence::~InSequence() { 816 if (sequence_created_) { 817 delete internal::g_gmock_implicit_sequence.get(); 818 internal::g_gmock_implicit_sequence.set(NULL); 819 } 820 } 821 822 } // namespace testing 823