gmock-spec-builders.cc 28.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Gennadiy Civil's avatar
 
Gennadiy Civil committed
29

30
31
32
33
34
// Google Mock - a framework for writing C++ mock classes.
//
// This file implements the spec builder syntax (ON_CALL and
// EXPECT_CALL).

35
#include "gmock/gmock-spec-builders.h"
36

37
#include <stdlib.h>
38

39
40
#include <iostream>  // NOLINT
#include <map>
misterg's avatar
misterg committed
41
#include <memory>
42
#include <set>
43
#include <string>
44
#include <unordered_map>
Gennadiy Civil's avatar
Gennadiy Civil committed
45
#include <vector>
46

47
48
#include "gmock/gmock.h"
#include "gtest/gtest.h"
49
#include "gtest/internal/gtest-port.h"
50

51
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
52
#include <unistd.h>  // NOLINT
53
#endif
54
55
56
#if GTEST_OS_QURT
#include <qurt_event.h>
#endif
57

Gennadiy Civil's avatar
 
Gennadiy Civil committed
58
// Silence C4800 (C4800: 'int *const ': forcing value
59
// to bool 'true' or 'false') for MSVC 15
60
61
#if defined(_MSC_VER) && (_MSC_VER == 1900)
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800)
Gennadiy Civil's avatar
 
Gennadiy Civil committed
62
#endif
Gennadiy Civil's avatar
 
Gennadiy Civil committed
63

64
65
66
67
68
namespace testing {
namespace internal {

// Protects the mock object registry (in class Mock), all function
// mockers, and all expectations.
69
GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
70

71
// Logs a message including file and line number information.
72
73
GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
                                const char* file, int line,
74
                                const std::string& message) {
75
  ::std::ostringstream s;
76
77
  s << internal::FormatFileLocation(file, line) << " " << message
    << ::std::endl;
78
79
80
  Log(severity, s.str(), 0);
}

81
// Constructs an ExpectationBase object.
82
83
ExpectationBase::ExpectationBase(const char* a_file, int a_line,
                                 const std::string& a_source_text)
84
85
86
    : file_(a_file),
      line_(a_line),
      source_text_(a_source_text),
87
88
89
      cardinality_specified_(false),
      cardinality_(Exactly(1)),
      call_count_(0),
90
91
92
93
94
95
      retired_(false),
      extra_matcher_specified_(false),
      repeated_action_specified_(false),
      retires_on_saturation_(false),
      last_clause_(kNone),
      action_count_checked_(false) {}
96
97
98
99
100
101

// Destructs an ExpectationBase object.
ExpectationBase::~ExpectationBase() {}

// Explicitly specifies the cardinality of this expectation.  Used by
// the subclasses to implement the .Times() clause.
102
void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
103
  cardinality_specified_ = true;
104
  cardinality_ = a_cardinality;
105
106
107
}

// Retires all pre-requisites of this expectation.
108
109
void ExpectationBase::RetireAllPreRequisites()
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
110
111
112
113
114
115
  if (is_retired()) {
    // We can take this short-cut as we never retire an expectation
    // until we have retired all its pre-requisites.
    return;
  }

Gennadiy Civil's avatar
Gennadiy Civil committed
116
117
118
119
120
121
122
123
124
125
126
127
128
  ::std::vector<ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      ExpectationBase* next = it->expectation_base().get();
      if (!next->is_retired()) {
        next->Retire();
        expectations.push_back(next);
      }
129
130
131
132
    }
  }
}

133
134
// Returns true if and only if all pre-requisites of this expectation
// have been satisfied.
135
136
bool ExpectationBase::AllPrerequisitesAreSatisfied() const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
137
  g_gmock_mutex.AssertHeld();
Gennadiy Civil's avatar
Gennadiy Civil committed
138
139
140
141
142
143
144
145
146
147
148
149
  ::std::vector<const ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    const ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      const ExpectationBase* next = it->expectation_base().get();
      if (!next->IsSatisfied()) return false;
      expectations.push_back(next);
    }
