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