PageRenderTime 78ms CodeModel.GetById 17ms app.highlight 49ms RepoModel.GetById 1ms app.codeStats 1ms

/testlibs/gmock/include/gmock/gmock-spec-builders.h

https://github.com/deltaforge/nebu-app-mongo
C Header | 1749 lines | 873 code | 249 blank | 627 comment | 61 complexity | 89b340ccf0bd3a5abea06db2622c550e MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1// Copyright 2007, Google Inc.
   2// All rights reserved.
   3//
   4// Redistribution and use in source and binary forms, with or without
   5// modification, are permitted provided that the following conditions are
   6// met:
   7//
   8//     * Redistributions of source code must retain the above copyright
   9// notice, this list of conditions and the following disclaimer.
  10//     * Redistributions in binary form must reproduce the above
  11// copyright notice, this list of conditions and the following disclaimer
  12// in the documentation and/or other materials provided with the
  13// distribution.
  14//     * Neither the name of Google Inc. nor the names of its
  15// contributors may be used to endorse or promote products derived from
  16// this software without specific prior written permission.
  17//
  18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29//
  30// Author: wan@google.com (Zhanyong Wan)
  31
  32// Google Mock - a framework for writing C++ mock classes.
  33//
  34// This file implements the ON_CALL() and EXPECT_CALL() macros.
  35//
  36// A user can use the ON_CALL() macro to specify the default action of
  37// a mock method.  The syntax is:
  38//
  39//   ON_CALL(mock_object, Method(argument-matchers))
  40//       .With(multi-argument-matcher)
  41//       .WillByDefault(action);
  42//
  43//  where the .With() clause is optional.
  44//
  45// A user can use the EXPECT_CALL() macro to specify an expectation on
  46// a mock method.  The syntax is:
  47//
  48//   EXPECT_CALL(mock_object, Method(argument-matchers))
  49//       .With(multi-argument-matchers)
  50//       .Times(cardinality)
  51//       .InSequence(sequences)
  52//       .After(expectations)
  53//       .WillOnce(action)
  54//       .WillRepeatedly(action)
  55//       .RetiresOnSaturation();
  56//
  57// where all clauses are optional, and .InSequence()/.After()/
  58// .WillOnce() can appear any number of times.
  59
  60#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
  61#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
  62
  63#include <map>
  64#include <set>
  65#include <sstream>
  66#include <string>
  67#include <vector>
  68
  69#include "gmock/gmock-actions.h"
  70#include "gmock/gmock-cardinalities.h"
  71#include "gmock/gmock-matchers.h"
  72#include "gmock/internal/gmock-internal-utils.h"
  73#include "gmock/internal/gmock-port.h"
  74#include "gtest/gtest.h"
  75
  76namespace testing {
  77
  78// An abstract handle of an expectation.
  79class Expectation;
  80
  81// A set of expectation handles.
  82class ExpectationSet;
  83
  84// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
  85// and MUST NOT BE USED IN USER CODE!!!
  86namespace internal {
  87
  88// Implements a mock function.
  89template <typename F> class FunctionMocker;
  90
  91// Base class for expectations.
  92class ExpectationBase;
  93
  94// Implements an expectation.
  95template <typename F> class TypedExpectation;
  96
  97// Helper class for testing the Expectation class template.
  98class ExpectationTester;
  99
 100// Base class for function mockers.
 101template <typename F> class FunctionMockerBase;
 102
 103// Protects the mock object registry (in class Mock), all function
 104// mockers, and all expectations.
 105//
 106// The reason we don't use more fine-grained protection is: when a
 107// mock function Foo() is called, it needs to consult its expectations
 108// to see which one should be picked.  If another thread is allowed to
 109// call a mock function (either Foo() or a different one) at the same
 110// time, it could affect the "retired" attributes of Foo()'s
 111// expectations when InSequence() is used, and thus affect which
 112// expectation gets picked.  Therefore, we sequence all mock function
 113// calls to ensure the integrity of the mock objects' states.
 114GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
 115
 116// Untyped base class for ActionResultHolder<R>.
 117class UntypedActionResultHolderBase;
 118
 119// Abstract base class of FunctionMockerBase.  This is the
 120// type-agnostic part of the function mocker interface.  Its pure
 121// virtual methods are implemented by FunctionMockerBase.
 122class UntypedFunctionMockerBase {
 123 public:
 124  UntypedFunctionMockerBase();
 125  virtual ~UntypedFunctionMockerBase();
 126
 127  // Verifies that all expectations on this mock function have been
 128  // satisfied.  Reports one or more Google Test non-fatal failures
 129  // and returns false if not.
 130  // L >= g_gmock_mutex
 131  bool VerifyAndClearExpectationsLocked();
 132
 133  // Clears the ON_CALL()s set on this mock function.
 134  // L >= g_gmock_mutex
 135  virtual void ClearDefaultActionsLocked() = 0;
 136
 137  // In all of the following Untyped* functions, it's the caller's
 138  // responsibility to guarantee the correctness of the arguments'
 139  // types.
 140
 141  // Performs the default action with the given arguments and returns
 142  // the action's result.  The call description string will be used in
 143  // the error message to describe the call in the case the default
 144  // action fails.
 145  // L = *
 146  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
 147      const void* untyped_args,
 148      const string& call_description) const = 0;
 149
 150  // Performs the given action with the given arguments and returns
 151  // the action's result.
 152  // L = *
 153  virtual UntypedActionResultHolderBase* UntypedPerformAction(
 154      const void* untyped_action,
 155      const void* untyped_args) const = 0;
 156
 157  // Writes a message that the call is uninteresting (i.e. neither
 158  // explicitly expected nor explicitly unexpected) to the given
 159  // ostream.
 160  // L < g_gmock_mutex
 161  virtual void UntypedDescribeUninterestingCall(const void* untyped_args,
 162                                                ::std::ostream* os) const = 0;
 163
 164  // Returns the expectation that matches the given function arguments
 165  // (or NULL is there's no match); when a match is found,
 166  // untyped_action is set to point to the action that should be
 167  // performed (or NULL if the action is "do default"), and
 168  // is_excessive is modified to indicate whether the call exceeds the
 169  // expected number.
 170  // L < g_gmock_mutex
 171  virtual const ExpectationBase* UntypedFindMatchingExpectation(
 172      const void* untyped_args,
 173      const void** untyped_action, bool* is_excessive,
 174      ::std::ostream* what, ::std::ostream* why) = 0;
 175
 176  // Prints the given function arguments to the ostream.
 177  virtual void UntypedPrintArgs(const void* untyped_args,
 178                                ::std::ostream* os) const = 0;
 179
 180  // Sets the mock object this mock method belongs to, and registers
 181  // this information in the global mock registry.  Will be called
 182  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
 183  // method.
 184  // TODO(wan@google.com): rename to SetAndRegisterOwner().
 185  // L < g_gmock_mutex
 186  void RegisterOwner(const void* mock_obj);
 187
 188  // Sets the mock object this mock method belongs to, and sets the
 189  // name of the mock function.  Will be called upon each invocation
 190  // of this mock function.
 191  // L < g_gmock_mutex
 192  void SetOwnerAndName(const void* mock_obj, const char* name);
 193
 194  // Returns the mock object this mock method belongs to.  Must be
 195  // called after RegisterOwner() or SetOwnerAndName() has been
 196  // called.
 197  // L < g_gmock_mutex
 198  const void* MockObject() const;
 199
 200  // Returns the name of this mock method.  Must be called after
 201  // SetOwnerAndName() has been called.
 202  // L < g_gmock_mutex
 203  const char* Name() const;
 204
 205  // Returns the result of invoking this mock function with the given
 206  // arguments.  This function can be safely called from multiple
 207  // threads concurrently.  The caller is responsible for deleting the
 208  // result.
 209  // L < g_gmock_mutex
 210  const UntypedActionResultHolderBase* UntypedInvokeWith(
 211      const void* untyped_args);
 212
 213 protected:
 214  typedef std::vector<const void*> UntypedOnCallSpecs;
 215
 216  typedef std::vector<internal::linked_ptr<ExpectationBase> >
 217  UntypedExpectations;
 218
 219  // Returns an Expectation object that references and co-owns exp,
 220  // which must be an expectation on this mock function.
 221  Expectation GetHandleOf(ExpectationBase* exp);
 222
 223  // Address of the mock object this mock method belongs to.  Only
 224  // valid after this mock method has been called or
 225  // ON_CALL/EXPECT_CALL has been invoked on it.
 226  const void* mock_obj_;  // Protected by g_gmock_mutex.
 227
 228  // Name of the function being mocked.  Only valid after this mock
 229  // method has been called.
 230  const char* name_;  // Protected by g_gmock_mutex.
 231
 232  // All default action specs for this function mocker.
 233  UntypedOnCallSpecs untyped_on_call_specs_;
 234
 235  // All expectations for this function mocker.
 236  UntypedExpectations untyped_expectations_;
 237};  // class UntypedFunctionMockerBase
 238
 239// Untyped base class for OnCallSpec<F>.
 240class UntypedOnCallSpecBase {
 241 public:
 242  // The arguments are the location of the ON_CALL() statement.
 243  UntypedOnCallSpecBase(const char* a_file, int a_line)
 244      : file_(a_file), line_(a_line), last_clause_(kNone) {}
 245
 246  // Where in the source file was the default action spec defined?
 247  const char* file() const { return file_; }
 248  int line() const { return line_; }
 249
 250 protected:
 251  // Gives each clause in the ON_CALL() statement a name.
 252  enum Clause {
 253    // Do not change the order of the enum members!  The run-time
 254    // syntax checking relies on it.
 255    kNone,
 256    kWith,
 257    kWillByDefault
 258  };
 259
 260  // Asserts that the ON_CALL() statement has a certain property.
 261  void AssertSpecProperty(bool property, const string& failure_message) const {
 262    Assert(property, file_, line_, failure_message);
 263  }
 264
 265  // Expects that the ON_CALL() statement has a certain property.
 266  void ExpectSpecProperty(bool property, const string& failure_message) const {
 267    Expect(property, file_, line_, failure_message);
 268  }
 269
 270  const char* file_;
 271  int line_;
 272
 273  // The last clause in the ON_CALL() statement as seen so far.
 274  // Initially kNone and changes as the statement is parsed.
 275  Clause last_clause_;
 276};  // class UntypedOnCallSpecBase
 277
 278// This template class implements an ON_CALL spec.
 279template <typename F>
 280class OnCallSpec : public UntypedOnCallSpecBase {
 281 public:
 282  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
 283  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
 284
 285  // Constructs an OnCallSpec object from the information inside
 286  // the parenthesis of an ON_CALL() statement.
 287  OnCallSpec(const char* a_file, int a_line,
 288             const ArgumentMatcherTuple& matchers)
 289      : UntypedOnCallSpecBase(a_file, a_line),
 290        matchers_(matchers),
 291        // By default, extra_matcher_ should match anything.  However,
 292        // we cannot initialize it with _ as that triggers a compiler
 293        // bug in Symbian's C++ compiler (cannot decide between two
 294        // overloaded constructors of Matcher<const ArgumentTuple&>).
 295        extra_matcher_(A<const ArgumentTuple&>()) {
 296  }
 297
 298  // Implements the .With() clause.
 299  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
 300    // Makes sure this is called at most once.
 301    ExpectSpecProperty(last_clause_ < kWith,
 302                       ".With() cannot appear "
 303                       "more than once in an ON_CALL().");
 304    last_clause_ = kWith;
 305
 306    extra_matcher_ = m;
 307    return *this;
 308  }
 309
 310  // Implements the .WillByDefault() clause.
 311  OnCallSpec& WillByDefault(const Action<F>& action) {
 312    ExpectSpecProperty(last_clause_ < kWillByDefault,
 313                       ".WillByDefault() must appear "
 314                       "exactly once in an ON_CALL().");
 315    last_clause_ = kWillByDefault;
 316
 317    ExpectSpecProperty(!action.IsDoDefault(),
 318                       "DoDefault() cannot be used in ON_CALL().");
 319    action_ = action;
 320    return *this;
 321  }
 322
 323  // Returns true iff the given arguments match the matchers.
 324  bool Matches(const ArgumentTuple& args) const {
 325    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
 326  }
 327
 328  // Returns the action specified by the user.
 329  const Action<F>& GetAction() const {
 330    AssertSpecProperty(last_clause_ == kWillByDefault,
 331                       ".WillByDefault() must appear exactly "
 332                       "once in an ON_CALL().");
 333    return action_;
 334  }
 335
 336 private:
 337  // The information in statement
 338  //
 339  //   ON_CALL(mock_object, Method(matchers))
 340  //       .With(multi-argument-matcher)
 341  //       .WillByDefault(action);
 342  //
 343  // is recorded in the data members like this:
 344  //
 345  //   source file that contains the statement => file_
 346  //   line number of the statement            => line_
 347  //   matchers                                => matchers_
 348  //   multi-argument-matcher                  => extra_matcher_
 349  //   action                                  => action_
 350  ArgumentMatcherTuple matchers_;
 351  Matcher<const ArgumentTuple&> extra_matcher_;
 352  Action<F> action_;
 353};  // class OnCallSpec
 354
 355// Possible reactions on uninteresting calls.  TODO(wan@google.com):
 356// rename the enum values to the kFoo style.
 357enum CallReaction {
 358  ALLOW,
 359  WARN,
 360  FAIL
 361};
 362
 363}  // namespace internal
 364
 365// Utilities for manipulating mock objects.
 366class Mock {
 367 public:
 368  // The following public methods can be called concurrently.
 369
 370  // Tells Google Mock to ignore mock_obj when checking for leaked
 371  // mock objects.
 372  static void AllowLeak(const void* mock_obj);
 373
 374  // Verifies and clears all expectations on the given mock object.
 375  // If the expectations aren't satisfied, generates one or more
 376  // Google Test non-fatal failures and returns false.
 377  static bool VerifyAndClearExpectations(void* mock_obj);
 378
 379  // Verifies all expectations on the given mock object and clears its
 380  // default actions and expectations.  Returns true iff the
 381  // verification was successful.
 382  static bool VerifyAndClear(void* mock_obj);
 383 private:
 384  friend class internal::UntypedFunctionMockerBase;
 385
 386  // Needed for a function mocker to register itself (so that we know
 387  // how to clear a mock object).
 388  template <typename F>
 389  friend class internal::FunctionMockerBase;
 390
 391  template <typename M>
 392  friend class NiceMock;
 393
 394  template <typename M>
 395  friend class StrictMock;
 396
 397  // Tells Google Mock to allow uninteresting calls on the given mock
 398  // object.
 399  // L < g_gmock_mutex
 400  static void AllowUninterestingCalls(const void* mock_obj);
 401
 402  // Tells Google Mock to warn the user about uninteresting calls on
 403  // the given mock object.
 404  // L < g_gmock_mutex
 405  static void WarnUninterestingCalls(const void* mock_obj);
 406
 407  // Tells Google Mock to fail uninteresting calls on the given mock
 408  // object.
 409  // L < g_gmock_mutex
 410  static void FailUninterestingCalls(const void* mock_obj);
 411
 412  // Tells Google Mock the given mock object is being destroyed and
 413  // its entry in the call-reaction table should be removed.
 414  // L < g_gmock_mutex
 415  static void UnregisterCallReaction(const void* mock_obj);
 416
 417  // Returns the reaction Google Mock will have on uninteresting calls
 418  // made on the given mock object.
 419  // L < g_gmock_mutex
 420  static internal::CallReaction GetReactionOnUninterestingCalls(
 421      const void* mock_obj);
 422
 423  // Verifies that all expectations on the given mock object have been
 424  // satisfied.  Reports one or more Google Test non-fatal failures
 425  // and returns false if not.
 426  // L >= g_gmock_mutex
 427  static bool VerifyAndClearExpectationsLocked(void* mock_obj);
 428
 429  // Clears all ON_CALL()s set on the given mock object.
 430  // L >= g_gmock_mutex
 431  static void ClearDefaultActionsLocked(void* mock_obj);
 432
 433  // Registers a mock object and a mock method it owns.
 434  // L < g_gmock_mutex
 435  static void Register(const void* mock_obj,
 436                       internal::UntypedFunctionMockerBase* mocker);
 437
 438  // Tells Google Mock where in the source code mock_obj is used in an
 439  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
 440  // information helps the user identify which object it is.
 441  // L < g_gmock_mutex
 442  static void RegisterUseByOnCallOrExpectCall(
 443      const void* mock_obj, const char* file, int line);
 444
 445  // Unregisters a mock method; removes the owning mock object from
 446  // the registry when the last mock method associated with it has
 447  // been unregistered.  This is called only in the destructor of
 448  // FunctionMockerBase.
 449  // L >= g_gmock_mutex
 450  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker);
 451};  // class Mock
 452
 453// An abstract handle of an expectation.  Useful in the .After()
 454// clause of EXPECT_CALL() for setting the (partial) order of
 455// expectations.  The syntax:
 456//
 457//   Expectation e1 = EXPECT_CALL(...)...;
 458//   EXPECT_CALL(...).After(e1)...;
 459//
 460// sets two expectations where the latter can only be matched after
 461// the former has been satisfied.
 462//
 463// Notes:
 464//   - This class is copyable and has value semantics.
 465//   - Constness is shallow: a const Expectation object itself cannot
 466//     be modified, but the mutable methods of the ExpectationBase
 467//     object it references can be called via expectation_base().
 468//   - The constructors and destructor are defined out-of-line because
 469//     the Symbian WINSCW compiler wants to otherwise instantiate them
 470//     when it sees this class definition, at which point it doesn't have
 471//     ExpectationBase available yet, leading to incorrect destruction
 472//     in the linked_ptr (or compilation errors if using a checking
 473//     linked_ptr).
 474class Expectation {
 475 public:
 476  // Constructs a null object that doesn't reference any expectation.
 477  Expectation();
 478
 479  ~Expectation();
 480
 481  // This single-argument ctor must not be explicit, in order to support the
 482  //   Expectation e = EXPECT_CALL(...);
 483  // syntax.
 484  //
 485  // A TypedExpectation object stores its pre-requisites as
 486  // Expectation objects, and needs to call the non-const Retire()
 487  // method on the ExpectationBase objects they reference.  Therefore
 488  // Expectation must receive a *non-const* reference to the
 489  // ExpectationBase object.
 490  Expectation(internal::ExpectationBase& exp);  // NOLINT
 491
 492  // The compiler-generated copy ctor and operator= work exactly as
 493  // intended, so we don't need to define our own.
 494
 495  // Returns true iff rhs references the same expectation as this object does.
 496  bool operator==(const Expectation& rhs) const {
 497    return expectation_base_ == rhs.expectation_base_;
 498  }
 499
 500  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
 501
 502 private:
 503  friend class ExpectationSet;
 504  friend class Sequence;
 505  friend class ::testing::internal::ExpectationBase;
 506  friend class ::testing::internal::UntypedFunctionMockerBase;
 507
 508  template <typename F>
 509  friend class ::testing::internal::FunctionMockerBase;
 510
 511  template <typename F>
 512  friend class ::testing::internal::TypedExpectation;
 513
 514  // This comparator is needed for putting Expectation objects into a set.
 515  class Less {
 516   public:
 517    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
 518      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
 519    }
 520  };
 521
 522  typedef ::std::set<Expectation, Less> Set;
 523
 524  Expectation(
 525      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
 526
 527  // Returns the expectation this object references.
 528  const internal::linked_ptr<internal::ExpectationBase>&
 529  expectation_base() const {
 530    return expectation_base_;
 531  }
 532
 533  // A linked_ptr that co-owns the expectation this handle references.
 534  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
 535};
 536
 537// A set of expectation handles.  Useful in the .After() clause of
 538// EXPECT_CALL() for setting the (partial) order of expectations.  The
 539// syntax:
 540//
 541//   ExpectationSet es;
 542//   es += EXPECT_CALL(...)...;
 543//   es += EXPECT_CALL(...)...;
 544//   EXPECT_CALL(...).After(es)...;
 545//
 546// sets three expectations where the last one can only be matched
 547// after the first two have both been satisfied.
 548//
 549// This class is copyable and has value semantics.
 550class ExpectationSet {
 551 public:
 552  // A bidirectional iterator that can read a const element in the set.
 553  typedef Expectation::Set::const_iterator const_iterator;
 554
 555  // An object stored in the set.  This is an alias of Expectation.
 556  typedef Expectation::Set::value_type value_type;
 557
 558  // Constructs an empty set.
 559  ExpectationSet() {}
 560
 561  // This single-argument ctor must not be explicit, in order to support the
 562  //   ExpectationSet es = EXPECT_CALL(...);
 563  // syntax.
 564  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
 565    *this += Expectation(exp);
 566  }
 567
 568  // This single-argument ctor implements implicit conversion from
 569  // Expectation and thus must not be explicit.  This allows either an
 570  // Expectation or an ExpectationSet to be used in .After().
 571  ExpectationSet(const Expectation& e) {  // NOLINT
 572    *this += e;
 573  }
 574
 575  // The compiler-generator ctor and operator= works exactly as
 576  // intended, so we don't need to define our own.
 577
 578  // Returns true iff rhs contains the same set of Expectation objects
 579  // as this does.
 580  bool operator==(const ExpectationSet& rhs) const {
 581    return expectations_ == rhs.expectations_;
 582  }
 583
 584  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
 585
 586  // Implements the syntax
 587  //   expectation_set += EXPECT_CALL(...);
 588  ExpectationSet& operator+=(const Expectation& e) {
 589    expectations_.insert(e);
 590    return *this;
 591  }
 592
 593  int size() const { return static_cast<int>(expectations_.size()); }
 594
 595  const_iterator begin() const { return expectations_.begin(); }
 596  const_iterator end() const { return expectations_.end(); }
 597
 598 private:
 599  Expectation::Set expectations_;
 600};
 601
 602
 603// Sequence objects are used by a user to specify the relative order
 604// in which the expectations should match.  They are copyable (we rely
 605// on the compiler-defined copy constructor and assignment operator).
 606class Sequence {
 607 public:
 608  // Constructs an empty sequence.
 609  Sequence() : last_expectation_(new Expectation) {}
 610
 611  // Adds an expectation to this sequence.  The caller must ensure
 612  // that no other thread is accessing this Sequence object.
 613  void AddExpectation(const Expectation& expectation) const;
 614
 615 private:
 616  // The last expectation in this sequence.  We use a linked_ptr here
 617  // because Sequence objects are copyable and we want the copies to
 618  // be aliases.  The linked_ptr allows the copies to co-own and share
 619  // the same Expectation object.
 620  internal::linked_ptr<Expectation> last_expectation_;
 621};  // class Sequence
 622
 623// An object of this type causes all EXPECT_CALL() statements
 624// encountered in its scope to be put in an anonymous sequence.  The
 625// work is done in the constructor and destructor.  You should only
 626// create an InSequence object on the stack.
 627//
 628// The sole purpose for this class is to support easy definition of
 629// sequential expectations, e.g.
 630//
 631//   {
 632//     InSequence dummy;  // The name of the object doesn't matter.
 633//
 634//     // The following expectations must match in the order they appear.
 635//     EXPECT_CALL(a, Bar())...;
 636//     EXPECT_CALL(a, Baz())...;
 637//     ...
 638//     EXPECT_CALL(b, Xyz())...;
 639//   }
 640//
 641// You can create InSequence objects in multiple threads, as long as
 642// they are used to affect different mock objects.  The idea is that
 643// each thread can create and set up its own mocks as if it's the only
 644// thread.  However, for clarity of your tests we recommend you to set
 645// up mocks in the main thread unless you have a good reason not to do
 646// so.
 647class InSequence {
 648 public:
 649  InSequence();
 650  ~InSequence();
 651 private:
 652  bool sequence_created_;
 653
 654  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
 655} GTEST_ATTRIBUTE_UNUSED_;
 656
 657namespace internal {
 658
 659// Points to the implicit sequence introduced by a living InSequence
 660// object (if any) in the current thread or NULL.
 661extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
 662
 663// Base class for implementing expectations.
 664//
 665// There are two reasons for having a type-agnostic base class for
 666// Expectation:
 667//
 668//   1. We need to store collections of expectations of different
 669//   types (e.g. all pre-requisites of a particular expectation, all
 670//   expectations in a sequence).  Therefore these expectation objects
 671//   must share a common base class.
 672//
 673//   2. We can avoid binary code bloat by moving methods not depending
 674//   on the template argument of Expectation to the base class.
 675//
 676// This class is internal and mustn't be used by user code directly.
 677class ExpectationBase {
 678 public:
 679  // source_text is the EXPECT_CALL(...) source that created this Expectation.
 680  ExpectationBase(const char* file, int line, const string& source_text);
 681
 682  virtual ~ExpectationBase();
 683
 684  // Where in the source file was the expectation spec defined?
 685  const char* file() const { return file_; }
 686  int line() const { return line_; }
 687  const char* source_text() const { return source_text_.c_str(); }
 688  // Returns the cardinality specified in the expectation spec.
 689  const Cardinality& cardinality() const { return cardinality_; }
 690
 691  // Describes the source file location of this expectation.
 692  void DescribeLocationTo(::std::ostream* os) const {
 693    *os << FormatFileLocation(file(), line()) << " ";
 694  }
 695
 696  // Describes how many times a function call matching this
 697  // expectation has occurred.
 698  // L >= g_gmock_mutex
 699  void DescribeCallCountTo(::std::ostream* os) const;
 700
 701  // If this mock method has an extra matcher (i.e. .With(matcher)),
 702  // describes it to the ostream.
 703  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
 704
 705 protected:
 706  friend class ::testing::Expectation;
 707  friend class UntypedFunctionMockerBase;
 708
 709  enum Clause {
 710    // Don't change the order of the enum members!
 711    kNone,
 712    kWith,
 713    kTimes,
 714    kInSequence,
 715    kAfter,
 716    kWillOnce,
 717    kWillRepeatedly,
 718    kRetiresOnSaturation
 719  };
 720
 721  typedef std::vector<const void*> UntypedActions;
 722
 723  // Returns an Expectation object that references and co-owns this
 724  // expectation.
 725  virtual Expectation GetHandle() = 0;
 726
 727  // Asserts that the EXPECT_CALL() statement has the given property.
 728  void AssertSpecProperty(bool property, const string& failure_message) const {
 729    Assert(property, file_, line_, failure_message);
 730  }
 731
 732  // Expects that the EXPECT_CALL() statement has the given property.
 733  void ExpectSpecProperty(bool property, const string& failure_message) const {
 734    Expect(property, file_, line_, failure_message);
 735  }
 736
 737  // Explicitly specifies the cardinality of this expectation.  Used
 738  // by the subclasses to implement the .Times() clause.
 739  void SpecifyCardinality(const Cardinality& cardinality);
 740
 741  // Returns true iff the user specified the cardinality explicitly
 742  // using a .Times().
 743  bool cardinality_specified() const { return cardinality_specified_; }
 744
 745  // Sets the cardinality of this expectation spec.
 746  void set_cardinality(const Cardinality& a_cardinality) {
 747    cardinality_ = a_cardinality;
 748  }
 749
 750  // The following group of methods should only be called after the
 751  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
 752  // the current thread.
 753
 754  // Retires all pre-requisites of this expectation.
 755  // L >= g_gmock_mutex
 756  void RetireAllPreRequisites();
 757
 758  // Returns true iff this expectation is retired.
 759  // L >= g_gmock_mutex
 760  bool is_retired() const {
 761    g_gmock_mutex.AssertHeld();
 762    return retired_;
 763  }
 764
 765  // Retires this expectation.
 766  // L >= g_gmock_mutex
 767  void Retire() {
 768    g_gmock_mutex.AssertHeld();
 769    retired_ = true;
 770  }
 771
 772  // Returns true iff this expectation is satisfied.
 773  // L >= g_gmock_mutex
 774  bool IsSatisfied() const {
 775    g_gmock_mutex.AssertHeld();
 776    return cardinality().IsSatisfiedByCallCount(call_count_);
 777  }
 778
 779  // Returns true iff this expectation is saturated.
 780  // L >= g_gmock_mutex
 781  bool IsSaturated() const {
 782    g_gmock_mutex.AssertHeld();
 783    return cardinality().IsSaturatedByCallCount(call_count_);
 784  }
 785
 786  // Returns true iff this expectation is over-saturated.
 787  // L >= g_gmock_mutex
 788  bool IsOverSaturated() const {
 789    g_gmock_mutex.AssertHeld();
 790    return cardinality().IsOverSaturatedByCallCount(call_count_);
 791  }
 792
 793  // Returns true iff all pre-requisites of this expectation are satisfied.
 794  // L >= g_gmock_mutex
 795  bool AllPrerequisitesAreSatisfied() const;
 796
 797  // Adds unsatisfied pre-requisites of this expectation to 'result'.
 798  // L >= g_gmock_mutex
 799  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const;
 800
 801  // Returns the number this expectation has been invoked.
 802  // L >= g_gmock_mutex
 803  int call_count() const {
 804    g_gmock_mutex.AssertHeld();
 805    return call_count_;
 806  }
 807
 808  // Increments the number this expectation has been invoked.
 809  // L >= g_gmock_mutex
 810  void IncrementCallCount() {
 811    g_gmock_mutex.AssertHeld();
 812    call_count_++;
 813  }
 814
 815  // Checks the action count (i.e. the number of WillOnce() and
 816  // WillRepeatedly() clauses) against the cardinality if this hasn't
 817  // been done before.  Prints a warning if there are too many or too
 818  // few actions.
 819  // L < mutex_
 820  void CheckActionCountIfNotDone() const;
 821
 822  friend class ::testing::Sequence;
 823  friend class ::testing::internal::ExpectationTester;
 824
 825  template <typename Function>
 826  friend class TypedExpectation;
 827
 828  // Implements the .Times() clause.
 829  void UntypedTimes(const Cardinality& a_cardinality);
 830
 831  // This group of fields are part of the spec and won't change after
 832  // an EXPECT_CALL() statement finishes.
 833  const char* file_;          // The file that contains the expectation.
 834  int line_;                  // The line number of the expectation.
 835  const string source_text_;  // The EXPECT_CALL(...) source text.
 836  // True iff the cardinality is specified explicitly.
 837  bool cardinality_specified_;
 838  Cardinality cardinality_;            // The cardinality of the expectation.
 839  // The immediate pre-requisites (i.e. expectations that must be
 840  // satisfied before this expectation can be matched) of this
 841  // expectation.  We use linked_ptr in the set because we want an
 842  // Expectation object to be co-owned by its FunctionMocker and its
 843  // successors.  This allows multiple mock objects to be deleted at
 844  // different times.
 845  ExpectationSet immediate_prerequisites_;
 846
 847  // This group of fields are the current state of the expectation,
 848  // and can change as the mock function is called.
 849  int call_count_;  // How many times this expectation has been invoked.
 850  bool retired_;    // True iff this expectation has retired.
 851  UntypedActions untyped_actions_;
 852  bool extra_matcher_specified_;
 853  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
 854  bool retires_on_saturation_;
 855  Clause last_clause_;
 856  mutable bool action_count_checked_;  // Under mutex_.
 857  mutable Mutex mutex_;  // Protects action_count_checked_.
 858
 859  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
 860};  // class ExpectationBase
 861
 862// Impements an expectation for the given function type.
 863template <typename F>
 864class TypedExpectation : public ExpectationBase {
 865 public:
 866  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
 867  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
 868  typedef typename Function<F>::Result Result;
 869
 870  TypedExpectation(FunctionMockerBase<F>* owner,
 871                   const char* a_file, int a_line, const string& a_source_text,
 872                   const ArgumentMatcherTuple& m)
 873      : ExpectationBase(a_file, a_line, a_source_text),
 874        owner_(owner),
 875        matchers_(m),
 876        // By default, extra_matcher_ should match anything.  However,
 877        // we cannot initialize it with _ as that triggers a compiler
 878        // bug in Symbian's C++ compiler (cannot decide between two
 879        // overloaded constructors of Matcher<const ArgumentTuple&>).
 880        extra_matcher_(A<const ArgumentTuple&>()),
 881        repeated_action_(DoDefault()) {}
 882
 883  virtual ~TypedExpectation() {
 884    // Check the validity of the action count if it hasn't been done
 885    // yet (for example, if the expectation was never used).
 886    CheckActionCountIfNotDone();
 887    for (UntypedActions::const_iterator it = untyped_actions_.begin();
 888         it != untyped_actions_.end(); ++it) {
 889      delete static_cast<const Action<F>*>(*it);
 890    }
 891  }
 892
 893  // Implements the .With() clause.
 894  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
 895    if (last_clause_ == kWith) {
 896      ExpectSpecProperty(false,
 897                         ".With() cannot appear "
 898                         "more than once in an EXPECT_CALL().");
 899    } else {
 900      ExpectSpecProperty(last_clause_ < kWith,
 901                         ".With() must be the first "
 902                         "clause in an EXPECT_CALL().");
 903    }
 904    last_clause_ = kWith;
 905
 906    extra_matcher_ = m;
 907    extra_matcher_specified_ = true;
 908    return *this;
 909  }
 910
 911  // Implements the .Times() clause.
 912  TypedExpectation& Times(const Cardinality& a_cardinality) {
 913    ExpectationBase::UntypedTimes(a_cardinality);
 914    return *this;
 915  }
 916
 917  // Implements the .Times() clause.
 918  TypedExpectation& Times(int n) {
 919    return Times(Exactly(n));
 920  }
 921
 922  // Implements the .InSequence() clause.
 923  TypedExpectation& InSequence(const Sequence& s) {
 924    ExpectSpecProperty(last_clause_ <= kInSequence,
 925                       ".InSequence() cannot appear after .After(),"
 926                       " .WillOnce(), .WillRepeatedly(), or "
 927                       ".RetiresOnSaturation().");
 928    last_clause_ = kInSequence;
 929
 930    s.AddExpectation(GetHandle());
 931    return *this;
 932  }
 933  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
 934    return InSequence(s1).InSequence(s2);
 935  }
 936  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
 937                               const Sequence& s3) {
 938    return InSequence(s1, s2).InSequence(s3);
 939  }
 940  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
 941                               const Sequence& s3, const Sequence& s4) {
 942    return InSequence(s1, s2, s3).InSequence(s4);
 943  }
 944  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
 945                               const Sequence& s3, const Sequence& s4,
 946                               const Sequence& s5) {
 947    return InSequence(s1, s2, s3, s4).InSequence(s5);
 948  }
 949
 950  // Implements that .After() clause.
 951  TypedExpectation& After(const ExpectationSet& s) {
 952    ExpectSpecProperty(last_clause_ <= kAfter,
 953                       ".After() cannot appear after .WillOnce(),"
 954                       " .WillRepeatedly(), or "
 955                       ".RetiresOnSaturation().");
 956    last_clause_ = kAfter;
 957
 958    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
 959      immediate_prerequisites_ += *it;
 960    }
 961    return *this;
 962  }
 963  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
 964    return After(s1).After(s2);
 965  }
 966  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
 967                          const ExpectationSet& s3) {
 968    return After(s1, s2).After(s3);
 969  }
 970  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
 971                          const ExpectationSet& s3, const ExpectationSet& s4) {
 972    return After(s1, s2, s3).After(s4);
 973  }
 974  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
 975                          const ExpectationSet& s3, const ExpectationSet& s4,
 976                          const ExpectationSet& s5) {
 977    return After(s1, s2, s3, s4).After(s5);
 978  }
 979
 980  // Implements the .WillOnce() clause.
 981  TypedExpectation& WillOnce(const Action<F>& action) {
 982    ExpectSpecProperty(last_clause_ <= kWillOnce,
 983                       ".WillOnce() cannot appear after "
 984                       ".WillRepeatedly() or .RetiresOnSaturation().");
 985    last_clause_ = kWillOnce;
 986
 987    untyped_actions_.push_back(new Action<F>(action));
 988    if (!cardinality_specified()) {
 989      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
 990    }
 991    return *this;
 992  }
 993
 994  // Implements the .WillRepeatedly() clause.
 995  TypedExpectation& WillRepeatedly(const Action<F>& action) {
 996    if (last_clause_ == kWillRepeatedly) {
 997      ExpectSpecProperty(false,
 998                         ".WillRepeatedly() cannot appear "
 999                         "more than once in an EXPECT_CALL().");
1000    } else {
1001      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
1002                         ".WillRepeatedly() cannot appear "
1003                         "after .RetiresOnSaturation().");
1004    }
1005    last_clause_ = kWillRepeatedly;
1006    repeated_action_specified_ = true;
1007
1008    repeated_action_ = action;
1009    if (!cardinality_specified()) {
1010      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
1011    }
1012
1013    // Now that no more action clauses can be specified, we check
1014    // whether their count makes sense.
1015    CheckActionCountIfNotDone();
1016    return *this;
1017  }
1018
1019  // Implements the .RetiresOnSaturation() clause.
1020  TypedExpectation& RetiresOnSaturation() {
1021    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
1022                       ".RetiresOnSaturation() cannot appear "
1023                       "more than once.");
1024    last_clause_ = kRetiresOnSaturation;
1025    retires_on_saturation_ = true;
1026
1027    // Now that no more action clauses can be specified, we check
1028    // whether their count makes sense.
1029    CheckActionCountIfNotDone();
1030    return *this;
1031  }
1032
1033  // Returns the matchers for the arguments as specified inside the
1034  // EXPECT_CALL() macro.
1035  const ArgumentMatcherTuple& matchers() const {
1036    return matchers_;
1037  }
1038
1039  // Returns the matcher specified by the .With() clause.
1040  const Matcher<const ArgumentTuple&>& extra_matcher() const {
1041    return extra_matcher_;
1042  }
1043
1044  // Returns the action specified by the .WillRepeatedly() clause.
1045  const Action<F>& repeated_action() const { return repeated_action_; }
1046
1047  // If this mock method has an extra matcher (i.e. .With(matcher)),
1048  // describes it to the ostream.
1049  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
1050    if (extra_matcher_specified_) {
1051      *os << "    Expected args: ";
1052      extra_matcher_.DescribeTo(os);
1053      *os << "\n";
1054    }
1055  }
1056
1057 private:
1058  template <typename Function>
1059  friend class FunctionMockerBase;
1060
1061  // Returns an Expectation object that references and co-owns this
1062  // expectation.
1063  virtual Expectation GetHandle() {
1064    return owner_->GetHandleOf(this);
1065  }
1066
1067  // The following methods will be called only after the EXPECT_CALL()
1068  // statement finishes and when the current thread holds
1069  // g_gmock_mutex.
1070
1071  // Returns true iff this expectation matches the given arguments.
1072  // L >= g_gmock_mutex
1073  bool Matches(const ArgumentTuple& args) const {
1074    g_gmock_mutex.AssertHeld();
1075    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
1076  }
1077
1078  // Returns true iff this expectation should handle the given arguments.
1079  // L >= g_gmock_mutex
1080  bool ShouldHandleArguments(const ArgumentTuple& args) const {
1081    g_gmock_mutex.AssertHeld();
1082
1083    // In case the action count wasn't checked when the expectation
1084    // was defined (e.g. if this expectation has no WillRepeatedly()
1085    // or RetiresOnSaturation() clause), we check it when the
1086    // expectation is used for the first time.
1087    CheckActionCountIfNotDone();
1088    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
1089  }
1090
1091  // Describes the result of matching the arguments against this
1092  // expectation to the given ostream.
1093  // L >= g_gmock_mutex
1094  void ExplainMatchResultTo(const ArgumentTuple& args,
1095                            ::std::ostream* os) const {
1096    g_gmock_mutex.AssertHeld();
1097
1098    if (is_retired()) {
1099      *os << "         Expected: the expectation is active\n"
1100          << "           Actual: it is retired\n";
1101    } else if (!Matches(args)) {
1102      if (!TupleMatches(matchers_, args)) {
1103        ExplainMatchFailureTupleTo(matchers_, args, os);
1104      }
1105      StringMatchResultListener listener;
1106      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
1107        *os << "    Expected args: ";
1108        extra_matcher_.DescribeTo(os);
1109        *os << "\n           Actual: don't match";
1110
1111        internal::PrintIfNotEmpty(listener.str(), os);
1112        *os << "\n";
1113      }
1114    } else if (!AllPrerequisitesAreSatisfied()) {
1115      *os << "         Expected: all pre-requisites are satisfied\n"
1116          << "           Actual: the following immediate pre-requisites "
1117          << "are not satisfied:\n";
1118      ExpectationSet unsatisfied_prereqs;
1119      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
1120      int i = 0;
1121      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
1122           it != unsatisfied_prereqs.end(); ++it) {
1123        it->expectation_base()->DescribeLocationTo(os);
1124        *os << "pre-requisite #" << i++ << "\n";
1125      }
1126      *os << "                   (end of pre-requisites)\n";
1127    } else {
1128      // This line is here just for completeness' sake.  It will never
1129      // be executed as currently the ExplainMatchResultTo() function
1130      // is called only when the mock function call does NOT match the
1131      // expectation.
1132      *os << "The call matches the expectation.\n";
1133    }
1134  }
1135
1136  // Returns the action that should be taken for the current invocation.
1137  // L >= g_gmock_mutex
1138  const Action<F>& GetCurrentAction(const FunctionMockerBase<F>* mocker,
1139                                    const ArgumentTuple& args) const {
1140    g_gmock_mutex.AssertHeld();
1141    const int count = call_count();
1142    Assert(count >= 1, __FILE__, __LINE__,
1143           "call_count() is <= 0 when GetCurrentAction() is "
1144           "called - this should never happen.");
1145
1146    const int action_count = static_cast<int>(untyped_actions_.size());
1147    if (action_count > 0 && !repeated_action_specified_ &&
1148        count > action_count) {
1149      // If there is at least one WillOnce() and no WillRepeatedly(),
1150      // we warn the user when the WillOnce() clauses ran out.
1151      ::std::stringstream ss;
1152      DescribeLocationTo(&ss);
1153      ss << "Actions ran out in " << source_text() << "...\n"
1154         << "Called " << count << " times, but only "
1155         << action_count << " WillOnce()"
1156         << (action_count == 1 ? " is" : "s are") << " specified - ";
1157      mocker->DescribeDefaultActionTo(args, &ss);
1158      Log(WARNING, ss.str(), 1);
1159    }
1160
1161    return count <= action_count ?
1162        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
1163        repeated_action();
1164  }
1165
1166  // Given the arguments of a mock function call, if the call will
1167  // over-saturate this expectation, returns the default action;
1168  // otherwise, returns the next action in this expectation.  Also
1169  // describes *what* happened to 'what', and explains *why* Google
1170  // Mock does it to 'why'.  This method is not const as it calls
1171  // IncrementCallCount().  A return value of NULL means the default
1172  // action.
1173  // L >= g_gmock_mutex
1174  const Action<F>* GetActionForArguments(const FunctionMockerBase<F>* mocker,
1175                                         const ArgumentTuple& args,
1176                                         ::std::ostream* what,
1177                                         ::std::ostream* why) {
1178    g_gmock_mutex.AssertHeld();
1179    if (IsSaturated()) {
1180      // We have an excessive call.
1181      IncrementCallCount();
1182      *what << "Mock function called more times than expected - ";
1183      mocker->DescribeDefaultActionTo(args, what);
1184      DescribeCallCountTo(why);
1185
1186      // TODO(wan@google.com): allow the user to control whether
1187      // unexpected calls should fail immediately or continue using a
1188      // flag --gmock_unexpected_calls_are_fatal.
1189      return NULL;
1190    }
1191
1192    IncrementCallCount();
1193    RetireAllPreRequisites();
1194
1195    if (retires_on_saturation_ && IsSaturated()) {
1196      Retire();
1197    }
1198
1199    // Must be done after IncrementCount()!
1200    *what << "Mock function call matches " << source_text() <<"...\n";
1201    return &(GetCurrentAction(mocker, args));
1202  }
1203
1204  // All the fields below won't change once the EXPECT_CALL()
1205  // statement finishes.
1206  FunctionMockerBase<F>* const owner_;
1207  ArgumentMatcherTuple matchers_;
1208  Matcher<const ArgumentTuple&> extra_matcher_;
1209  Action<F> repeated_action_;
1210
1211  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
1212};  // class TypedExpectation
1213
1214// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
1215// specifying the default behavior of, or expectation on, a mock
1216// function.
1217
1218// Note: class MockSpec really belongs to the ::testing namespace.
1219// However if we define it in ::testing, MSVC will complain when
1220// classes in ::testing::internal declare it as a friend class
1221// template.  To workaround this compiler bug, we define MockSpec in
1222// ::testing::internal and import it into ::testing.
1223
1224// Logs a message including file and line number information.
1225void LogWithLocation(testing::internal::LogSeverity severity,
1226                     const char* file, int line,
1227                     const string& message);
1228
1229template <typename F>
1230class MockSpec {
1231 public:
1232  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
1233  typedef typename internal::Function<F>::ArgumentMatcherTuple
1234      ArgumentMatcherTuple;
1235
1236  // Constructs a MockSpec object, given the function mocker object
1237  // that the spec is associated with.
1238  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
1239      : function_mocker_(function_mocker) {}
1240
1241  // Adds a new default action spec to the function mocker and returns
1242  // the newly created spec.
1243  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
1244      const char* file, int line, const char* obj, const char* call) {
1245    LogWithLocation(internal::INFO, file, line,
1246        string("ON_CALL(") + obj + ", " + call + ") invoked");
1247    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
1248  }
1249
1250  // Adds a new expectation spec to the function mocker and returns
1251  // the newly created spec.
1252  internal::TypedExpectation<F>& InternalExpectedAt(
1253      const char* file, int line, const char* obj, const char* call) {
1254    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
1255    LogWithLocation(internal::INFO, file, line, source_text + " invoked");
1256    return function_mocker_->AddNewExpectation(
1257        file, line, source_text, matchers_);
1258  }
1259
1260 private:
1261  template <typename Function>
1262  friend class internal::FunctionMocker;
1263
1264  void SetMatchers(const ArgumentMatcherTuple& matchers) {
1265    matchers_ = matchers;
1266  }
1267
1268  // The function mocker that owns this spec.
1269  internal::FunctionMockerBase<F>* const function_mocker_;
1270  // The argument matchers specified in the spec.
1271  ArgumentMatcherTuple matchers_;
1272
1273  GTEST_DISALLOW_ASSIGN_(MockSpec);
1274};  // class MockSpec
1275
1276// MSVC warns about using 'this' in base member initializer list, so
1277// we need to temporarily disable the warning.  We have to do it for
1278// the entire class to suppress the warning, even though it's about
1279// the constructor only.
1280
1281#ifdef _MSC_VER
1282# pragma warning(push)          // Saves the current warning state.
1283# pragma warning(disable:4355)  // Temporarily disables warning 4355.
1284#endif  // _MSV_VER
1285
1286// C++ treats the void type specially.  For example, you cannot define
1287// a void-typed variable or pass a void value to a function.
1288// ActionResultHolder<T> holds a value of type T, where T must be a
1289// copyable type or void (T doesn't need to be default-constructable).
1290// It hides the syntactic difference between void and other types, and
1291// is used to unify the code for invoking both void-returning and
1292// non-void-returning mock functions.
1293
1294// Untyped base class for ActionResultHolder<T>.
1295class UntypedActionResultHolderBase {
1296 public:
1297  virtual ~UntypedActionResultHolderBase() {}
1298
1299  // Prints the held value as an action's result to os.
1300  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
1301};
1302
1303// This generic definition is used when T is not void.
1304template <typename T>
1305class ActionResultHolder : public UntypedActionResultHolderBase {
1306 public:
1307  explicit ActionResultHolder(T a_value) : value_(a_value) {}
1308
1309  // The compiler-generated copy constructor and assignment operator
1310  // are exactly what we need, so we don't need to define them.
1311
1312  // Returns the held value and deletes this object.
1313  T GetValueAndDelete() const {
1314    T retval(value_);
1315    delete this;
1316    return retval;
1317  }
1318
1319  // Prints the held value as an action's result to os.
1320  virtual void PrintAsActionResult(::std::ostream* os) const {
1321    *os << "\n          Returns: ";
1322    // T may be a reference type, so we don't use UniversalPrint().
1323    UniversalPrinter<T>::Print(value_, os);
1324  }
1325
1326  // Performs the given mock function's default action and returns the
1327  // result in a new-ed ActionResultHolder.
1328  template <typename F>
1329  static ActionResultHolder* PerformDefaultAction(
1330      const FunctionMockerBase<F>* func_mocker,
1331      const typename Function<F>::ArgumentTuple& args,
1332      const string& call_description) {
1333    return new ActionResultHolder(
1334        func_mocker->PerformDefaultAction(args, call_description));
1335  }
1336
1337  // Performs the given action and returns the result in a new-ed
1338  // ActionResultHolder.
1339  template <typename F>
1340  static ActionResultHolder*
1341  PerformAction(const Action<F>& action,
1342                const typename Function<F>::ArgumentTuple& args) {
1343    return new ActionResultHolder(action.Perform(args));
1344  }
1345
1346 private:
1347  T value_;
1348
1349  // T could be a reference type, so = isn't supported.
1350  GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
1351};
1352
1353// Specialization for T = void.
1354template <>
1355class ActionResultHolder<void> : public UntypedActionResultHolderBase {
1356 public:
1357  void GetValueAndDelete() const { delete this; }
1358
1359  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
1360
1361  // Performs the given mock function's default action and returns NULL;
1362  template <typename F>
1363  static ActionResultHolder* PerformDefaultAction(
1364      const Functio

Large files files are truncated, but you can click here to view the full file