150
151
152
153
154
  }
  return true;
}

// Adds unsatisfied pre-requisites of this expectation to 'result'.
155
156
void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
157
  g_gmock_mutex.AssertHeld();
Gennadiy Civil's avatar
Gennadiy Civil committed
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
  ::std::vector<const ExpectationBase*> expectations(1, this);
  while (!expectations.empty()) {
    const ExpectationBase* exp = expectations.back();
    expectations.pop_back();

    for (ExpectationSet::const_iterator it =
             exp->immediate_prerequisites_.begin();
         it != exp->immediate_prerequisites_.end(); ++it) {
      const ExpectationBase* next = it->expectation_base().get();

      if (next->IsSatisfied()) {
        // If *it is satisfied and has a call count of 0, some of its
        // pre-requisites may not be satisfied yet.
        if (next->call_count_ == 0) {
          expectations.push_back(next);
        }
      } else {
        // Now that we know next is unsatisfied, we are not so interested
        // in whether its pre-requisites are satisfied.  Therefore we
        // don't iterate into it here.
        *result += *it;
179
180
181
182
183
      }
    }
  }
}

184
185
// Describes how many times a function call matching this
// expectation has occurred.
186
187
void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
188
189
190
191
192
193
194
195
196
197
  g_gmock_mutex.AssertHeld();

  // Describes how many times the function is expected to be called.
  *os << "         Expected: to be ";
  cardinality().DescribeTo(os);
  *os << "\n           Actual: ";
  Cardinality::DescribeActualCallCountTo(call_count(), os);

  // Describes the state of the expectation (e.g. is it satisfied?
  // is it active?).
198
199
200
201
202
203
  *os << " - "
      << (IsOverSaturated() ? "over-saturated"
          : IsSaturated()   ? "saturated"
          : IsSatisfied()   ? "satisfied"
                            : "unsatisfied")
      << " and " << (is_retired() ? "retired" : "active");
204
205
206
207
208
209
}

// Checks the action count (i.e. the number of WillOnce() and
// WillRepeatedly() clauses) against the cardinality if this hasn't
// been done before.  Prints a warning if there are too many or too
// few actions.
210
211
void ExpectationBase::CheckActionCountIfNotDone() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
  bool should_check = false;
  {
    MutexLock l(&mutex_);
    if (!action_count_checked_) {
      action_count_checked_ = true;
      should_check = true;
    }
  }

  if (should_check) {
    if (!cardinality_specified_) {
      // The cardinality was inferred - no need to check the action
      // count against it.
      return;
    }

    // The cardinality was explicitly specified.
    const int action_count = static_cast<int>(untyped_actions_.size());
    const int upper_bound = cardinality().ConservativeUpperBound();
    const int lower_bound = cardinality().ConservativeLowerBound();
    bool too_many;  // True if there are too many actions, or false
    // if there are too few.
    if (action_count > upper_bound ||
        (action_count == upper_bound && repeated_action_specified_)) {
      too_many = true;
    } else if (0 < action_count && action_count < lower_bound &&
               !repeated_action_specified_) {
      too_many = false;
    } else {
      return;
    }

    ::std::stringstream ss;
    DescribeLocationTo(&ss);
246
247
    ss << "Too " << (too_many ? "many" : "few") << " actions specified in "
       << source_text() << "...\n"
248
249
       << "Expected to be ";
    cardinality().DescribeTo(&ss);
250
251
    ss << ", but has " << (too_many ? "" : "only ") << action_count
       << " WillOnce()" << (action_count == 1 ? "" : "s");
252
253
254
255
    if (repeated_action_specified_) {
      ss << " and a WillRepeatedly()";
    }
    ss << ".";
zhanyong.wan's avatar
zhanyong.wan committed
256
    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
257
258
259
260
261
262
263
264
265
266
  }
}

