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