// Implements the .Times() clause.
void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
  if (last_clause_ == kTimes) {
    ExpectSpecProperty(false,
                       ".Times() cannot appear "
                       "more than once in an EXPECT_CALL().");
  } else {
267
268
269
    ExpectSpecProperty(
        last_clause_ < kTimes,
        ".Times() may only appear *before* .InSequence(), .WillOnce(), "
Krystian Kuzniarek's avatar
Krystian Kuzniarek committed
270
        ".WillRepeatedly(), or .RetiresOnSaturation(), not after.");
271
272
273
274
275
276
  }
  last_clause_ = kTimes;

  SpecifyCardinality(a_cardinality);
}

277
278
// Points to the implicit sequence introduced by a living InSequence
// object (if any) in the current thread or NULL.
279
GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
280
281
282

// Reports an uninteresting call (whose description is in msg) in the
// manner specified by 'reaction'.
283
void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
284
285
  // Include a stack trace only if --gmock_verbose=info is specified.
  const int stack_frames_to_skip =
Abseil Team's avatar
Abseil Team committed
286
      GMOCK_FLAG_GET(verbose) == kInfoVerbosity ? 3 : -1;
287
  switch (reaction) {
zhanyong.wan's avatar
zhanyong.wan committed
288
    case kAllow:
289
      Log(kInfo, msg, stack_frames_to_skip);
290
      break;
zhanyong.wan's avatar
zhanyong.wan committed
291
    case kWarn:
292
293
      Log(kWarning,
          msg +
Gennadiy Civil's avatar
Gennadiy Civil committed
294
295
296
297
              "\nNOTE: You can safely ignore the above warning unless this "
              "call should not happen.  Do not suppress it by blindly adding "
              "an EXPECT_CALL() if you don't mean to enforce the call.  "
              "See "
assafpr's avatar
assafpr committed
298
              "https://github.com/google/googletest/blob/main/docs/"
Abseil Team's avatar
Abseil Team committed
299
              "gmock_cook_book.md#"
300
              "knowing-when-to-expect-useoncall for details.\n",
301
          stack_frames_to_skip);
302
303
      break;
    default:  // FAIL
304
      Expect(false, nullptr, -1, msg);
305
306
307
  }
}

308
UntypedFunctionMockerBase::UntypedFunctionMockerBase()
309
    : mock_obj_(nullptr), name_("") {}
310
311
312
313
314
315
316

UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}

// Sets the mock object this mock method belongs to, and registers
// this information in the global mock registry.  Will be called
// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
// method.
317
318
void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
319
320
321
322
323
324
325
326
327
328
  {
    MutexLock l(&g_gmock_mutex);
    mock_obj_ = mock_obj;
  }
  Mock::Register(mock_obj, this);
}

// Sets the mock object this mock method belongs to, and sets the name
// of the mock function.  Will be called upon each invocation of this
// mock function.
329
330
331
void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
                                                const char* name)
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
332
333
334
335
336
337
338
339
340
  // We protect name_ under g_gmock_mutex in case this mock function
  // is called from two threads concurrently.
  MutexLock l(&g_gmock_mutex);
  mock_obj_ = mock_obj;
  name_ = name;
}

// Returns the name of the function being mocked.  Must be called
// after RegisterOwner() or SetOwnerAndName() has been called.
341
342
const void* UntypedFunctionMockerBase::MockObject() const
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
343
344
345
346
347
  const void* mock_obj;
  {
    // We protect mock_obj_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
    MutexLock l(&g_gmock_mutex);
348
    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
349
350
351
352
353
354
355
356
357
           "MockObject() must not be called before RegisterOwner() or "
           "SetOwnerAndName() has been called.");
    mock_obj = mock_obj_;
  }
  return mock_obj;
}

// Returns the name of this mock method.  Must be called after
// SetOwnerAndName() has been called.
358
359
const char* UntypedFunctionMockerBase::Name() const
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
360
361
362
363
364
  const char* name;
  {
    // We protect name_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
    MutexLock l(&g_gmock_mutex);
365
    Assert(name_ != nullptr, __FILE__, __LINE__,
366
367
368
369
370
371
372
373
374
375
           "Name() must not be called before SetOwnerAndName() has "
           "been called.");
    name = name_;
  }
  return name;
}

// Returns an Expectation object that references and co-owns exp,
// which must be an expectation on this mock function.
Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
Gennadiy Civil's avatar
Gennadiy Civil committed
376
377
  // See the definition of untyped_expectations_ for why access to it
  // is unprotected here.
378
  for (UntypedExpectations::const_iterator it = untyped_expectations_.begin();
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
       it != untyped_expectations_.end(); ++it) {
    if (it->get() == exp) {
      return Expectation(*it);
    }
  }

  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
  return Expectation();
  // The above statement is just to make the code compile, and will
  // never be executed.
}

// Verifies that all expectations on this mock function have been
// satisfied.  Reports one or more Google Test non-fatal failures
// and returns false if not.
394
395
bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
396
397
  g_gmock_mutex.AssertHeld();
  bool expectations_met = true;
398
  for (UntypedExpectations::const_iterator it = untyped_expectations_.begin();
399
400
401
402
403
404
405
406
407
408
       it != untyped_expectations_.end(); ++it) {
    ExpectationBase* const untyped_expectation = it->get();
    if (untyped_expectation->IsOverSaturated()) {
      // There was an upper-bound violation.  Since the error was
      // already reported when it occurred, there is no need to do
      // anything here.
      expectations_met = false;
    } else if (!untyped_expectation->IsSatisfied()) {
      expectations_met = false;
      ::std::stringstream ss;
409

410
411
412
      const ::std::string& expectation_name =
          untyped_expectation->GetDescription();
      ss << "Actual function ";
413
      if (!expectation_name.empty()) {
414
        ss << "\"" << expectation_name << "\" ";
415
      }
416
417
      ss << "call count doesn't match " << untyped_expectation->source_text()
         << "...\n";
418
419
420
421
422
      // No need to show the source file location of the expectation
      // in the description, as the Expect() call that follows already
      // takes care of it.
      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
      untyped_expectation->DescribeCallCountTo(&ss);
423
424
      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
             ss.str());
425
426
    }
  }
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441

  // Deleting our expectations may trigger other mock objects to be deleted, for
  // example if an action contains a reference counted smart pointer to that
  // mock object, and that is the last reference. So if we delete our
  // expectations within the context of the global mutex we may deadlock when
  // this method is called again. Instead, make a copy of the set of
  // expectations to delete, clear our set within the mutex, and then clear the
  // copied set outside of it.
  UntypedExpectations expectations_to_delete;
  untyped_expectations_.swap(expectations_to_delete);

  g_gmock_mutex.Unlock();
  expectations_to_delete.clear();
  g_gmock_mutex.Lock();

442
443
444
  return expectations_met;
}

445
static CallReaction intToCallReaction(int mock_behavior) {
Alyssa Wilk's avatar
Alyssa Wilk committed
446
447
448
449
450
451
  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
    return static_cast<internal::CallReaction>(mock_behavior);
  }
  return kWarn;
}

452
453
454
455
456
457
458
459
}  // namespace internal

// Class Mock.

namespace {

typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;

460
461
462
463
464
// The current state of a mock object.  Such information is needed for
// detecting leaked mock objects and explicitly verifying a mock's
// expectations.
struct MockObjectState {
  MockObjectState()
465
      : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
466
467
468
469
470

  // Where in the source file an ON_CALL or EXPECT_CALL is first
  // invoked on this mock object.
  const char* first_used_file;
  int first_used_line;
misterg's avatar
misterg committed
471
  ::std::string first_used_test_suite;
472
  ::std::string first_used_test;
473
  bool leakable;  // true if and only if it's OK to leak the object.
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
  FunctionMockers function_mockers;  // All registered methods of the object.
};

// A global registry holding the state of all mock objects that are
// alive.  A mock object is added to this registry the first time
// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
// is removed from the registry in the mock object's destructor.
class MockObjectRegistry {
 public:
  // Maps a mock object (identified by its address) to its state.
  typedef std::map<const void*, MockObjectState> StateMap;

  // This destructor will be called when a program exits, after all
  // tests in it have been run.  By then, there should be no mock
  // object alive.  Therefore we report any living object as test
  // failure, unless the user explicitly asked us to ignore it.
  ~MockObjectRegistry() {
Abseil Team's avatar
Abseil Team committed
491
    if (!GMOCK_FLAG_GET(catch_leaked_mocks)) return;
492
493
494
495
496
497
498

    int leaked_count = 0;
    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
         ++it) {
      if (it->second.leakable)  // The user said it's fine to leak this object.
        continue;

Gennadiy Civil's avatar
Gennadiy Civil committed
499
      // FIXME: Print the type of the leaked object.
500
      // This can help the user identify the leaked object.
501
      std::cout << "\n";
502
      const MockObjectState& state = it->second;
503
504
      std::cout << internal::FormatFileLocation(state.first_used_file,
                                                state.first_used_line);
505
      std::cout << " ERROR: this mock object";
Abseil Team's avatar
Abseil Team committed
506
      if (!state.first_used_test.empty()) {
misterg's avatar
misterg committed
507
508
        std::cout << " (used in test " << state.first_used_test_suite << "."
                  << state.first_used_test << ")";
509
      }
510
      std::cout << " should be deleted but never is. Its address is @"
511
                << it->first << ".";
512
513
514
      leaked_count++;
    }
    if (leaked_count > 0) {
Gennadiy Civil's avatar
Gennadiy Civil committed
515
516
      std::cout << "\nERROR: " << leaked_count << " leaked mock "
                << (leaked_count == 1 ? "object" : "objects")
Abseil Team's avatar
Abseil Team committed
517
                << " found at program exit. Expectations on a mock object are "
Gennadiy Civil's avatar
Gennadiy Civil committed
518
519
520
521
522
523
                   "verified when the object is destructed. Leaking a mock "
                   "means that its expectations aren't verified, which is "
                   "usually a test bug. If you really intend to leak a mock, "
                   "you can suppress this error using "
                   "testing::Mock::AllowLeak(mock_object), or you may use a "
                   "fake or stub instead of a mock.\n";
524
      std::cout.flush();
525
526
527
528
      ::std::cerr.flush();
      // RUN_ALL_TESTS() has already returned when this destructor is
      // called.  Therefore we cannot use the normal Google Test
      // failure reporting mechanism.
529
530
531
#if GTEST_OS_QURT
      qurt_exception_raise_fatal();
#else
532
533
      _exit(1);  // We cannot call exit() as it is not reentrant and
                 // may already have been called.
534
#endif
535
536
537
538
    }
  }

  StateMap& states() { return states_; }
539

540
541
542
543
544
 private:
  StateMap states_;
};

// Protected by g_gmock_mutex.
545
546
547
548
MockObjectRegistry g_mock_object_registry;

// Maps a mock object to the reaction Google Mock should have when an
// uninteresting method is called.  Protected by g_gmock_mutex.
549
550
551
552
553
std::unordered_map<uintptr_t, internal::CallReaction>&
UninterestingCallReactionMap() {
  static auto* map = new std::unordered_map<uintptr_t, internal::CallReaction>;
  return *map;
}
554
555
556

// Sets the reaction Google Mock should have when an uninteresting
// method of the given mock object is called.
557
void SetReactionOnUninterestingCalls(uintptr_t mock_obj,
558
559
                                     internal::CallReaction reaction)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
560
  internal::MutexLock l(&internal::g_gmock_mutex);
561
  UninterestingCallReactionMap()[mock_obj] = reaction;
562
563
564
565
566
567
}

}  // namespace

// Tells Google Mock to allow uninteresting calls on the given mock
// object.
568
void Mock::AllowUninterestingCalls(uintptr_t mock_obj)
569
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
zhanyong.wan's avatar
zhanyong.wan committed
570
  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
571
572
573
574
}

// Tells Google Mock to warn the user about uninteresting calls on the
// given mock object.
575
void Mock::WarnUninterestingCalls(uintptr_t mock_obj)
576
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
zhanyong.wan's avatar
zhanyong.wan committed
577
  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
578
579
580
581
}

// Tells Google Mock to fail uninteresting calls on the given mock
// object.
582
void Mock::FailUninterestingCalls(uintptr_t mock_obj)
583
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
zhanyong.wan's avatar
zhanyong.wan committed
584
  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
585
586
587
588
}

// Tells Google Mock the given mock object is being destroyed and its
// entry in the call-reaction table should be removed.
589
void Mock::UnregisterCallReaction(uintptr_t mock_obj)
590
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
591
  internal::MutexLock l(&internal::g_gmock_mutex);
592
  UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj));
593
594
595
596
597
}

// Returns the reaction Google Mock will have on uninteresting calls
// made on the given mock object.
internal::CallReaction Mock::GetReactionOnUninterestingCalls(
598
    const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
599
  internal::MutexLock l(&internal::g_gmock_mutex);
600
601
  return (UninterestingCallReactionMap().count(
              reinterpret_cast<uintptr_t>(mock_obj)) == 0)
Abseil Team's avatar
Abseil Team committed
602
603
             ? internal::intToCallReaction(
                   GMOCK_FLAG_GET(default_mock_behavior))
604
605
             : UninterestingCallReactionMap()[reinterpret_cast<uintptr_t>(
                   mock_obj)];
606
607
}

608
609
// Tells Google Mock to ignore mock_obj when checking for leaked mock
// objects.
610
611
void Mock::AllowLeak(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
612
613
614
615
  internal::MutexLock l(&internal::g_gmock_mutex);
  g_mock_object_registry.states()[mock_obj].leakable = true;
}

616
617
618
// Verifies and clears all expectations on the given mock object.  If
// the expectations aren't satisfied, generates one or more Google
// Test non-fatal failures and returns false.
619
620
bool Mock::VerifyAndClearExpectations(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
621
622
623
624
625
  internal::MutexLock l(&internal::g_gmock_mutex);
  return VerifyAndClearExpectationsLocked(mock_obj);
}

// Verifies all expectations on the given mock object and clears its
626
// default actions and expectations.  Returns true if and only if the
627
// verification was successful.
628
629
bool Mock::VerifyAndClear(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
630
631
632
633
634
635
636
637
  internal::MutexLock l(&internal::g_gmock_mutex);
  ClearDefaultActionsLocked(mock_obj);
  return VerifyAndClearExpectationsLocked(mock_obj);
}

// Verifies and clears all expectations on the given mock object.  If
// the expectations aren't satisfied, generates one or more Google
// Test non-fatal failures and returns false.
638
639
bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
640
  internal::g_gmock_mutex.AssertHeld();
641
  if (g_mock_object_registry.states().count(mock_obj) == 0) {
642
643
644
645
646
647
648
    // No EXPECT_CALL() was set on the given mock object.
    return true;
  }

  // Verifies and clears the expectations on each mock method in the
  // given mock object.
  bool expectations_met = true;
649
650
  FunctionMockers& mockers =
      g_mock_object_registry.states()[mock_obj].function_mockers;
651
652
653
654
655
656
657
658
659
660
661
662
  for (FunctionMockers::const_iterator it = mockers.begin();
       it != mockers.end(); ++it) {
    if (!(*it)->VerifyAndClearExpectationsLocked()) {
      expectations_met = false;
    }
  }

  // We don't clear the content of mockers, as they may still be
  // needed by ClearDefaultActionsLocked().
  return expectations_met;
}

663
664
bool Mock::IsNaggy(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
665
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn;
666
667
668
}
bool Mock::IsNice(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
669
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow;
670
671
672
}
bool Mock::IsStrict(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
673
  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail;
674
675
}

676
677
// Registers a mock object and a mock method it owns.
void Mock::Register(const void* mock_obj,
678
679
                    internal::UntypedFunctionMockerBase* mocker)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
680
  internal::MutexLock l(&internal::g_gmock_mutex);
681
682
683
684
685
686
  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
}

// Tells Google Mock where in the source code mock_obj is used in an
// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
// information helps the user identify which object it is.
687
688
689
void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
                                           const char* file, int line)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
690
691
  internal::MutexLock l(&internal::g_gmock_mutex);
  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
692
  if (state.first_used_file == nullptr) {
693
694
    state.first_used_file = file;
    state.first_used_line = line;
695
696
    const TestInfo* const test_info =
        UnitTest::GetInstance()->current_test_info();
697
    if (test_info != nullptr) {
misterg's avatar
misterg committed
698
      state.first_used_test_suite = test_info->test_suite_name();
699
700
      state.first_used_test = test_info->name();
    }
701
  }
702
703
704
705
706
707
}

// Unregisters a mock method; removes the owning mock object from the
// registry when the last mock method associated with it has been
// unregistered.  This is called only in the destructor of
// FunctionMockerBase.
708
709
void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
710
  internal::g_gmock_mutex.AssertHeld();
711
712
713
714
  for (MockObjectRegistry::StateMap::iterator it =
           g_mock_object_registry.states().begin();
       it != g_mock_object_registry.states().end(); ++it) {
    FunctionMockers& mockers = it->second.function_mockers;
715
716
717
    if (mockers.erase(mocker) > 0) {
      // mocker was in mockers and has been just removed.
      if (mockers.empty()) {
718
        g_mock_object_registry.states().erase(it);
719
720
721
722
723
724
725
      }
      return;
    }
  }
}

// Clears all ON_CALL()s set on the given mock object.
726
727
void Mock::ClearDefaultActionsLocked(void* mock_obj)
    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
728
729
  internal::g_gmock_mutex.AssertHeld();

730
  if (g_mock_object_registry.states().count(mock_obj) == 0) {
731
732
733
734
735
736
    // No ON_CALL() was set on the given mock object.
    return;
  }

  // Clears the default actions for each mock method in the given mock
  // object.
737
738
  FunctionMockers& mockers =
      g_mock_object_registry.states()[mock_obj].function_mockers;
739
740
741
742
743
744
745
746
747
  for (FunctionMockers::const_iterator it = mockers.begin();
       it != mockers.end(); ++it) {
    (*it)->ClearDefaultActionsLocked();
  }

  // We don't clear the content of mockers, as they may still be
  // needed by VerifyAndClearExpectationsLocked().
}

748
749
750
Expectation::Expectation() {}

Expectation::Expectation(
misterg's avatar
misterg committed
751
    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
752
    : expectation_base_(an_expectation_base) {}
753
754
755

Expectation::~Expectation() {}

756
// Adds an expectation to a sequence.
757
void Sequence::AddExpectation(const Expectation& expectation) const {
758
  if (*last_expectation_ != expectation) {
759
    if (last_expectation_->expectation_base() != nullptr) {
760
761
      expectation.expectation_base()->immediate_prerequisites_ +=
          *last_expectation_;
762
763
764
765
766
767
768
    }
    *last_expectation_ = expectation;
  }
}

// Creates the implicit sequence if there isn't one.
InSequence::InSequence() {
769
  if (internal::g_gmock_implicit_sequence.get() == nullptr) {
770
771
772
773
774
775
776
777
778
779
780
781
    internal::g_gmock_implicit_sequence.set(new Sequence);
    sequence_created_ = true;
  } else {
    sequence_created_ = false;
  }
}

// Deletes the implicit sequence if it was created by the constructor
// of this object.
InSequence::~InSequence() {
  if (sequence_created_) {
    delete internal::g_gmock_implicit_sequence.get();
782
    internal::g_gmock_implicit_sequence.set(nullptr);
783
784
785
786
  }
}

}  // namespace testing
Gennadiy Civil's avatar
 
Gennadiy Civil committed
787

788
789
#if defined(_MSC_VER) && (_MSC_VER == 1900)
GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4800
Gennadiy Civil's avatar
 
Gennadiy Civil committed
790
#endif