113481Sgiacomo.travaglini@arm.com// Copyright 2007, Google Inc.
213481Sgiacomo.travaglini@arm.com// All rights reserved.
313481Sgiacomo.travaglini@arm.com//
413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without
513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are
613481Sgiacomo.travaglini@arm.com// met:
713481Sgiacomo.travaglini@arm.com//
813481Sgiacomo.travaglini@arm.com//     * Redistributions of source code must retain the above copyright
913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer.
1013481Sgiacomo.travaglini@arm.com//     * Redistributions in binary form must reproduce the above
1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer
1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the
1313481Sgiacomo.travaglini@arm.com// distribution.
1413481Sgiacomo.travaglini@arm.com//     * Neither the name of Google Inc. nor the names of its
1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from
1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission.
1713481Sgiacomo.travaglini@arm.com//
1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2913481Sgiacomo.travaglini@arm.com//
3013481Sgiacomo.travaglini@arm.com// Author: wan@google.com (Zhanyong Wan)
3113481Sgiacomo.travaglini@arm.com
3213481Sgiacomo.travaglini@arm.com// Google Mock - a framework for writing C++ mock classes.
3313481Sgiacomo.travaglini@arm.com//
3413481Sgiacomo.travaglini@arm.com// This file implements the ON_CALL() and EXPECT_CALL() macros.
3513481Sgiacomo.travaglini@arm.com//
3613481Sgiacomo.travaglini@arm.com// A user can use the ON_CALL() macro to specify the default action of
3713481Sgiacomo.travaglini@arm.com// a mock method.  The syntax is:
3813481Sgiacomo.travaglini@arm.com//
3913481Sgiacomo.travaglini@arm.com//   ON_CALL(mock_object, Method(argument-matchers))
4013481Sgiacomo.travaglini@arm.com//       .With(multi-argument-matcher)
4113481Sgiacomo.travaglini@arm.com//       .WillByDefault(action);
4213481Sgiacomo.travaglini@arm.com//
4313481Sgiacomo.travaglini@arm.com//  where the .With() clause is optional.
4413481Sgiacomo.travaglini@arm.com//
4513481Sgiacomo.travaglini@arm.com// A user can use the EXPECT_CALL() macro to specify an expectation on
4613481Sgiacomo.travaglini@arm.com// a mock method.  The syntax is:
4713481Sgiacomo.travaglini@arm.com//
4813481Sgiacomo.travaglini@arm.com//   EXPECT_CALL(mock_object, Method(argument-matchers))
4913481Sgiacomo.travaglini@arm.com//       .With(multi-argument-matchers)
5013481Sgiacomo.travaglini@arm.com//       .Times(cardinality)
5113481Sgiacomo.travaglini@arm.com//       .InSequence(sequences)
5213481Sgiacomo.travaglini@arm.com//       .After(expectations)
5313481Sgiacomo.travaglini@arm.com//       .WillOnce(action)
5413481Sgiacomo.travaglini@arm.com//       .WillRepeatedly(action)
5513481Sgiacomo.travaglini@arm.com//       .RetiresOnSaturation();
5613481Sgiacomo.travaglini@arm.com//
5713481Sgiacomo.travaglini@arm.com// where all clauses are optional, and .InSequence()/.After()/
5813481Sgiacomo.travaglini@arm.com// .WillOnce() can appear any number of times.
5913481Sgiacomo.travaglini@arm.com
6013481Sgiacomo.travaglini@arm.com#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
6113481Sgiacomo.travaglini@arm.com#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
6213481Sgiacomo.travaglini@arm.com
6313481Sgiacomo.travaglini@arm.com#include <map>
6413481Sgiacomo.travaglini@arm.com#include <set>
6513481Sgiacomo.travaglini@arm.com#include <sstream>
6613481Sgiacomo.travaglini@arm.com#include <string>
6713481Sgiacomo.travaglini@arm.com#include <vector>
6813481Sgiacomo.travaglini@arm.com
6913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS
7013481Sgiacomo.travaglini@arm.com# include <stdexcept>  // NOLINT
7113481Sgiacomo.travaglini@arm.com#endif
7213481Sgiacomo.travaglini@arm.com
7313481Sgiacomo.travaglini@arm.com#include "gmock/gmock-actions.h"
7413481Sgiacomo.travaglini@arm.com#include "gmock/gmock-cardinalities.h"
7513481Sgiacomo.travaglini@arm.com#include "gmock/gmock-matchers.h"
7613481Sgiacomo.travaglini@arm.com#include "gmock/internal/gmock-internal-utils.h"
7713481Sgiacomo.travaglini@arm.com#include "gmock/internal/gmock-port.h"
7813481Sgiacomo.travaglini@arm.com#include "gtest/gtest.h"
7913481Sgiacomo.travaglini@arm.com
8013481Sgiacomo.travaglini@arm.comnamespace testing {
8113481Sgiacomo.travaglini@arm.com
8213481Sgiacomo.travaglini@arm.com// An abstract handle of an expectation.
8313481Sgiacomo.travaglini@arm.comclass Expectation;
8413481Sgiacomo.travaglini@arm.com
8513481Sgiacomo.travaglini@arm.com// A set of expectation handles.
8613481Sgiacomo.travaglini@arm.comclass ExpectationSet;
8713481Sgiacomo.travaglini@arm.com
8813481Sgiacomo.travaglini@arm.com// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
8913481Sgiacomo.travaglini@arm.com// and MUST NOT BE USED IN USER CODE!!!
9013481Sgiacomo.travaglini@arm.comnamespace internal {
9113481Sgiacomo.travaglini@arm.com
9213481Sgiacomo.travaglini@arm.com// Implements a mock function.
9313481Sgiacomo.travaglini@arm.comtemplate <typename F> class FunctionMocker;
9413481Sgiacomo.travaglini@arm.com
9513481Sgiacomo.travaglini@arm.com// Base class for expectations.
9613481Sgiacomo.travaglini@arm.comclass ExpectationBase;
9713481Sgiacomo.travaglini@arm.com
9813481Sgiacomo.travaglini@arm.com// Implements an expectation.
9913481Sgiacomo.travaglini@arm.comtemplate <typename F> class TypedExpectation;
10013481Sgiacomo.travaglini@arm.com
10113481Sgiacomo.travaglini@arm.com// Helper class for testing the Expectation class template.
10213481Sgiacomo.travaglini@arm.comclass ExpectationTester;
10313481Sgiacomo.travaglini@arm.com
10413481Sgiacomo.travaglini@arm.com// Base class for function mockers.
10513481Sgiacomo.travaglini@arm.comtemplate <typename F> class FunctionMockerBase;
10613481Sgiacomo.travaglini@arm.com
10713481Sgiacomo.travaglini@arm.com// Protects the mock object registry (in class Mock), all function
10813481Sgiacomo.travaglini@arm.com// mockers, and all expectations.
10913481Sgiacomo.travaglini@arm.com//
11013481Sgiacomo.travaglini@arm.com// The reason we don't use more fine-grained protection is: when a
11113481Sgiacomo.travaglini@arm.com// mock function Foo() is called, it needs to consult its expectations
11213481Sgiacomo.travaglini@arm.com// to see which one should be picked.  If another thread is allowed to
11313481Sgiacomo.travaglini@arm.com// call a mock function (either Foo() or a different one) at the same
11413481Sgiacomo.travaglini@arm.com// time, it could affect the "retired" attributes of Foo()'s
11513481Sgiacomo.travaglini@arm.com// expectations when InSequence() is used, and thus affect which
11613481Sgiacomo.travaglini@arm.com// expectation gets picked.  Therefore, we sequence all mock function
11713481Sgiacomo.travaglini@arm.com// calls to ensure the integrity of the mock objects' states.
11813481Sgiacomo.travaglini@arm.comGTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
11913481Sgiacomo.travaglini@arm.com
12013481Sgiacomo.travaglini@arm.com// Untyped base class for ActionResultHolder<R>.
12113481Sgiacomo.travaglini@arm.comclass UntypedActionResultHolderBase;
12213481Sgiacomo.travaglini@arm.com
12313481Sgiacomo.travaglini@arm.com// Abstract base class of FunctionMockerBase.  This is the
12413481Sgiacomo.travaglini@arm.com// type-agnostic part of the function mocker interface.  Its pure
12513481Sgiacomo.travaglini@arm.com// virtual methods are implemented by FunctionMockerBase.
12613481Sgiacomo.travaglini@arm.comclass GTEST_API_ UntypedFunctionMockerBase {
12713481Sgiacomo.travaglini@arm.com public:
12813481Sgiacomo.travaglini@arm.com  UntypedFunctionMockerBase();
12913481Sgiacomo.travaglini@arm.com  virtual ~UntypedFunctionMockerBase();
13013481Sgiacomo.travaglini@arm.com
13113481Sgiacomo.travaglini@arm.com  // Verifies that all expectations on this mock function have been
13213481Sgiacomo.travaglini@arm.com  // satisfied.  Reports one or more Google Test non-fatal failures
13313481Sgiacomo.travaglini@arm.com  // and returns false if not.
13413481Sgiacomo.travaglini@arm.com  bool VerifyAndClearExpectationsLocked()
13513481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
13613481Sgiacomo.travaglini@arm.com
13713481Sgiacomo.travaglini@arm.com  // Clears the ON_CALL()s set on this mock function.
13813481Sgiacomo.travaglini@arm.com  virtual void ClearDefaultActionsLocked()
13913481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
14013481Sgiacomo.travaglini@arm.com
14113481Sgiacomo.travaglini@arm.com  // In all of the following Untyped* functions, it's the caller's
14213481Sgiacomo.travaglini@arm.com  // responsibility to guarantee the correctness of the arguments'
14313481Sgiacomo.travaglini@arm.com  // types.
14413481Sgiacomo.travaglini@arm.com
14513481Sgiacomo.travaglini@arm.com  // Performs the default action with the given arguments and returns
14613481Sgiacomo.travaglini@arm.com  // the action's result.  The call description string will be used in
14713481Sgiacomo.travaglini@arm.com  // the error message to describe the call in the case the default
14813481Sgiacomo.travaglini@arm.com  // action fails.
14913481Sgiacomo.travaglini@arm.com  // L = *
15013481Sgiacomo.travaglini@arm.com  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
15113481Sgiacomo.travaglini@arm.com      const void* untyped_args,
15213481Sgiacomo.travaglini@arm.com      const string& call_description) const = 0;
15313481Sgiacomo.travaglini@arm.com
15413481Sgiacomo.travaglini@arm.com  // Performs the given action with the given arguments and returns
15513481Sgiacomo.travaglini@arm.com  // the action's result.
15613481Sgiacomo.travaglini@arm.com  // L = *
15713481Sgiacomo.travaglini@arm.com  virtual UntypedActionResultHolderBase* UntypedPerformAction(
15813481Sgiacomo.travaglini@arm.com      const void* untyped_action,
15913481Sgiacomo.travaglini@arm.com      const void* untyped_args) const = 0;
16013481Sgiacomo.travaglini@arm.com
16113481Sgiacomo.travaglini@arm.com  // Writes a message that the call is uninteresting (i.e. neither
16213481Sgiacomo.travaglini@arm.com  // explicitly expected nor explicitly unexpected) to the given
16313481Sgiacomo.travaglini@arm.com  // ostream.
16413481Sgiacomo.travaglini@arm.com  virtual void UntypedDescribeUninterestingCall(
16513481Sgiacomo.travaglini@arm.com      const void* untyped_args,
16613481Sgiacomo.travaglini@arm.com      ::std::ostream* os) const
16713481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
16813481Sgiacomo.travaglini@arm.com
16913481Sgiacomo.travaglini@arm.com  // Returns the expectation that matches the given function arguments
17013481Sgiacomo.travaglini@arm.com  // (or NULL is there's no match); when a match is found,
17113481Sgiacomo.travaglini@arm.com  // untyped_action is set to point to the action that should be
17213481Sgiacomo.travaglini@arm.com  // performed (or NULL if the action is "do default"), and
17313481Sgiacomo.travaglini@arm.com  // is_excessive is modified to indicate whether the call exceeds the
17413481Sgiacomo.travaglini@arm.com  // expected number.
17513481Sgiacomo.travaglini@arm.com  virtual const ExpectationBase* UntypedFindMatchingExpectation(
17613481Sgiacomo.travaglini@arm.com      const void* untyped_args,
17713481Sgiacomo.travaglini@arm.com      const void** untyped_action, bool* is_excessive,
17813481Sgiacomo.travaglini@arm.com      ::std::ostream* what, ::std::ostream* why)
17913481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
18013481Sgiacomo.travaglini@arm.com
18113481Sgiacomo.travaglini@arm.com  // Prints the given function arguments to the ostream.
18213481Sgiacomo.travaglini@arm.com  virtual void UntypedPrintArgs(const void* untyped_args,
18313481Sgiacomo.travaglini@arm.com                                ::std::ostream* os) const = 0;
18413481Sgiacomo.travaglini@arm.com
18513481Sgiacomo.travaglini@arm.com  // Sets the mock object this mock method belongs to, and registers
18613481Sgiacomo.travaglini@arm.com  // this information in the global mock registry.  Will be called
18713481Sgiacomo.travaglini@arm.com  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
18813481Sgiacomo.travaglini@arm.com  // method.
18913481Sgiacomo.travaglini@arm.com  // TODO(wan@google.com): rename to SetAndRegisterOwner().
19013481Sgiacomo.travaglini@arm.com  void RegisterOwner(const void* mock_obj)
19113481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
19213481Sgiacomo.travaglini@arm.com
19313481Sgiacomo.travaglini@arm.com  // Sets the mock object this mock method belongs to, and sets the
19413481Sgiacomo.travaglini@arm.com  // name of the mock function.  Will be called upon each invocation
19513481Sgiacomo.travaglini@arm.com  // of this mock function.
19613481Sgiacomo.travaglini@arm.com  void SetOwnerAndName(const void* mock_obj, const char* name)
19713481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
19813481Sgiacomo.travaglini@arm.com
19913481Sgiacomo.travaglini@arm.com  // Returns the mock object this mock method belongs to.  Must be
20013481Sgiacomo.travaglini@arm.com  // called after RegisterOwner() or SetOwnerAndName() has been
20113481Sgiacomo.travaglini@arm.com  // called.
20213481Sgiacomo.travaglini@arm.com  const void* MockObject() const
20313481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
20413481Sgiacomo.travaglini@arm.com
20513481Sgiacomo.travaglini@arm.com  // Returns the name of this mock method.  Must be called after
20613481Sgiacomo.travaglini@arm.com  // SetOwnerAndName() has been called.
20713481Sgiacomo.travaglini@arm.com  const char* Name() const
20813481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
20913481Sgiacomo.travaglini@arm.com
21013481Sgiacomo.travaglini@arm.com  // Returns the result of invoking this mock function with the given
21113481Sgiacomo.travaglini@arm.com  // arguments.  This function can be safely called from multiple
21213481Sgiacomo.travaglini@arm.com  // threads concurrently.  The caller is responsible for deleting the
21313481Sgiacomo.travaglini@arm.com  // result.
21413481Sgiacomo.travaglini@arm.com  UntypedActionResultHolderBase* UntypedInvokeWith(
21513481Sgiacomo.travaglini@arm.com      const void* untyped_args)
21613481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
21713481Sgiacomo.travaglini@arm.com
21813481Sgiacomo.travaglini@arm.com protected:
21913481Sgiacomo.travaglini@arm.com  typedef std::vector<const void*> UntypedOnCallSpecs;
22013481Sgiacomo.travaglini@arm.com
22113481Sgiacomo.travaglini@arm.com  typedef std::vector<internal::linked_ptr<ExpectationBase> >
22213481Sgiacomo.travaglini@arm.com  UntypedExpectations;
22313481Sgiacomo.travaglini@arm.com
22413481Sgiacomo.travaglini@arm.com  // Returns an Expectation object that references and co-owns exp,
22513481Sgiacomo.travaglini@arm.com  // which must be an expectation on this mock function.
22613481Sgiacomo.travaglini@arm.com  Expectation GetHandleOf(ExpectationBase* exp);
22713481Sgiacomo.travaglini@arm.com
22813481Sgiacomo.travaglini@arm.com  // Address of the mock object this mock method belongs to.  Only
22913481Sgiacomo.travaglini@arm.com  // valid after this mock method has been called or
23013481Sgiacomo.travaglini@arm.com  // ON_CALL/EXPECT_CALL has been invoked on it.
23113481Sgiacomo.travaglini@arm.com  const void* mock_obj_;  // Protected by g_gmock_mutex.
23213481Sgiacomo.travaglini@arm.com
23313481Sgiacomo.travaglini@arm.com  // Name of the function being mocked.  Only valid after this mock
23413481Sgiacomo.travaglini@arm.com  // method has been called.
23513481Sgiacomo.travaglini@arm.com  const char* name_;  // Protected by g_gmock_mutex.
23613481Sgiacomo.travaglini@arm.com
23713481Sgiacomo.travaglini@arm.com  // All default action specs for this function mocker.
23813481Sgiacomo.travaglini@arm.com  UntypedOnCallSpecs untyped_on_call_specs_;
23913481Sgiacomo.travaglini@arm.com
24013481Sgiacomo.travaglini@arm.com  // All expectations for this function mocker.
24113481Sgiacomo.travaglini@arm.com  UntypedExpectations untyped_expectations_;
24213481Sgiacomo.travaglini@arm.com};  // class UntypedFunctionMockerBase
24313481Sgiacomo.travaglini@arm.com
24413481Sgiacomo.travaglini@arm.com// Untyped base class for OnCallSpec<F>.
24513481Sgiacomo.travaglini@arm.comclass UntypedOnCallSpecBase {
24613481Sgiacomo.travaglini@arm.com public:
24713481Sgiacomo.travaglini@arm.com  // The arguments are the location of the ON_CALL() statement.
24813481Sgiacomo.travaglini@arm.com  UntypedOnCallSpecBase(const char* a_file, int a_line)
24913481Sgiacomo.travaglini@arm.com      : file_(a_file), line_(a_line), last_clause_(kNone) {}
25013481Sgiacomo.travaglini@arm.com
25113481Sgiacomo.travaglini@arm.com  // Where in the source file was the default action spec defined?
25213481Sgiacomo.travaglini@arm.com  const char* file() const { return file_; }
25313481Sgiacomo.travaglini@arm.com  int line() const { return line_; }
25413481Sgiacomo.travaglini@arm.com
25513481Sgiacomo.travaglini@arm.com protected:
25613481Sgiacomo.travaglini@arm.com  // Gives each clause in the ON_CALL() statement a name.
25713481Sgiacomo.travaglini@arm.com  enum Clause {
25813481Sgiacomo.travaglini@arm.com    // Do not change the order of the enum members!  The run-time
25913481Sgiacomo.travaglini@arm.com    // syntax checking relies on it.
26013481Sgiacomo.travaglini@arm.com    kNone,
26113481Sgiacomo.travaglini@arm.com    kWith,
26213481Sgiacomo.travaglini@arm.com    kWillByDefault
26313481Sgiacomo.travaglini@arm.com  };
26413481Sgiacomo.travaglini@arm.com
26513481Sgiacomo.travaglini@arm.com  // Asserts that the ON_CALL() statement has a certain property.
26613481Sgiacomo.travaglini@arm.com  void AssertSpecProperty(bool property, const string& failure_message) const {
26713481Sgiacomo.travaglini@arm.com    Assert(property, file_, line_, failure_message);
26813481Sgiacomo.travaglini@arm.com  }
26913481Sgiacomo.travaglini@arm.com
27013481Sgiacomo.travaglini@arm.com  // Expects that the ON_CALL() statement has a certain property.
27113481Sgiacomo.travaglini@arm.com  void ExpectSpecProperty(bool property, const string& failure_message) const {
27213481Sgiacomo.travaglini@arm.com    Expect(property, file_, line_, failure_message);
27313481Sgiacomo.travaglini@arm.com  }
27413481Sgiacomo.travaglini@arm.com
27513481Sgiacomo.travaglini@arm.com  const char* file_;
27613481Sgiacomo.travaglini@arm.com  int line_;
27713481Sgiacomo.travaglini@arm.com
27813481Sgiacomo.travaglini@arm.com  // The last clause in the ON_CALL() statement as seen so far.
27913481Sgiacomo.travaglini@arm.com  // Initially kNone and changes as the statement is parsed.
28013481Sgiacomo.travaglini@arm.com  Clause last_clause_;
28113481Sgiacomo.travaglini@arm.com};  // class UntypedOnCallSpecBase
28213481Sgiacomo.travaglini@arm.com
28313481Sgiacomo.travaglini@arm.com// This template class implements an ON_CALL spec.
28413481Sgiacomo.travaglini@arm.comtemplate <typename F>
28513481Sgiacomo.travaglini@arm.comclass OnCallSpec : public UntypedOnCallSpecBase {
28613481Sgiacomo.travaglini@arm.com public:
28713481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
28813481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
28913481Sgiacomo.travaglini@arm.com
29013481Sgiacomo.travaglini@arm.com  // Constructs an OnCallSpec object from the information inside
29113481Sgiacomo.travaglini@arm.com  // the parenthesis of an ON_CALL() statement.
29213481Sgiacomo.travaglini@arm.com  OnCallSpec(const char* a_file, int a_line,
29313481Sgiacomo.travaglini@arm.com             const ArgumentMatcherTuple& matchers)
29413481Sgiacomo.travaglini@arm.com      : UntypedOnCallSpecBase(a_file, a_line),
29513481Sgiacomo.travaglini@arm.com        matchers_(matchers),
29613481Sgiacomo.travaglini@arm.com        // By default, extra_matcher_ should match anything.  However,
29713481Sgiacomo.travaglini@arm.com        // we cannot initialize it with _ as that triggers a compiler
29813481Sgiacomo.travaglini@arm.com        // bug in Symbian's C++ compiler (cannot decide between two
29913481Sgiacomo.travaglini@arm.com        // overloaded constructors of Matcher<const ArgumentTuple&>).
30013481Sgiacomo.travaglini@arm.com        extra_matcher_(A<const ArgumentTuple&>()) {
30113481Sgiacomo.travaglini@arm.com  }
30213481Sgiacomo.travaglini@arm.com
30313481Sgiacomo.travaglini@arm.com  // Implements the .With() clause.
30413481Sgiacomo.travaglini@arm.com  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
30513481Sgiacomo.travaglini@arm.com    // Makes sure this is called at most once.
30613481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ < kWith,
30713481Sgiacomo.travaglini@arm.com                       ".With() cannot appear "
30813481Sgiacomo.travaglini@arm.com                       "more than once in an ON_CALL().");
30913481Sgiacomo.travaglini@arm.com    last_clause_ = kWith;
31013481Sgiacomo.travaglini@arm.com
31113481Sgiacomo.travaglini@arm.com    extra_matcher_ = m;
31213481Sgiacomo.travaglini@arm.com    return *this;
31313481Sgiacomo.travaglini@arm.com  }
31413481Sgiacomo.travaglini@arm.com
31513481Sgiacomo.travaglini@arm.com  // Implements the .WillByDefault() clause.
31613481Sgiacomo.travaglini@arm.com  OnCallSpec& WillByDefault(const Action<F>& action) {
31713481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ < kWillByDefault,
31813481Sgiacomo.travaglini@arm.com                       ".WillByDefault() must appear "
31913481Sgiacomo.travaglini@arm.com                       "exactly once in an ON_CALL().");
32013481Sgiacomo.travaglini@arm.com    last_clause_ = kWillByDefault;
32113481Sgiacomo.travaglini@arm.com
32213481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(!action.IsDoDefault(),
32313481Sgiacomo.travaglini@arm.com                       "DoDefault() cannot be used in ON_CALL().");
32413481Sgiacomo.travaglini@arm.com    action_ = action;
32513481Sgiacomo.travaglini@arm.com    return *this;
32613481Sgiacomo.travaglini@arm.com  }
32713481Sgiacomo.travaglini@arm.com
32813481Sgiacomo.travaglini@arm.com  // Returns true iff the given arguments match the matchers.
32913481Sgiacomo.travaglini@arm.com  bool Matches(const ArgumentTuple& args) const {
33013481Sgiacomo.travaglini@arm.com    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
33113481Sgiacomo.travaglini@arm.com  }
33213481Sgiacomo.travaglini@arm.com
33313481Sgiacomo.travaglini@arm.com  // Returns the action specified by the user.
33413481Sgiacomo.travaglini@arm.com  const Action<F>& GetAction() const {
33513481Sgiacomo.travaglini@arm.com    AssertSpecProperty(last_clause_ == kWillByDefault,
33613481Sgiacomo.travaglini@arm.com                       ".WillByDefault() must appear exactly "
33713481Sgiacomo.travaglini@arm.com                       "once in an ON_CALL().");
33813481Sgiacomo.travaglini@arm.com    return action_;
33913481Sgiacomo.travaglini@arm.com  }
34013481Sgiacomo.travaglini@arm.com
34113481Sgiacomo.travaglini@arm.com private:
34213481Sgiacomo.travaglini@arm.com  // The information in statement
34313481Sgiacomo.travaglini@arm.com  //
34413481Sgiacomo.travaglini@arm.com  //   ON_CALL(mock_object, Method(matchers))
34513481Sgiacomo.travaglini@arm.com  //       .With(multi-argument-matcher)
34613481Sgiacomo.travaglini@arm.com  //       .WillByDefault(action);
34713481Sgiacomo.travaglini@arm.com  //
34813481Sgiacomo.travaglini@arm.com  // is recorded in the data members like this:
34913481Sgiacomo.travaglini@arm.com  //
35013481Sgiacomo.travaglini@arm.com  //   source file that contains the statement => file_
35113481Sgiacomo.travaglini@arm.com  //   line number of the statement            => line_
35213481Sgiacomo.travaglini@arm.com  //   matchers                                => matchers_
35313481Sgiacomo.travaglini@arm.com  //   multi-argument-matcher                  => extra_matcher_
35413481Sgiacomo.travaglini@arm.com  //   action                                  => action_
35513481Sgiacomo.travaglini@arm.com  ArgumentMatcherTuple matchers_;
35613481Sgiacomo.travaglini@arm.com  Matcher<const ArgumentTuple&> extra_matcher_;
35713481Sgiacomo.travaglini@arm.com  Action<F> action_;
35813481Sgiacomo.travaglini@arm.com};  // class OnCallSpec
35913481Sgiacomo.travaglini@arm.com
36013481Sgiacomo.travaglini@arm.com// Possible reactions on uninteresting calls.
36113481Sgiacomo.travaglini@arm.comenum CallReaction {
36213481Sgiacomo.travaglini@arm.com  kAllow,
36313481Sgiacomo.travaglini@arm.com  kWarn,
36413481Sgiacomo.travaglini@arm.com  kFail,
36513481Sgiacomo.travaglini@arm.com  kDefault = kWarn  // By default, warn about uninteresting calls.
36613481Sgiacomo.travaglini@arm.com};
36713481Sgiacomo.travaglini@arm.com
36813481Sgiacomo.travaglini@arm.com}  // namespace internal
36913481Sgiacomo.travaglini@arm.com
37013481Sgiacomo.travaglini@arm.com// Utilities for manipulating mock objects.
37113481Sgiacomo.travaglini@arm.comclass GTEST_API_ Mock {
37213481Sgiacomo.travaglini@arm.com public:
37313481Sgiacomo.travaglini@arm.com  // The following public methods can be called concurrently.
37413481Sgiacomo.travaglini@arm.com
37513481Sgiacomo.travaglini@arm.com  // Tells Google Mock to ignore mock_obj when checking for leaked
37613481Sgiacomo.travaglini@arm.com  // mock objects.
37713481Sgiacomo.travaglini@arm.com  static void AllowLeak(const void* mock_obj)
37813481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
37913481Sgiacomo.travaglini@arm.com
38013481Sgiacomo.travaglini@arm.com  // Verifies and clears all expectations on the given mock object.
38113481Sgiacomo.travaglini@arm.com  // If the expectations aren't satisfied, generates one or more
38213481Sgiacomo.travaglini@arm.com  // Google Test non-fatal failures and returns false.
38313481Sgiacomo.travaglini@arm.com  static bool VerifyAndClearExpectations(void* mock_obj)
38413481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
38513481Sgiacomo.travaglini@arm.com
38613481Sgiacomo.travaglini@arm.com  // Verifies all expectations on the given mock object and clears its
38713481Sgiacomo.travaglini@arm.com  // default actions and expectations.  Returns true iff the
38813481Sgiacomo.travaglini@arm.com  // verification was successful.
38913481Sgiacomo.travaglini@arm.com  static bool VerifyAndClear(void* mock_obj)
39013481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
39113481Sgiacomo.travaglini@arm.com
39213481Sgiacomo.travaglini@arm.com private:
39313481Sgiacomo.travaglini@arm.com  friend class internal::UntypedFunctionMockerBase;
39413481Sgiacomo.travaglini@arm.com
39513481Sgiacomo.travaglini@arm.com  // Needed for a function mocker to register itself (so that we know
39613481Sgiacomo.travaglini@arm.com  // how to clear a mock object).
39713481Sgiacomo.travaglini@arm.com  template <typename F>
39813481Sgiacomo.travaglini@arm.com  friend class internal::FunctionMockerBase;
39913481Sgiacomo.travaglini@arm.com
40013481Sgiacomo.travaglini@arm.com  template <typename M>
40113481Sgiacomo.travaglini@arm.com  friend class NiceMock;
40213481Sgiacomo.travaglini@arm.com
40313481Sgiacomo.travaglini@arm.com  template <typename M>
40413481Sgiacomo.travaglini@arm.com  friend class NaggyMock;
40513481Sgiacomo.travaglini@arm.com
40613481Sgiacomo.travaglini@arm.com  template <typename M>
40713481Sgiacomo.travaglini@arm.com  friend class StrictMock;
40813481Sgiacomo.travaglini@arm.com
40913481Sgiacomo.travaglini@arm.com  // Tells Google Mock to allow uninteresting calls on the given mock
41013481Sgiacomo.travaglini@arm.com  // object.
41113481Sgiacomo.travaglini@arm.com  static void AllowUninterestingCalls(const void* mock_obj)
41213481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
41313481Sgiacomo.travaglini@arm.com
41413481Sgiacomo.travaglini@arm.com  // Tells Google Mock to warn the user about uninteresting calls on
41513481Sgiacomo.travaglini@arm.com  // the given mock object.
41613481Sgiacomo.travaglini@arm.com  static void WarnUninterestingCalls(const void* mock_obj)
41713481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
41813481Sgiacomo.travaglini@arm.com
41913481Sgiacomo.travaglini@arm.com  // Tells Google Mock to fail uninteresting calls on the given mock
42013481Sgiacomo.travaglini@arm.com  // object.
42113481Sgiacomo.travaglini@arm.com  static void FailUninterestingCalls(const void* mock_obj)
42213481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
42313481Sgiacomo.travaglini@arm.com
42413481Sgiacomo.travaglini@arm.com  // Tells Google Mock the given mock object is being destroyed and
42513481Sgiacomo.travaglini@arm.com  // its entry in the call-reaction table should be removed.
42613481Sgiacomo.travaglini@arm.com  static void UnregisterCallReaction(const void* mock_obj)
42713481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
42813481Sgiacomo.travaglini@arm.com
42913481Sgiacomo.travaglini@arm.com  // Returns the reaction Google Mock will have on uninteresting calls
43013481Sgiacomo.travaglini@arm.com  // made on the given mock object.
43113481Sgiacomo.travaglini@arm.com  static internal::CallReaction GetReactionOnUninterestingCalls(
43213481Sgiacomo.travaglini@arm.com      const void* mock_obj)
43313481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
43413481Sgiacomo.travaglini@arm.com
43513481Sgiacomo.travaglini@arm.com  // Verifies that all expectations on the given mock object have been
43613481Sgiacomo.travaglini@arm.com  // satisfied.  Reports one or more Google Test non-fatal failures
43713481Sgiacomo.travaglini@arm.com  // and returns false if not.
43813481Sgiacomo.travaglini@arm.com  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
43913481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
44013481Sgiacomo.travaglini@arm.com
44113481Sgiacomo.travaglini@arm.com  // Clears all ON_CALL()s set on the given mock object.
44213481Sgiacomo.travaglini@arm.com  static void ClearDefaultActionsLocked(void* mock_obj)
44313481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
44413481Sgiacomo.travaglini@arm.com
44513481Sgiacomo.travaglini@arm.com  // Registers a mock object and a mock method it owns.
44613481Sgiacomo.travaglini@arm.com  static void Register(
44713481Sgiacomo.travaglini@arm.com      const void* mock_obj,
44813481Sgiacomo.travaglini@arm.com      internal::UntypedFunctionMockerBase* mocker)
44913481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
45013481Sgiacomo.travaglini@arm.com
45113481Sgiacomo.travaglini@arm.com  // Tells Google Mock where in the source code mock_obj is used in an
45213481Sgiacomo.travaglini@arm.com  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
45313481Sgiacomo.travaglini@arm.com  // information helps the user identify which object it is.
45413481Sgiacomo.travaglini@arm.com  static void RegisterUseByOnCallOrExpectCall(
45513481Sgiacomo.travaglini@arm.com      const void* mock_obj, const char* file, int line)
45613481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
45713481Sgiacomo.travaglini@arm.com
45813481Sgiacomo.travaglini@arm.com  // Unregisters a mock method; removes the owning mock object from
45913481Sgiacomo.travaglini@arm.com  // the registry when the last mock method associated with it has
46013481Sgiacomo.travaglini@arm.com  // been unregistered.  This is called only in the destructor of
46113481Sgiacomo.travaglini@arm.com  // FunctionMockerBase.
46213481Sgiacomo.travaglini@arm.com  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
46313481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
46413481Sgiacomo.travaglini@arm.com};  // class Mock
46513481Sgiacomo.travaglini@arm.com
46613481Sgiacomo.travaglini@arm.com// An abstract handle of an expectation.  Useful in the .After()
46713481Sgiacomo.travaglini@arm.com// clause of EXPECT_CALL() for setting the (partial) order of
46813481Sgiacomo.travaglini@arm.com// expectations.  The syntax:
46913481Sgiacomo.travaglini@arm.com//
47013481Sgiacomo.travaglini@arm.com//   Expectation e1 = EXPECT_CALL(...)...;
47113481Sgiacomo.travaglini@arm.com//   EXPECT_CALL(...).After(e1)...;
47213481Sgiacomo.travaglini@arm.com//
47313481Sgiacomo.travaglini@arm.com// sets two expectations where the latter can only be matched after
47413481Sgiacomo.travaglini@arm.com// the former has been satisfied.
47513481Sgiacomo.travaglini@arm.com//
47613481Sgiacomo.travaglini@arm.com// Notes:
47713481Sgiacomo.travaglini@arm.com//   - This class is copyable and has value semantics.
47813481Sgiacomo.travaglini@arm.com//   - Constness is shallow: a const Expectation object itself cannot
47913481Sgiacomo.travaglini@arm.com//     be modified, but the mutable methods of the ExpectationBase
48013481Sgiacomo.travaglini@arm.com//     object it references can be called via expectation_base().
48113481Sgiacomo.travaglini@arm.com//   - The constructors and destructor are defined out-of-line because
48213481Sgiacomo.travaglini@arm.com//     the Symbian WINSCW compiler wants to otherwise instantiate them
48313481Sgiacomo.travaglini@arm.com//     when it sees this class definition, at which point it doesn't have
48413481Sgiacomo.travaglini@arm.com//     ExpectationBase available yet, leading to incorrect destruction
48513481Sgiacomo.travaglini@arm.com//     in the linked_ptr (or compilation errors if using a checking
48613481Sgiacomo.travaglini@arm.com//     linked_ptr).
48713481Sgiacomo.travaglini@arm.comclass GTEST_API_ Expectation {
48813481Sgiacomo.travaglini@arm.com public:
48913481Sgiacomo.travaglini@arm.com  // Constructs a null object that doesn't reference any expectation.
49013481Sgiacomo.travaglini@arm.com  Expectation();
49113481Sgiacomo.travaglini@arm.com
49213481Sgiacomo.travaglini@arm.com  ~Expectation();
49313481Sgiacomo.travaglini@arm.com
49413481Sgiacomo.travaglini@arm.com  // This single-argument ctor must not be explicit, in order to support the
49513481Sgiacomo.travaglini@arm.com  //   Expectation e = EXPECT_CALL(...);
49613481Sgiacomo.travaglini@arm.com  // syntax.
49713481Sgiacomo.travaglini@arm.com  //
49813481Sgiacomo.travaglini@arm.com  // A TypedExpectation object stores its pre-requisites as
49913481Sgiacomo.travaglini@arm.com  // Expectation objects, and needs to call the non-const Retire()
50013481Sgiacomo.travaglini@arm.com  // method on the ExpectationBase objects they reference.  Therefore
50113481Sgiacomo.travaglini@arm.com  // Expectation must receive a *non-const* reference to the
50213481Sgiacomo.travaglini@arm.com  // ExpectationBase object.
50313481Sgiacomo.travaglini@arm.com  Expectation(internal::ExpectationBase& exp);  // NOLINT
50413481Sgiacomo.travaglini@arm.com
50513481Sgiacomo.travaglini@arm.com  // The compiler-generated copy ctor and operator= work exactly as
50613481Sgiacomo.travaglini@arm.com  // intended, so we don't need to define our own.
50713481Sgiacomo.travaglini@arm.com
50813481Sgiacomo.travaglini@arm.com  // Returns true iff rhs references the same expectation as this object does.
50913481Sgiacomo.travaglini@arm.com  bool operator==(const Expectation& rhs) const {
51013481Sgiacomo.travaglini@arm.com    return expectation_base_ == rhs.expectation_base_;
51113481Sgiacomo.travaglini@arm.com  }
51213481Sgiacomo.travaglini@arm.com
51313481Sgiacomo.travaglini@arm.com  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
51413481Sgiacomo.travaglini@arm.com
51513481Sgiacomo.travaglini@arm.com private:
51613481Sgiacomo.travaglini@arm.com  friend class ExpectationSet;
51713481Sgiacomo.travaglini@arm.com  friend class Sequence;
51813481Sgiacomo.travaglini@arm.com  friend class ::testing::internal::ExpectationBase;
51913481Sgiacomo.travaglini@arm.com  friend class ::testing::internal::UntypedFunctionMockerBase;
52013481Sgiacomo.travaglini@arm.com
52113481Sgiacomo.travaglini@arm.com  template <typename F>
52213481Sgiacomo.travaglini@arm.com  friend class ::testing::internal::FunctionMockerBase;
52313481Sgiacomo.travaglini@arm.com
52413481Sgiacomo.travaglini@arm.com  template <typename F>
52513481Sgiacomo.travaglini@arm.com  friend class ::testing::internal::TypedExpectation;
52613481Sgiacomo.travaglini@arm.com
52713481Sgiacomo.travaglini@arm.com  // This comparator is needed for putting Expectation objects into a set.
52813481Sgiacomo.travaglini@arm.com  class Less {
52913481Sgiacomo.travaglini@arm.com   public:
53013481Sgiacomo.travaglini@arm.com    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
53113481Sgiacomo.travaglini@arm.com      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
53213481Sgiacomo.travaglini@arm.com    }
53313481Sgiacomo.travaglini@arm.com  };
53413481Sgiacomo.travaglini@arm.com
53513481Sgiacomo.travaglini@arm.com  typedef ::std::set<Expectation, Less> Set;
53613481Sgiacomo.travaglini@arm.com
53713481Sgiacomo.travaglini@arm.com  Expectation(
53813481Sgiacomo.travaglini@arm.com      const internal::linked_ptr<internal::ExpectationBase>& expectation_base);
53913481Sgiacomo.travaglini@arm.com
54013481Sgiacomo.travaglini@arm.com  // Returns the expectation this object references.
54113481Sgiacomo.travaglini@arm.com  const internal::linked_ptr<internal::ExpectationBase>&
54213481Sgiacomo.travaglini@arm.com  expectation_base() const {
54313481Sgiacomo.travaglini@arm.com    return expectation_base_;
54413481Sgiacomo.travaglini@arm.com  }
54513481Sgiacomo.travaglini@arm.com
54613481Sgiacomo.travaglini@arm.com  // A linked_ptr that co-owns the expectation this handle references.
54713481Sgiacomo.travaglini@arm.com  internal::linked_ptr<internal::ExpectationBase> expectation_base_;
54813481Sgiacomo.travaglini@arm.com};
54913481Sgiacomo.travaglini@arm.com
55013481Sgiacomo.travaglini@arm.com// A set of expectation handles.  Useful in the .After() clause of
55113481Sgiacomo.travaglini@arm.com// EXPECT_CALL() for setting the (partial) order of expectations.  The
55213481Sgiacomo.travaglini@arm.com// syntax:
55313481Sgiacomo.travaglini@arm.com//
55413481Sgiacomo.travaglini@arm.com//   ExpectationSet es;
55513481Sgiacomo.travaglini@arm.com//   es += EXPECT_CALL(...)...;
55613481Sgiacomo.travaglini@arm.com//   es += EXPECT_CALL(...)...;
55713481Sgiacomo.travaglini@arm.com//   EXPECT_CALL(...).After(es)...;
55813481Sgiacomo.travaglini@arm.com//
55913481Sgiacomo.travaglini@arm.com// sets three expectations where the last one can only be matched
56013481Sgiacomo.travaglini@arm.com// after the first two have both been satisfied.
56113481Sgiacomo.travaglini@arm.com//
56213481Sgiacomo.travaglini@arm.com// This class is copyable and has value semantics.
56313481Sgiacomo.travaglini@arm.comclass ExpectationSet {
56413481Sgiacomo.travaglini@arm.com public:
56513481Sgiacomo.travaglini@arm.com  // A bidirectional iterator that can read a const element in the set.
56613481Sgiacomo.travaglini@arm.com  typedef Expectation::Set::const_iterator const_iterator;
56713481Sgiacomo.travaglini@arm.com
56813481Sgiacomo.travaglini@arm.com  // An object stored in the set.  This is an alias of Expectation.
56913481Sgiacomo.travaglini@arm.com  typedef Expectation::Set::value_type value_type;
57013481Sgiacomo.travaglini@arm.com
57113481Sgiacomo.travaglini@arm.com  // Constructs an empty set.
57213481Sgiacomo.travaglini@arm.com  ExpectationSet() {}
57313481Sgiacomo.travaglini@arm.com
57413481Sgiacomo.travaglini@arm.com  // This single-argument ctor must not be explicit, in order to support the
57513481Sgiacomo.travaglini@arm.com  //   ExpectationSet es = EXPECT_CALL(...);
57613481Sgiacomo.travaglini@arm.com  // syntax.
57713481Sgiacomo.travaglini@arm.com  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
57813481Sgiacomo.travaglini@arm.com    *this += Expectation(exp);
57913481Sgiacomo.travaglini@arm.com  }
58013481Sgiacomo.travaglini@arm.com
58113481Sgiacomo.travaglini@arm.com  // This single-argument ctor implements implicit conversion from
58213481Sgiacomo.travaglini@arm.com  // Expectation and thus must not be explicit.  This allows either an
58313481Sgiacomo.travaglini@arm.com  // Expectation or an ExpectationSet to be used in .After().
58413481Sgiacomo.travaglini@arm.com  ExpectationSet(const Expectation& e) {  // NOLINT
58513481Sgiacomo.travaglini@arm.com    *this += e;
58613481Sgiacomo.travaglini@arm.com  }
58713481Sgiacomo.travaglini@arm.com
58813481Sgiacomo.travaglini@arm.com  // The compiler-generator ctor and operator= works exactly as
58913481Sgiacomo.travaglini@arm.com  // intended, so we don't need to define our own.
59013481Sgiacomo.travaglini@arm.com
59113481Sgiacomo.travaglini@arm.com  // Returns true iff rhs contains the same set of Expectation objects
59213481Sgiacomo.travaglini@arm.com  // as this does.
59313481Sgiacomo.travaglini@arm.com  bool operator==(const ExpectationSet& rhs) const {
59413481Sgiacomo.travaglini@arm.com    return expectations_ == rhs.expectations_;
59513481Sgiacomo.travaglini@arm.com  }
59613481Sgiacomo.travaglini@arm.com
59713481Sgiacomo.travaglini@arm.com  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
59813481Sgiacomo.travaglini@arm.com
59913481Sgiacomo.travaglini@arm.com  // Implements the syntax
60013481Sgiacomo.travaglini@arm.com  //   expectation_set += EXPECT_CALL(...);
60113481Sgiacomo.travaglini@arm.com  ExpectationSet& operator+=(const Expectation& e) {
60213481Sgiacomo.travaglini@arm.com    expectations_.insert(e);
60313481Sgiacomo.travaglini@arm.com    return *this;
60413481Sgiacomo.travaglini@arm.com  }
60513481Sgiacomo.travaglini@arm.com
60613481Sgiacomo.travaglini@arm.com  int size() const { return static_cast<int>(expectations_.size()); }
60713481Sgiacomo.travaglini@arm.com
60813481Sgiacomo.travaglini@arm.com  const_iterator begin() const { return expectations_.begin(); }
60913481Sgiacomo.travaglini@arm.com  const_iterator end() const { return expectations_.end(); }
61013481Sgiacomo.travaglini@arm.com
61113481Sgiacomo.travaglini@arm.com private:
61213481Sgiacomo.travaglini@arm.com  Expectation::Set expectations_;
61313481Sgiacomo.travaglini@arm.com};
61413481Sgiacomo.travaglini@arm.com
61513481Sgiacomo.travaglini@arm.com
61613481Sgiacomo.travaglini@arm.com// Sequence objects are used by a user to specify the relative order
61713481Sgiacomo.travaglini@arm.com// in which the expectations should match.  They are copyable (we rely
61813481Sgiacomo.travaglini@arm.com// on the compiler-defined copy constructor and assignment operator).
61913481Sgiacomo.travaglini@arm.comclass GTEST_API_ Sequence {
62013481Sgiacomo.travaglini@arm.com public:
62113481Sgiacomo.travaglini@arm.com  // Constructs an empty sequence.
62213481Sgiacomo.travaglini@arm.com  Sequence() : last_expectation_(new Expectation) {}
62313481Sgiacomo.travaglini@arm.com
62413481Sgiacomo.travaglini@arm.com  // Adds an expectation to this sequence.  The caller must ensure
62513481Sgiacomo.travaglini@arm.com  // that no other thread is accessing this Sequence object.
62613481Sgiacomo.travaglini@arm.com  void AddExpectation(const Expectation& expectation) const;
62713481Sgiacomo.travaglini@arm.com
62813481Sgiacomo.travaglini@arm.com private:
62913481Sgiacomo.travaglini@arm.com  // The last expectation in this sequence.  We use a linked_ptr here
63013481Sgiacomo.travaglini@arm.com  // because Sequence objects are copyable and we want the copies to
63113481Sgiacomo.travaglini@arm.com  // be aliases.  The linked_ptr allows the copies to co-own and share
63213481Sgiacomo.travaglini@arm.com  // the same Expectation object.
63313481Sgiacomo.travaglini@arm.com  internal::linked_ptr<Expectation> last_expectation_;
63413481Sgiacomo.travaglini@arm.com};  // class Sequence
63513481Sgiacomo.travaglini@arm.com
63613481Sgiacomo.travaglini@arm.com// An object of this type causes all EXPECT_CALL() statements
63713481Sgiacomo.travaglini@arm.com// encountered in its scope to be put in an anonymous sequence.  The
63813481Sgiacomo.travaglini@arm.com// work is done in the constructor and destructor.  You should only
63913481Sgiacomo.travaglini@arm.com// create an InSequence object on the stack.
64013481Sgiacomo.travaglini@arm.com//
64113481Sgiacomo.travaglini@arm.com// The sole purpose for this class is to support easy definition of
64213481Sgiacomo.travaglini@arm.com// sequential expectations, e.g.
64313481Sgiacomo.travaglini@arm.com//
64413481Sgiacomo.travaglini@arm.com//   {
64513481Sgiacomo.travaglini@arm.com//     InSequence dummy;  // The name of the object doesn't matter.
64613481Sgiacomo.travaglini@arm.com//
64713481Sgiacomo.travaglini@arm.com//     // The following expectations must match in the order they appear.
64813481Sgiacomo.travaglini@arm.com//     EXPECT_CALL(a, Bar())...;
64913481Sgiacomo.travaglini@arm.com//     EXPECT_CALL(a, Baz())...;
65013481Sgiacomo.travaglini@arm.com//     ...
65113481Sgiacomo.travaglini@arm.com//     EXPECT_CALL(b, Xyz())...;
65213481Sgiacomo.travaglini@arm.com//   }
65313481Sgiacomo.travaglini@arm.com//
65413481Sgiacomo.travaglini@arm.com// You can create InSequence objects in multiple threads, as long as
65513481Sgiacomo.travaglini@arm.com// they are used to affect different mock objects.  The idea is that
65613481Sgiacomo.travaglini@arm.com// each thread can create and set up its own mocks as if it's the only
65713481Sgiacomo.travaglini@arm.com// thread.  However, for clarity of your tests we recommend you to set
65813481Sgiacomo.travaglini@arm.com// up mocks in the main thread unless you have a good reason not to do
65913481Sgiacomo.travaglini@arm.com// so.
66013481Sgiacomo.travaglini@arm.comclass GTEST_API_ InSequence {
66113481Sgiacomo.travaglini@arm.com public:
66213481Sgiacomo.travaglini@arm.com  InSequence();
66313481Sgiacomo.travaglini@arm.com  ~InSequence();
66413481Sgiacomo.travaglini@arm.com private:
66513481Sgiacomo.travaglini@arm.com  bool sequence_created_;
66613481Sgiacomo.travaglini@arm.com
66713481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
66813481Sgiacomo.travaglini@arm.com} GTEST_ATTRIBUTE_UNUSED_;
66913481Sgiacomo.travaglini@arm.com
67013481Sgiacomo.travaglini@arm.comnamespace internal {
67113481Sgiacomo.travaglini@arm.com
67213481Sgiacomo.travaglini@arm.com// Points to the implicit sequence introduced by a living InSequence
67313481Sgiacomo.travaglini@arm.com// object (if any) in the current thread or NULL.
67413481Sgiacomo.travaglini@arm.comGTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
67513481Sgiacomo.travaglini@arm.com
67613481Sgiacomo.travaglini@arm.com// Base class for implementing expectations.
67713481Sgiacomo.travaglini@arm.com//
67813481Sgiacomo.travaglini@arm.com// There are two reasons for having a type-agnostic base class for
67913481Sgiacomo.travaglini@arm.com// Expectation:
68013481Sgiacomo.travaglini@arm.com//
68113481Sgiacomo.travaglini@arm.com//   1. We need to store collections of expectations of different
68213481Sgiacomo.travaglini@arm.com//   types (e.g. all pre-requisites of a particular expectation, all
68313481Sgiacomo.travaglini@arm.com//   expectations in a sequence).  Therefore these expectation objects
68413481Sgiacomo.travaglini@arm.com//   must share a common base class.
68513481Sgiacomo.travaglini@arm.com//
68613481Sgiacomo.travaglini@arm.com//   2. We can avoid binary code bloat by moving methods not depending
68713481Sgiacomo.travaglini@arm.com//   on the template argument of Expectation to the base class.
68813481Sgiacomo.travaglini@arm.com//
68913481Sgiacomo.travaglini@arm.com// This class is internal and mustn't be used by user code directly.
69013481Sgiacomo.travaglini@arm.comclass GTEST_API_ ExpectationBase {
69113481Sgiacomo.travaglini@arm.com public:
69213481Sgiacomo.travaglini@arm.com  // source_text is the EXPECT_CALL(...) source that created this Expectation.
69313481Sgiacomo.travaglini@arm.com  ExpectationBase(const char* file, int line, const string& source_text);
69413481Sgiacomo.travaglini@arm.com
69513481Sgiacomo.travaglini@arm.com  virtual ~ExpectationBase();
69613481Sgiacomo.travaglini@arm.com
69713481Sgiacomo.travaglini@arm.com  // Where in the source file was the expectation spec defined?
69813481Sgiacomo.travaglini@arm.com  const char* file() const { return file_; }
69913481Sgiacomo.travaglini@arm.com  int line() const { return line_; }
70013481Sgiacomo.travaglini@arm.com  const char* source_text() const { return source_text_.c_str(); }
70113481Sgiacomo.travaglini@arm.com  // Returns the cardinality specified in the expectation spec.
70213481Sgiacomo.travaglini@arm.com  const Cardinality& cardinality() const { return cardinality_; }
70313481Sgiacomo.travaglini@arm.com
70413481Sgiacomo.travaglini@arm.com  // Describes the source file location of this expectation.
70513481Sgiacomo.travaglini@arm.com  void DescribeLocationTo(::std::ostream* os) const {
70613481Sgiacomo.travaglini@arm.com    *os << FormatFileLocation(file(), line()) << " ";
70713481Sgiacomo.travaglini@arm.com  }
70813481Sgiacomo.travaglini@arm.com
70913481Sgiacomo.travaglini@arm.com  // Describes how many times a function call matching this
71013481Sgiacomo.travaglini@arm.com  // expectation has occurred.
71113481Sgiacomo.travaglini@arm.com  void DescribeCallCountTo(::std::ostream* os) const
71213481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
71313481Sgiacomo.travaglini@arm.com
71413481Sgiacomo.travaglini@arm.com  // If this mock method has an extra matcher (i.e. .With(matcher)),
71513481Sgiacomo.travaglini@arm.com  // describes it to the ostream.
71613481Sgiacomo.travaglini@arm.com  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
71713481Sgiacomo.travaglini@arm.com
71813481Sgiacomo.travaglini@arm.com protected:
71913481Sgiacomo.travaglini@arm.com  friend class ::testing::Expectation;
72013481Sgiacomo.travaglini@arm.com  friend class UntypedFunctionMockerBase;
72113481Sgiacomo.travaglini@arm.com
72213481Sgiacomo.travaglini@arm.com  enum Clause {
72313481Sgiacomo.travaglini@arm.com    // Don't change the order of the enum members!
72413481Sgiacomo.travaglini@arm.com    kNone,
72513481Sgiacomo.travaglini@arm.com    kWith,
72613481Sgiacomo.travaglini@arm.com    kTimes,
72713481Sgiacomo.travaglini@arm.com    kInSequence,
72813481Sgiacomo.travaglini@arm.com    kAfter,
72913481Sgiacomo.travaglini@arm.com    kWillOnce,
73013481Sgiacomo.travaglini@arm.com    kWillRepeatedly,
73113481Sgiacomo.travaglini@arm.com    kRetiresOnSaturation
73213481Sgiacomo.travaglini@arm.com  };
73313481Sgiacomo.travaglini@arm.com
73413481Sgiacomo.travaglini@arm.com  typedef std::vector<const void*> UntypedActions;
73513481Sgiacomo.travaglini@arm.com
73613481Sgiacomo.travaglini@arm.com  // Returns an Expectation object that references and co-owns this
73713481Sgiacomo.travaglini@arm.com  // expectation.
73813481Sgiacomo.travaglini@arm.com  virtual Expectation GetHandle() = 0;
73913481Sgiacomo.travaglini@arm.com
74013481Sgiacomo.travaglini@arm.com  // Asserts that the EXPECT_CALL() statement has the given property.
74113481Sgiacomo.travaglini@arm.com  void AssertSpecProperty(bool property, const string& failure_message) const {
74213481Sgiacomo.travaglini@arm.com    Assert(property, file_, line_, failure_message);
74313481Sgiacomo.travaglini@arm.com  }
74413481Sgiacomo.travaglini@arm.com
74513481Sgiacomo.travaglini@arm.com  // Expects that the EXPECT_CALL() statement has the given property.
74613481Sgiacomo.travaglini@arm.com  void ExpectSpecProperty(bool property, const string& failure_message) const {
74713481Sgiacomo.travaglini@arm.com    Expect(property, file_, line_, failure_message);
74813481Sgiacomo.travaglini@arm.com  }
74913481Sgiacomo.travaglini@arm.com
75013481Sgiacomo.travaglini@arm.com  // Explicitly specifies the cardinality of this expectation.  Used
75113481Sgiacomo.travaglini@arm.com  // by the subclasses to implement the .Times() clause.
75213481Sgiacomo.travaglini@arm.com  void SpecifyCardinality(const Cardinality& cardinality);
75313481Sgiacomo.travaglini@arm.com
75413481Sgiacomo.travaglini@arm.com  // Returns true iff the user specified the cardinality explicitly
75513481Sgiacomo.travaglini@arm.com  // using a .Times().
75613481Sgiacomo.travaglini@arm.com  bool cardinality_specified() const { return cardinality_specified_; }
75713481Sgiacomo.travaglini@arm.com
75813481Sgiacomo.travaglini@arm.com  // Sets the cardinality of this expectation spec.
75913481Sgiacomo.travaglini@arm.com  void set_cardinality(const Cardinality& a_cardinality) {
76013481Sgiacomo.travaglini@arm.com    cardinality_ = a_cardinality;
76113481Sgiacomo.travaglini@arm.com  }
76213481Sgiacomo.travaglini@arm.com
76313481Sgiacomo.travaglini@arm.com  // The following group of methods should only be called after the
76413481Sgiacomo.travaglini@arm.com  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
76513481Sgiacomo.travaglini@arm.com  // the current thread.
76613481Sgiacomo.travaglini@arm.com
76713481Sgiacomo.travaglini@arm.com  // Retires all pre-requisites of this expectation.
76813481Sgiacomo.travaglini@arm.com  void RetireAllPreRequisites()
76913481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
77013481Sgiacomo.travaglini@arm.com
77113481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation is retired.
77213481Sgiacomo.travaglini@arm.com  bool is_retired() const
77313481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
77413481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
77513481Sgiacomo.travaglini@arm.com    return retired_;
77613481Sgiacomo.travaglini@arm.com  }
77713481Sgiacomo.travaglini@arm.com
77813481Sgiacomo.travaglini@arm.com  // Retires this expectation.
77913481Sgiacomo.travaglini@arm.com  void Retire()
78013481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
78113481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
78213481Sgiacomo.travaglini@arm.com    retired_ = true;
78313481Sgiacomo.travaglini@arm.com  }
78413481Sgiacomo.travaglini@arm.com
78513481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation is satisfied.
78613481Sgiacomo.travaglini@arm.com  bool IsSatisfied() const
78713481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
78813481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
78913481Sgiacomo.travaglini@arm.com    return cardinality().IsSatisfiedByCallCount(call_count_);
79013481Sgiacomo.travaglini@arm.com  }
79113481Sgiacomo.travaglini@arm.com
79213481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation is saturated.
79313481Sgiacomo.travaglini@arm.com  bool IsSaturated() const
79413481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
79513481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
79613481Sgiacomo.travaglini@arm.com    return cardinality().IsSaturatedByCallCount(call_count_);
79713481Sgiacomo.travaglini@arm.com  }
79813481Sgiacomo.travaglini@arm.com
79913481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation is over-saturated.
80013481Sgiacomo.travaglini@arm.com  bool IsOverSaturated() const
80113481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
80213481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
80313481Sgiacomo.travaglini@arm.com    return cardinality().IsOverSaturatedByCallCount(call_count_);
80413481Sgiacomo.travaglini@arm.com  }
80513481Sgiacomo.travaglini@arm.com
80613481Sgiacomo.travaglini@arm.com  // Returns true iff all pre-requisites of this expectation are satisfied.
80713481Sgiacomo.travaglini@arm.com  bool AllPrerequisitesAreSatisfied() const
80813481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
80913481Sgiacomo.travaglini@arm.com
81013481Sgiacomo.travaglini@arm.com  // Adds unsatisfied pre-requisites of this expectation to 'result'.
81113481Sgiacomo.travaglini@arm.com  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
81213481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
81313481Sgiacomo.travaglini@arm.com
81413481Sgiacomo.travaglini@arm.com  // Returns the number this expectation has been invoked.
81513481Sgiacomo.travaglini@arm.com  int call_count() const
81613481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
81713481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
81813481Sgiacomo.travaglini@arm.com    return call_count_;
81913481Sgiacomo.travaglini@arm.com  }
82013481Sgiacomo.travaglini@arm.com
82113481Sgiacomo.travaglini@arm.com  // Increments the number this expectation has been invoked.
82213481Sgiacomo.travaglini@arm.com  void IncrementCallCount()
82313481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
82413481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
82513481Sgiacomo.travaglini@arm.com    call_count_++;
82613481Sgiacomo.travaglini@arm.com  }
82713481Sgiacomo.travaglini@arm.com
82813481Sgiacomo.travaglini@arm.com  // Checks the action count (i.e. the number of WillOnce() and
82913481Sgiacomo.travaglini@arm.com  // WillRepeatedly() clauses) against the cardinality if this hasn't
83013481Sgiacomo.travaglini@arm.com  // been done before.  Prints a warning if there are too many or too
83113481Sgiacomo.travaglini@arm.com  // few actions.
83213481Sgiacomo.travaglini@arm.com  void CheckActionCountIfNotDone() const
83313481Sgiacomo.travaglini@arm.com      GTEST_LOCK_EXCLUDED_(mutex_);
83413481Sgiacomo.travaglini@arm.com
83513481Sgiacomo.travaglini@arm.com  friend class ::testing::Sequence;
83613481Sgiacomo.travaglini@arm.com  friend class ::testing::internal::ExpectationTester;
83713481Sgiacomo.travaglini@arm.com
83813481Sgiacomo.travaglini@arm.com  template <typename Function>
83913481Sgiacomo.travaglini@arm.com  friend class TypedExpectation;
84013481Sgiacomo.travaglini@arm.com
84113481Sgiacomo.travaglini@arm.com  // Implements the .Times() clause.
84213481Sgiacomo.travaglini@arm.com  void UntypedTimes(const Cardinality& a_cardinality);
84313481Sgiacomo.travaglini@arm.com
84413481Sgiacomo.travaglini@arm.com  // This group of fields are part of the spec and won't change after
84513481Sgiacomo.travaglini@arm.com  // an EXPECT_CALL() statement finishes.
84613481Sgiacomo.travaglini@arm.com  const char* file_;          // The file that contains the expectation.
84713481Sgiacomo.travaglini@arm.com  int line_;                  // The line number of the expectation.
84813481Sgiacomo.travaglini@arm.com  const string source_text_;  // The EXPECT_CALL(...) source text.
84913481Sgiacomo.travaglini@arm.com  // True iff the cardinality is specified explicitly.
85013481Sgiacomo.travaglini@arm.com  bool cardinality_specified_;
85113481Sgiacomo.travaglini@arm.com  Cardinality cardinality_;            // The cardinality of the expectation.
85213481Sgiacomo.travaglini@arm.com  // The immediate pre-requisites (i.e. expectations that must be
85313481Sgiacomo.travaglini@arm.com  // satisfied before this expectation can be matched) of this
85413481Sgiacomo.travaglini@arm.com  // expectation.  We use linked_ptr in the set because we want an
85513481Sgiacomo.travaglini@arm.com  // Expectation object to be co-owned by its FunctionMocker and its
85613481Sgiacomo.travaglini@arm.com  // successors.  This allows multiple mock objects to be deleted at
85713481Sgiacomo.travaglini@arm.com  // different times.
85813481Sgiacomo.travaglini@arm.com  ExpectationSet immediate_prerequisites_;
85913481Sgiacomo.travaglini@arm.com
86013481Sgiacomo.travaglini@arm.com  // This group of fields are the current state of the expectation,
86113481Sgiacomo.travaglini@arm.com  // and can change as the mock function is called.
86213481Sgiacomo.travaglini@arm.com  int call_count_;  // How many times this expectation has been invoked.
86313481Sgiacomo.travaglini@arm.com  bool retired_;    // True iff this expectation has retired.
86413481Sgiacomo.travaglini@arm.com  UntypedActions untyped_actions_;
86513481Sgiacomo.travaglini@arm.com  bool extra_matcher_specified_;
86613481Sgiacomo.travaglini@arm.com  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
86713481Sgiacomo.travaglini@arm.com  bool retires_on_saturation_;
86813481Sgiacomo.travaglini@arm.com  Clause last_clause_;
86913481Sgiacomo.travaglini@arm.com  mutable bool action_count_checked_;  // Under mutex_.
87013481Sgiacomo.travaglini@arm.com  mutable Mutex mutex_;  // Protects action_count_checked_.
87113481Sgiacomo.travaglini@arm.com
87213481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
87313481Sgiacomo.travaglini@arm.com};  // class ExpectationBase
87413481Sgiacomo.travaglini@arm.com
87513481Sgiacomo.travaglini@arm.com// Impements an expectation for the given function type.
87613481Sgiacomo.travaglini@arm.comtemplate <typename F>
87713481Sgiacomo.travaglini@arm.comclass TypedExpectation : public ExpectationBase {
87813481Sgiacomo.travaglini@arm.com public:
87913481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
88013481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
88113481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::Result Result;
88213481Sgiacomo.travaglini@arm.com
88313481Sgiacomo.travaglini@arm.com  TypedExpectation(FunctionMockerBase<F>* owner,
88413481Sgiacomo.travaglini@arm.com                   const char* a_file, int a_line, const string& a_source_text,
88513481Sgiacomo.travaglini@arm.com                   const ArgumentMatcherTuple& m)
88613481Sgiacomo.travaglini@arm.com      : ExpectationBase(a_file, a_line, a_source_text),
88713481Sgiacomo.travaglini@arm.com        owner_(owner),
88813481Sgiacomo.travaglini@arm.com        matchers_(m),
88913481Sgiacomo.travaglini@arm.com        // By default, extra_matcher_ should match anything.  However,
89013481Sgiacomo.travaglini@arm.com        // we cannot initialize it with _ as that triggers a compiler
89113481Sgiacomo.travaglini@arm.com        // bug in Symbian's C++ compiler (cannot decide between two
89213481Sgiacomo.travaglini@arm.com        // overloaded constructors of Matcher<const ArgumentTuple&>).
89313481Sgiacomo.travaglini@arm.com        extra_matcher_(A<const ArgumentTuple&>()),
89413481Sgiacomo.travaglini@arm.com        repeated_action_(DoDefault()) {}
89513481Sgiacomo.travaglini@arm.com
89613481Sgiacomo.travaglini@arm.com  virtual ~TypedExpectation() {
89713481Sgiacomo.travaglini@arm.com    // Check the validity of the action count if it hasn't been done
89813481Sgiacomo.travaglini@arm.com    // yet (for example, if the expectation was never used).
89913481Sgiacomo.travaglini@arm.com    CheckActionCountIfNotDone();
90013481Sgiacomo.travaglini@arm.com    for (UntypedActions::const_iterator it = untyped_actions_.begin();
90113481Sgiacomo.travaglini@arm.com         it != untyped_actions_.end(); ++it) {
90213481Sgiacomo.travaglini@arm.com      delete static_cast<const Action<F>*>(*it);
90313481Sgiacomo.travaglini@arm.com    }
90413481Sgiacomo.travaglini@arm.com  }
90513481Sgiacomo.travaglini@arm.com
90613481Sgiacomo.travaglini@arm.com  // Implements the .With() clause.
90713481Sgiacomo.travaglini@arm.com  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
90813481Sgiacomo.travaglini@arm.com    if (last_clause_ == kWith) {
90913481Sgiacomo.travaglini@arm.com      ExpectSpecProperty(false,
91013481Sgiacomo.travaglini@arm.com                         ".With() cannot appear "
91113481Sgiacomo.travaglini@arm.com                         "more than once in an EXPECT_CALL().");
91213481Sgiacomo.travaglini@arm.com    } else {
91313481Sgiacomo.travaglini@arm.com      ExpectSpecProperty(last_clause_ < kWith,
91413481Sgiacomo.travaglini@arm.com                         ".With() must be the first "
91513481Sgiacomo.travaglini@arm.com                         "clause in an EXPECT_CALL().");
91613481Sgiacomo.travaglini@arm.com    }
91713481Sgiacomo.travaglini@arm.com    last_clause_ = kWith;
91813481Sgiacomo.travaglini@arm.com
91913481Sgiacomo.travaglini@arm.com    extra_matcher_ = m;
92013481Sgiacomo.travaglini@arm.com    extra_matcher_specified_ = true;
92113481Sgiacomo.travaglini@arm.com    return *this;
92213481Sgiacomo.travaglini@arm.com  }
92313481Sgiacomo.travaglini@arm.com
92413481Sgiacomo.travaglini@arm.com  // Implements the .Times() clause.
92513481Sgiacomo.travaglini@arm.com  TypedExpectation& Times(const Cardinality& a_cardinality) {
92613481Sgiacomo.travaglini@arm.com    ExpectationBase::UntypedTimes(a_cardinality);
92713481Sgiacomo.travaglini@arm.com    return *this;
92813481Sgiacomo.travaglini@arm.com  }
92913481Sgiacomo.travaglini@arm.com
93013481Sgiacomo.travaglini@arm.com  // Implements the .Times() clause.
93113481Sgiacomo.travaglini@arm.com  TypedExpectation& Times(int n) {
93213481Sgiacomo.travaglini@arm.com    return Times(Exactly(n));
93313481Sgiacomo.travaglini@arm.com  }
93413481Sgiacomo.travaglini@arm.com
93513481Sgiacomo.travaglini@arm.com  // Implements the .InSequence() clause.
93613481Sgiacomo.travaglini@arm.com  TypedExpectation& InSequence(const Sequence& s) {
93713481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ <= kInSequence,
93813481Sgiacomo.travaglini@arm.com                       ".InSequence() cannot appear after .After(),"
93913481Sgiacomo.travaglini@arm.com                       " .WillOnce(), .WillRepeatedly(), or "
94013481Sgiacomo.travaglini@arm.com                       ".RetiresOnSaturation().");
94113481Sgiacomo.travaglini@arm.com    last_clause_ = kInSequence;
94213481Sgiacomo.travaglini@arm.com
94313481Sgiacomo.travaglini@arm.com    s.AddExpectation(GetHandle());
94413481Sgiacomo.travaglini@arm.com    return *this;
94513481Sgiacomo.travaglini@arm.com  }
94613481Sgiacomo.travaglini@arm.com  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
94713481Sgiacomo.travaglini@arm.com    return InSequence(s1).InSequence(s2);
94813481Sgiacomo.travaglini@arm.com  }
94913481Sgiacomo.travaglini@arm.com  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
95013481Sgiacomo.travaglini@arm.com                               const Sequence& s3) {
95113481Sgiacomo.travaglini@arm.com    return InSequence(s1, s2).InSequence(s3);
95213481Sgiacomo.travaglini@arm.com  }
95313481Sgiacomo.travaglini@arm.com  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
95413481Sgiacomo.travaglini@arm.com                               const Sequence& s3, const Sequence& s4) {
95513481Sgiacomo.travaglini@arm.com    return InSequence(s1, s2, s3).InSequence(s4);
95613481Sgiacomo.travaglini@arm.com  }
95713481Sgiacomo.travaglini@arm.com  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
95813481Sgiacomo.travaglini@arm.com                               const Sequence& s3, const Sequence& s4,
95913481Sgiacomo.travaglini@arm.com                               const Sequence& s5) {
96013481Sgiacomo.travaglini@arm.com    return InSequence(s1, s2, s3, s4).InSequence(s5);
96113481Sgiacomo.travaglini@arm.com  }
96213481Sgiacomo.travaglini@arm.com
96313481Sgiacomo.travaglini@arm.com  // Implements that .After() clause.
96413481Sgiacomo.travaglini@arm.com  TypedExpectation& After(const ExpectationSet& s) {
96513481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ <= kAfter,
96613481Sgiacomo.travaglini@arm.com                       ".After() cannot appear after .WillOnce(),"
96713481Sgiacomo.travaglini@arm.com                       " .WillRepeatedly(), or "
96813481Sgiacomo.travaglini@arm.com                       ".RetiresOnSaturation().");
96913481Sgiacomo.travaglini@arm.com    last_clause_ = kAfter;
97013481Sgiacomo.travaglini@arm.com
97113481Sgiacomo.travaglini@arm.com    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
97213481Sgiacomo.travaglini@arm.com      immediate_prerequisites_ += *it;
97313481Sgiacomo.travaglini@arm.com    }
97413481Sgiacomo.travaglini@arm.com    return *this;
97513481Sgiacomo.travaglini@arm.com  }
97613481Sgiacomo.travaglini@arm.com  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
97713481Sgiacomo.travaglini@arm.com    return After(s1).After(s2);
97813481Sgiacomo.travaglini@arm.com  }
97913481Sgiacomo.travaglini@arm.com  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
98013481Sgiacomo.travaglini@arm.com                          const ExpectationSet& s3) {
98113481Sgiacomo.travaglini@arm.com    return After(s1, s2).After(s3);
98213481Sgiacomo.travaglini@arm.com  }
98313481Sgiacomo.travaglini@arm.com  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
98413481Sgiacomo.travaglini@arm.com                          const ExpectationSet& s3, const ExpectationSet& s4) {
98513481Sgiacomo.travaglini@arm.com    return After(s1, s2, s3).After(s4);
98613481Sgiacomo.travaglini@arm.com  }
98713481Sgiacomo.travaglini@arm.com  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
98813481Sgiacomo.travaglini@arm.com                          const ExpectationSet& s3, const ExpectationSet& s4,
98913481Sgiacomo.travaglini@arm.com                          const ExpectationSet& s5) {
99013481Sgiacomo.travaglini@arm.com    return After(s1, s2, s3, s4).After(s5);
99113481Sgiacomo.travaglini@arm.com  }
99213481Sgiacomo.travaglini@arm.com
99313481Sgiacomo.travaglini@arm.com  // Implements the .WillOnce() clause.
99413481Sgiacomo.travaglini@arm.com  TypedExpectation& WillOnce(const Action<F>& action) {
99513481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ <= kWillOnce,
99613481Sgiacomo.travaglini@arm.com                       ".WillOnce() cannot appear after "
99713481Sgiacomo.travaglini@arm.com                       ".WillRepeatedly() or .RetiresOnSaturation().");
99813481Sgiacomo.travaglini@arm.com    last_clause_ = kWillOnce;
99913481Sgiacomo.travaglini@arm.com
100013481Sgiacomo.travaglini@arm.com    untyped_actions_.push_back(new Action<F>(action));
100113481Sgiacomo.travaglini@arm.com    if (!cardinality_specified()) {
100213481Sgiacomo.travaglini@arm.com      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
100313481Sgiacomo.travaglini@arm.com    }
100413481Sgiacomo.travaglini@arm.com    return *this;
100513481Sgiacomo.travaglini@arm.com  }
100613481Sgiacomo.travaglini@arm.com
100713481Sgiacomo.travaglini@arm.com  // Implements the .WillRepeatedly() clause.
100813481Sgiacomo.travaglini@arm.com  TypedExpectation& WillRepeatedly(const Action<F>& action) {
100913481Sgiacomo.travaglini@arm.com    if (last_clause_ == kWillRepeatedly) {
101013481Sgiacomo.travaglini@arm.com      ExpectSpecProperty(false,
101113481Sgiacomo.travaglini@arm.com                         ".WillRepeatedly() cannot appear "
101213481Sgiacomo.travaglini@arm.com                         "more than once in an EXPECT_CALL().");
101313481Sgiacomo.travaglini@arm.com    } else {
101413481Sgiacomo.travaglini@arm.com      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
101513481Sgiacomo.travaglini@arm.com                         ".WillRepeatedly() cannot appear "
101613481Sgiacomo.travaglini@arm.com                         "after .RetiresOnSaturation().");
101713481Sgiacomo.travaglini@arm.com    }
101813481Sgiacomo.travaglini@arm.com    last_clause_ = kWillRepeatedly;
101913481Sgiacomo.travaglini@arm.com    repeated_action_specified_ = true;
102013481Sgiacomo.travaglini@arm.com
102113481Sgiacomo.travaglini@arm.com    repeated_action_ = action;
102213481Sgiacomo.travaglini@arm.com    if (!cardinality_specified()) {
102313481Sgiacomo.travaglini@arm.com      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
102413481Sgiacomo.travaglini@arm.com    }
102513481Sgiacomo.travaglini@arm.com
102613481Sgiacomo.travaglini@arm.com    // Now that no more action clauses can be specified, we check
102713481Sgiacomo.travaglini@arm.com    // whether their count makes sense.
102813481Sgiacomo.travaglini@arm.com    CheckActionCountIfNotDone();
102913481Sgiacomo.travaglini@arm.com    return *this;
103013481Sgiacomo.travaglini@arm.com  }
103113481Sgiacomo.travaglini@arm.com
103213481Sgiacomo.travaglini@arm.com  // Implements the .RetiresOnSaturation() clause.
103313481Sgiacomo.travaglini@arm.com  TypedExpectation& RetiresOnSaturation() {
103413481Sgiacomo.travaglini@arm.com    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
103513481Sgiacomo.travaglini@arm.com                       ".RetiresOnSaturation() cannot appear "
103613481Sgiacomo.travaglini@arm.com                       "more than once.");
103713481Sgiacomo.travaglini@arm.com    last_clause_ = kRetiresOnSaturation;
103813481Sgiacomo.travaglini@arm.com    retires_on_saturation_ = true;
103913481Sgiacomo.travaglini@arm.com
104013481Sgiacomo.travaglini@arm.com    // Now that no more action clauses can be specified, we check
104113481Sgiacomo.travaglini@arm.com    // whether their count makes sense.
104213481Sgiacomo.travaglini@arm.com    CheckActionCountIfNotDone();
104313481Sgiacomo.travaglini@arm.com    return *this;
104413481Sgiacomo.travaglini@arm.com  }
104513481Sgiacomo.travaglini@arm.com
104613481Sgiacomo.travaglini@arm.com  // Returns the matchers for the arguments as specified inside the
104713481Sgiacomo.travaglini@arm.com  // EXPECT_CALL() macro.
104813481Sgiacomo.travaglini@arm.com  const ArgumentMatcherTuple& matchers() const {
104913481Sgiacomo.travaglini@arm.com    return matchers_;
105013481Sgiacomo.travaglini@arm.com  }
105113481Sgiacomo.travaglini@arm.com
105213481Sgiacomo.travaglini@arm.com  // Returns the matcher specified by the .With() clause.
105313481Sgiacomo.travaglini@arm.com  const Matcher<const ArgumentTuple&>& extra_matcher() const {
105413481Sgiacomo.travaglini@arm.com    return extra_matcher_;
105513481Sgiacomo.travaglini@arm.com  }
105613481Sgiacomo.travaglini@arm.com
105713481Sgiacomo.travaglini@arm.com  // Returns the action specified by the .WillRepeatedly() clause.
105813481Sgiacomo.travaglini@arm.com  const Action<F>& repeated_action() const { return repeated_action_; }
105913481Sgiacomo.travaglini@arm.com
106013481Sgiacomo.travaglini@arm.com  // If this mock method has an extra matcher (i.e. .With(matcher)),
106113481Sgiacomo.travaglini@arm.com  // describes it to the ostream.
106213481Sgiacomo.travaglini@arm.com  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) {
106313481Sgiacomo.travaglini@arm.com    if (extra_matcher_specified_) {
106413481Sgiacomo.travaglini@arm.com      *os << "    Expected args: ";
106513481Sgiacomo.travaglini@arm.com      extra_matcher_.DescribeTo(os);
106613481Sgiacomo.travaglini@arm.com      *os << "\n";
106713481Sgiacomo.travaglini@arm.com    }
106813481Sgiacomo.travaglini@arm.com  }
106913481Sgiacomo.travaglini@arm.com
107013481Sgiacomo.travaglini@arm.com private:
107113481Sgiacomo.travaglini@arm.com  template <typename Function>
107213481Sgiacomo.travaglini@arm.com  friend class FunctionMockerBase;
107313481Sgiacomo.travaglini@arm.com
107413481Sgiacomo.travaglini@arm.com  // Returns an Expectation object that references and co-owns this
107513481Sgiacomo.travaglini@arm.com  // expectation.
107613481Sgiacomo.travaglini@arm.com  virtual Expectation GetHandle() {
107713481Sgiacomo.travaglini@arm.com    return owner_->GetHandleOf(this);
107813481Sgiacomo.travaglini@arm.com  }
107913481Sgiacomo.travaglini@arm.com
108013481Sgiacomo.travaglini@arm.com  // The following methods will be called only after the EXPECT_CALL()
108113481Sgiacomo.travaglini@arm.com  // statement finishes and when the current thread holds
108213481Sgiacomo.travaglini@arm.com  // g_gmock_mutex.
108313481Sgiacomo.travaglini@arm.com
108413481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation matches the given arguments.
108513481Sgiacomo.travaglini@arm.com  bool Matches(const ArgumentTuple& args) const
108613481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
108713481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
108813481Sgiacomo.travaglini@arm.com    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
108913481Sgiacomo.travaglini@arm.com  }
109013481Sgiacomo.travaglini@arm.com
109113481Sgiacomo.travaglini@arm.com  // Returns true iff this expectation should handle the given arguments.
109213481Sgiacomo.travaglini@arm.com  bool ShouldHandleArguments(const ArgumentTuple& args) const
109313481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
109413481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
109513481Sgiacomo.travaglini@arm.com
109613481Sgiacomo.travaglini@arm.com    // In case the action count wasn't checked when the expectation
109713481Sgiacomo.travaglini@arm.com    // was defined (e.g. if this expectation has no WillRepeatedly()
109813481Sgiacomo.travaglini@arm.com    // or RetiresOnSaturation() clause), we check it when the
109913481Sgiacomo.travaglini@arm.com    // expectation is used for the first time.
110013481Sgiacomo.travaglini@arm.com    CheckActionCountIfNotDone();
110113481Sgiacomo.travaglini@arm.com    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
110213481Sgiacomo.travaglini@arm.com  }
110313481Sgiacomo.travaglini@arm.com
110413481Sgiacomo.travaglini@arm.com  // Describes the result of matching the arguments against this
110513481Sgiacomo.travaglini@arm.com  // expectation to the given ostream.
110613481Sgiacomo.travaglini@arm.com  void ExplainMatchResultTo(
110713481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args,
110813481Sgiacomo.travaglini@arm.com      ::std::ostream* os) const
110913481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
111013481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
111113481Sgiacomo.travaglini@arm.com
111213481Sgiacomo.travaglini@arm.com    if (is_retired()) {
111313481Sgiacomo.travaglini@arm.com      *os << "         Expected: the expectation is active\n"
111413481Sgiacomo.travaglini@arm.com          << "           Actual: it is retired\n";
111513481Sgiacomo.travaglini@arm.com    } else if (!Matches(args)) {
111613481Sgiacomo.travaglini@arm.com      if (!TupleMatches(matchers_, args)) {
111713481Sgiacomo.travaglini@arm.com        ExplainMatchFailureTupleTo(matchers_, args, os);
111813481Sgiacomo.travaglini@arm.com      }
111913481Sgiacomo.travaglini@arm.com      StringMatchResultListener listener;
112013481Sgiacomo.travaglini@arm.com      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
112113481Sgiacomo.travaglini@arm.com        *os << "    Expected args: ";
112213481Sgiacomo.travaglini@arm.com        extra_matcher_.DescribeTo(os);
112313481Sgiacomo.travaglini@arm.com        *os << "\n           Actual: don't match";
112413481Sgiacomo.travaglini@arm.com
112513481Sgiacomo.travaglini@arm.com        internal::PrintIfNotEmpty(listener.str(), os);
112613481Sgiacomo.travaglini@arm.com        *os << "\n";
112713481Sgiacomo.travaglini@arm.com      }
112813481Sgiacomo.travaglini@arm.com    } else if (!AllPrerequisitesAreSatisfied()) {
112913481Sgiacomo.travaglini@arm.com      *os << "         Expected: all pre-requisites are satisfied\n"
113013481Sgiacomo.travaglini@arm.com          << "           Actual: the following immediate pre-requisites "
113113481Sgiacomo.travaglini@arm.com          << "are not satisfied:\n";
113213481Sgiacomo.travaglini@arm.com      ExpectationSet unsatisfied_prereqs;
113313481Sgiacomo.travaglini@arm.com      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
113413481Sgiacomo.travaglini@arm.com      int i = 0;
113513481Sgiacomo.travaglini@arm.com      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
113613481Sgiacomo.travaglini@arm.com           it != unsatisfied_prereqs.end(); ++it) {
113713481Sgiacomo.travaglini@arm.com        it->expectation_base()->DescribeLocationTo(os);
113813481Sgiacomo.travaglini@arm.com        *os << "pre-requisite #" << i++ << "\n";
113913481Sgiacomo.travaglini@arm.com      }
114013481Sgiacomo.travaglini@arm.com      *os << "                   (end of pre-requisites)\n";
114113481Sgiacomo.travaglini@arm.com    } else {
114213481Sgiacomo.travaglini@arm.com      // This line is here just for completeness' sake.  It will never
114313481Sgiacomo.travaglini@arm.com      // be executed as currently the ExplainMatchResultTo() function
114413481Sgiacomo.travaglini@arm.com      // is called only when the mock function call does NOT match the
114513481Sgiacomo.travaglini@arm.com      // expectation.
114613481Sgiacomo.travaglini@arm.com      *os << "The call matches the expectation.\n";
114713481Sgiacomo.travaglini@arm.com    }
114813481Sgiacomo.travaglini@arm.com  }
114913481Sgiacomo.travaglini@arm.com
115013481Sgiacomo.travaglini@arm.com  // Returns the action that should be taken for the current invocation.
115113481Sgiacomo.travaglini@arm.com  const Action<F>& GetCurrentAction(
115213481Sgiacomo.travaglini@arm.com      const FunctionMockerBase<F>* mocker,
115313481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args) const
115413481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
115513481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
115613481Sgiacomo.travaglini@arm.com    const int count = call_count();
115713481Sgiacomo.travaglini@arm.com    Assert(count >= 1, __FILE__, __LINE__,
115813481Sgiacomo.travaglini@arm.com           "call_count() is <= 0 when GetCurrentAction() is "
115913481Sgiacomo.travaglini@arm.com           "called - this should never happen.");
116013481Sgiacomo.travaglini@arm.com
116113481Sgiacomo.travaglini@arm.com    const int action_count = static_cast<int>(untyped_actions_.size());
116213481Sgiacomo.travaglini@arm.com    if (action_count > 0 && !repeated_action_specified_ &&
116313481Sgiacomo.travaglini@arm.com        count > action_count) {
116413481Sgiacomo.travaglini@arm.com      // If there is at least one WillOnce() and no WillRepeatedly(),
116513481Sgiacomo.travaglini@arm.com      // we warn the user when the WillOnce() clauses ran out.
116613481Sgiacomo.travaglini@arm.com      ::std::stringstream ss;
116713481Sgiacomo.travaglini@arm.com      DescribeLocationTo(&ss);
116813481Sgiacomo.travaglini@arm.com      ss << "Actions ran out in " << source_text() << "...\n"
116913481Sgiacomo.travaglini@arm.com         << "Called " << count << " times, but only "
117013481Sgiacomo.travaglini@arm.com         << action_count << " WillOnce()"
117113481Sgiacomo.travaglini@arm.com         << (action_count == 1 ? " is" : "s are") << " specified - ";
117213481Sgiacomo.travaglini@arm.com      mocker->DescribeDefaultActionTo(args, &ss);
117313481Sgiacomo.travaglini@arm.com      Log(kWarning, ss.str(), 1);
117413481Sgiacomo.travaglini@arm.com    }
117513481Sgiacomo.travaglini@arm.com
117613481Sgiacomo.travaglini@arm.com    return count <= action_count ?
117713481Sgiacomo.travaglini@arm.com        *static_cast<const Action<F>*>(untyped_actions_[count - 1]) :
117813481Sgiacomo.travaglini@arm.com        repeated_action();
117913481Sgiacomo.travaglini@arm.com  }
118013481Sgiacomo.travaglini@arm.com
118113481Sgiacomo.travaglini@arm.com  // Given the arguments of a mock function call, if the call will
118213481Sgiacomo.travaglini@arm.com  // over-saturate this expectation, returns the default action;
118313481Sgiacomo.travaglini@arm.com  // otherwise, returns the next action in this expectation.  Also
118413481Sgiacomo.travaglini@arm.com  // describes *what* happened to 'what', and explains *why* Google
118513481Sgiacomo.travaglini@arm.com  // Mock does it to 'why'.  This method is not const as it calls
118613481Sgiacomo.travaglini@arm.com  // IncrementCallCount().  A return value of NULL means the default
118713481Sgiacomo.travaglini@arm.com  // action.
118813481Sgiacomo.travaglini@arm.com  const Action<F>* GetActionForArguments(
118913481Sgiacomo.travaglini@arm.com      const FunctionMockerBase<F>* mocker,
119013481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args,
119113481Sgiacomo.travaglini@arm.com      ::std::ostream* what,
119213481Sgiacomo.travaglini@arm.com      ::std::ostream* why)
119313481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
119413481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
119513481Sgiacomo.travaglini@arm.com    if (IsSaturated()) {
119613481Sgiacomo.travaglini@arm.com      // We have an excessive call.
119713481Sgiacomo.travaglini@arm.com      IncrementCallCount();
119813481Sgiacomo.travaglini@arm.com      *what << "Mock function called more times than expected - ";
119913481Sgiacomo.travaglini@arm.com      mocker->DescribeDefaultActionTo(args, what);
120013481Sgiacomo.travaglini@arm.com      DescribeCallCountTo(why);
120113481Sgiacomo.travaglini@arm.com
120213481Sgiacomo.travaglini@arm.com      // TODO(wan@google.com): allow the user to control whether
120313481Sgiacomo.travaglini@arm.com      // unexpected calls should fail immediately or continue using a
120413481Sgiacomo.travaglini@arm.com      // flag --gmock_unexpected_calls_are_fatal.
120513481Sgiacomo.travaglini@arm.com      return NULL;
120613481Sgiacomo.travaglini@arm.com    }
120713481Sgiacomo.travaglini@arm.com
120813481Sgiacomo.travaglini@arm.com    IncrementCallCount();
120913481Sgiacomo.travaglini@arm.com    RetireAllPreRequisites();
121013481Sgiacomo.travaglini@arm.com
121113481Sgiacomo.travaglini@arm.com    if (retires_on_saturation_ && IsSaturated()) {
121213481Sgiacomo.travaglini@arm.com      Retire();
121313481Sgiacomo.travaglini@arm.com    }
121413481Sgiacomo.travaglini@arm.com
121513481Sgiacomo.travaglini@arm.com    // Must be done after IncrementCount()!
121613481Sgiacomo.travaglini@arm.com    *what << "Mock function call matches " << source_text() <<"...\n";
121713481Sgiacomo.travaglini@arm.com    return &(GetCurrentAction(mocker, args));
121813481Sgiacomo.travaglini@arm.com  }
121913481Sgiacomo.travaglini@arm.com
122013481Sgiacomo.travaglini@arm.com  // All the fields below won't change once the EXPECT_CALL()
122113481Sgiacomo.travaglini@arm.com  // statement finishes.
122213481Sgiacomo.travaglini@arm.com  FunctionMockerBase<F>* const owner_;
122313481Sgiacomo.travaglini@arm.com  ArgumentMatcherTuple matchers_;
122413481Sgiacomo.travaglini@arm.com  Matcher<const ArgumentTuple&> extra_matcher_;
122513481Sgiacomo.travaglini@arm.com  Action<F> repeated_action_;
122613481Sgiacomo.travaglini@arm.com
122713481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
122813481Sgiacomo.travaglini@arm.com};  // class TypedExpectation
122913481Sgiacomo.travaglini@arm.com
123013481Sgiacomo.travaglini@arm.com// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
123113481Sgiacomo.travaglini@arm.com// specifying the default behavior of, or expectation on, a mock
123213481Sgiacomo.travaglini@arm.com// function.
123313481Sgiacomo.travaglini@arm.com
123413481Sgiacomo.travaglini@arm.com// Note: class MockSpec really belongs to the ::testing namespace.
123513481Sgiacomo.travaglini@arm.com// However if we define it in ::testing, MSVC will complain when
123613481Sgiacomo.travaglini@arm.com// classes in ::testing::internal declare it as a friend class
123713481Sgiacomo.travaglini@arm.com// template.  To workaround this compiler bug, we define MockSpec in
123813481Sgiacomo.travaglini@arm.com// ::testing::internal and import it into ::testing.
123913481Sgiacomo.travaglini@arm.com
124013481Sgiacomo.travaglini@arm.com// Logs a message including file and line number information.
124113481Sgiacomo.travaglini@arm.comGTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
124213481Sgiacomo.travaglini@arm.com                                const char* file, int line,
124313481Sgiacomo.travaglini@arm.com                                const string& message);
124413481Sgiacomo.travaglini@arm.com
124513481Sgiacomo.travaglini@arm.comtemplate <typename F>
124613481Sgiacomo.travaglini@arm.comclass MockSpec {
124713481Sgiacomo.travaglini@arm.com public:
124813481Sgiacomo.travaglini@arm.com  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
124913481Sgiacomo.travaglini@arm.com  typedef typename internal::Function<F>::ArgumentMatcherTuple
125013481Sgiacomo.travaglini@arm.com      ArgumentMatcherTuple;
125113481Sgiacomo.travaglini@arm.com
125213481Sgiacomo.travaglini@arm.com  // Constructs a MockSpec object, given the function mocker object
125313481Sgiacomo.travaglini@arm.com  // that the spec is associated with.
125413481Sgiacomo.travaglini@arm.com  explicit MockSpec(internal::FunctionMockerBase<F>* function_mocker)
125513481Sgiacomo.travaglini@arm.com      : function_mocker_(function_mocker) {}
125613481Sgiacomo.travaglini@arm.com
125713481Sgiacomo.travaglini@arm.com  // Adds a new default action spec to the function mocker and returns
125813481Sgiacomo.travaglini@arm.com  // the newly created spec.
125913481Sgiacomo.travaglini@arm.com  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
126013481Sgiacomo.travaglini@arm.com      const char* file, int line, const char* obj, const char* call) {
126113481Sgiacomo.travaglini@arm.com    LogWithLocation(internal::kInfo, file, line,
126213481Sgiacomo.travaglini@arm.com        string("ON_CALL(") + obj + ", " + call + ") invoked");
126313481Sgiacomo.travaglini@arm.com    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
126413481Sgiacomo.travaglini@arm.com  }
126513481Sgiacomo.travaglini@arm.com
126613481Sgiacomo.travaglini@arm.com  // Adds a new expectation spec to the function mocker and returns
126713481Sgiacomo.travaglini@arm.com  // the newly created spec.
126813481Sgiacomo.travaglini@arm.com  internal::TypedExpectation<F>& InternalExpectedAt(
126913481Sgiacomo.travaglini@arm.com      const char* file, int line, const char* obj, const char* call) {
127013481Sgiacomo.travaglini@arm.com    const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
127113481Sgiacomo.travaglini@arm.com    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
127213481Sgiacomo.travaglini@arm.com    return function_mocker_->AddNewExpectation(
127313481Sgiacomo.travaglini@arm.com        file, line, source_text, matchers_);
127413481Sgiacomo.travaglini@arm.com  }
127513481Sgiacomo.travaglini@arm.com
127613481Sgiacomo.travaglini@arm.com private:
127713481Sgiacomo.travaglini@arm.com  template <typename Function>
127813481Sgiacomo.travaglini@arm.com  friend class internal::FunctionMocker;
127913481Sgiacomo.travaglini@arm.com
128013481Sgiacomo.travaglini@arm.com  void SetMatchers(const ArgumentMatcherTuple& matchers) {
128113481Sgiacomo.travaglini@arm.com    matchers_ = matchers;
128213481Sgiacomo.travaglini@arm.com  }
128313481Sgiacomo.travaglini@arm.com
128413481Sgiacomo.travaglini@arm.com  // The function mocker that owns this spec.
128513481Sgiacomo.travaglini@arm.com  internal::FunctionMockerBase<F>* const function_mocker_;
128613481Sgiacomo.travaglini@arm.com  // The argument matchers specified in the spec.
128713481Sgiacomo.travaglini@arm.com  ArgumentMatcherTuple matchers_;
128813481Sgiacomo.travaglini@arm.com
128913481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_ASSIGN_(MockSpec);
129013481Sgiacomo.travaglini@arm.com};  // class MockSpec
129113481Sgiacomo.travaglini@arm.com
129213481Sgiacomo.travaglini@arm.com// Wrapper type for generically holding an ordinary value or lvalue reference.
129313481Sgiacomo.travaglini@arm.com// If T is not a reference type, it must be copyable or movable.
129413481Sgiacomo.travaglini@arm.com// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
129513481Sgiacomo.travaglini@arm.com// T is a move-only value type (which means that it will always be copyable
129613481Sgiacomo.travaglini@arm.com// if the current platform does not support move semantics).
129713481Sgiacomo.travaglini@arm.com//
129813481Sgiacomo.travaglini@arm.com// The primary template defines handling for values, but function header
129913481Sgiacomo.travaglini@arm.com// comments describe the contract for the whole template (including
130013481Sgiacomo.travaglini@arm.com// specializations).
130113481Sgiacomo.travaglini@arm.comtemplate <typename T>
130213481Sgiacomo.travaglini@arm.comclass ReferenceOrValueWrapper {
130313481Sgiacomo.travaglini@arm.com public:
130413481Sgiacomo.travaglini@arm.com  // Constructs a wrapper from the given value/reference.
130513481Sgiacomo.travaglini@arm.com  explicit ReferenceOrValueWrapper(T value)
130613481Sgiacomo.travaglini@arm.com      : value_(::testing::internal::move(value)) {
130713481Sgiacomo.travaglini@arm.com  }
130813481Sgiacomo.travaglini@arm.com
130913481Sgiacomo.travaglini@arm.com  // Unwraps and returns the underlying value/reference, exactly as
131013481Sgiacomo.travaglini@arm.com  // originally passed. The behavior of calling this more than once on
131113481Sgiacomo.travaglini@arm.com  // the same object is unspecified.
131213481Sgiacomo.travaglini@arm.com  T Unwrap() { return ::testing::internal::move(value_); }
131313481Sgiacomo.travaglini@arm.com
131413481Sgiacomo.travaglini@arm.com  // Provides nondestructive access to the underlying value/reference.
131513481Sgiacomo.travaglini@arm.com  // Always returns a const reference (more precisely,
131613481Sgiacomo.travaglini@arm.com  // const RemoveReference<T>&). The behavior of calling this after
131713481Sgiacomo.travaglini@arm.com  // calling Unwrap on the same object is unspecified.
131813481Sgiacomo.travaglini@arm.com  const T& Peek() const {
131913481Sgiacomo.travaglini@arm.com    return value_;
132013481Sgiacomo.travaglini@arm.com  }
132113481Sgiacomo.travaglini@arm.com
132213481Sgiacomo.travaglini@arm.com private:
132313481Sgiacomo.travaglini@arm.com  T value_;
132413481Sgiacomo.travaglini@arm.com};
132513481Sgiacomo.travaglini@arm.com
132613481Sgiacomo.travaglini@arm.com// Specialization for lvalue reference types. See primary template
132713481Sgiacomo.travaglini@arm.com// for documentation.
132813481Sgiacomo.travaglini@arm.comtemplate <typename T>
132913481Sgiacomo.travaglini@arm.comclass ReferenceOrValueWrapper<T&> {
133013481Sgiacomo.travaglini@arm.com public:
133113481Sgiacomo.travaglini@arm.com  // Workaround for debatable pass-by-reference lint warning (c-library-team
133213481Sgiacomo.travaglini@arm.com  // policy precludes NOLINT in this context)
133313481Sgiacomo.travaglini@arm.com  typedef T& reference;
133413481Sgiacomo.travaglini@arm.com  explicit ReferenceOrValueWrapper(reference ref)
133513481Sgiacomo.travaglini@arm.com      : value_ptr_(&ref) {}
133613481Sgiacomo.travaglini@arm.com  T& Unwrap() { return *value_ptr_; }
133713481Sgiacomo.travaglini@arm.com  const T& Peek() const { return *value_ptr_; }
133813481Sgiacomo.travaglini@arm.com
133913481Sgiacomo.travaglini@arm.com private:
134013481Sgiacomo.travaglini@arm.com  T* value_ptr_;
134113481Sgiacomo.travaglini@arm.com};
134213481Sgiacomo.travaglini@arm.com
134313481Sgiacomo.travaglini@arm.com// MSVC warns about using 'this' in base member initializer list, so
134413481Sgiacomo.travaglini@arm.com// we need to temporarily disable the warning.  We have to do it for
134513481Sgiacomo.travaglini@arm.com// the entire class to suppress the warning, even though it's about
134613481Sgiacomo.travaglini@arm.com// the constructor only.
134713481Sgiacomo.travaglini@arm.com
134813481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER
134913481Sgiacomo.travaglini@arm.com# pragma warning(push)          // Saves the current warning state.
135013481Sgiacomo.travaglini@arm.com# pragma warning(disable:4355)  // Temporarily disables warning 4355.
135113481Sgiacomo.travaglini@arm.com#endif  // _MSV_VER
135213481Sgiacomo.travaglini@arm.com
135313481Sgiacomo.travaglini@arm.com// C++ treats the void type specially.  For example, you cannot define
135413481Sgiacomo.travaglini@arm.com// a void-typed variable or pass a void value to a function.
135513481Sgiacomo.travaglini@arm.com// ActionResultHolder<T> holds a value of type T, where T must be a
135613481Sgiacomo.travaglini@arm.com// copyable type or void (T doesn't need to be default-constructable).
135713481Sgiacomo.travaglini@arm.com// It hides the syntactic difference between void and other types, and
135813481Sgiacomo.travaglini@arm.com// is used to unify the code for invoking both void-returning and
135913481Sgiacomo.travaglini@arm.com// non-void-returning mock functions.
136013481Sgiacomo.travaglini@arm.com
136113481Sgiacomo.travaglini@arm.com// Untyped base class for ActionResultHolder<T>.
136213481Sgiacomo.travaglini@arm.comclass UntypedActionResultHolderBase {
136313481Sgiacomo.travaglini@arm.com public:
136413481Sgiacomo.travaglini@arm.com  virtual ~UntypedActionResultHolderBase() {}
136513481Sgiacomo.travaglini@arm.com
136613481Sgiacomo.travaglini@arm.com  // Prints the held value as an action's result to os.
136713481Sgiacomo.travaglini@arm.com  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
136813481Sgiacomo.travaglini@arm.com};
136913481Sgiacomo.travaglini@arm.com
137013481Sgiacomo.travaglini@arm.com// This generic definition is used when T is not void.
137113481Sgiacomo.travaglini@arm.comtemplate <typename T>
137213481Sgiacomo.travaglini@arm.comclass ActionResultHolder : public UntypedActionResultHolderBase {
137313481Sgiacomo.travaglini@arm.com public:
137413481Sgiacomo.travaglini@arm.com  // Returns the held value. Must not be called more than once.
137513481Sgiacomo.travaglini@arm.com  T Unwrap() {
137613481Sgiacomo.travaglini@arm.com    return result_.Unwrap();
137713481Sgiacomo.travaglini@arm.com  }
137813481Sgiacomo.travaglini@arm.com
137913481Sgiacomo.travaglini@arm.com  // Prints the held value as an action's result to os.
138013481Sgiacomo.travaglini@arm.com  virtual void PrintAsActionResult(::std::ostream* os) const {
138113481Sgiacomo.travaglini@arm.com    *os << "\n          Returns: ";
138213481Sgiacomo.travaglini@arm.com    // T may be a reference type, so we don't use UniversalPrint().
138313481Sgiacomo.travaglini@arm.com    UniversalPrinter<T>::Print(result_.Peek(), os);
138413481Sgiacomo.travaglini@arm.com  }
138513481Sgiacomo.travaglini@arm.com
138613481Sgiacomo.travaglini@arm.com  // Performs the given mock function's default action and returns the
138713481Sgiacomo.travaglini@arm.com  // result in a new-ed ActionResultHolder.
138813481Sgiacomo.travaglini@arm.com  template <typename F>
138913481Sgiacomo.travaglini@arm.com  static ActionResultHolder* PerformDefaultAction(
139013481Sgiacomo.travaglini@arm.com      const FunctionMockerBase<F>* func_mocker,
139113481Sgiacomo.travaglini@arm.com      const typename Function<F>::ArgumentTuple& args,
139213481Sgiacomo.travaglini@arm.com      const string& call_description) {
139313481Sgiacomo.travaglini@arm.com    return new ActionResultHolder(Wrapper(
139413481Sgiacomo.travaglini@arm.com        func_mocker->PerformDefaultAction(args, call_description)));
139513481Sgiacomo.travaglini@arm.com  }
139613481Sgiacomo.travaglini@arm.com
139713481Sgiacomo.travaglini@arm.com  // Performs the given action and returns the result in a new-ed
139813481Sgiacomo.travaglini@arm.com  // ActionResultHolder.
139913481Sgiacomo.travaglini@arm.com  template <typename F>
140013481Sgiacomo.travaglini@arm.com  static ActionResultHolder*
140113481Sgiacomo.travaglini@arm.com  PerformAction(const Action<F>& action,
140213481Sgiacomo.travaglini@arm.com                const typename Function<F>::ArgumentTuple& args) {
140313481Sgiacomo.travaglini@arm.com    return new ActionResultHolder(Wrapper(action.Perform(args)));
140413481Sgiacomo.travaglini@arm.com  }
140513481Sgiacomo.travaglini@arm.com
140613481Sgiacomo.travaglini@arm.com private:
140713481Sgiacomo.travaglini@arm.com  typedef ReferenceOrValueWrapper<T> Wrapper;
140813481Sgiacomo.travaglini@arm.com
140913481Sgiacomo.travaglini@arm.com  explicit ActionResultHolder(Wrapper result)
141013481Sgiacomo.travaglini@arm.com      : result_(::testing::internal::move(result)) {
141113481Sgiacomo.travaglini@arm.com  }
141213481Sgiacomo.travaglini@arm.com
141313481Sgiacomo.travaglini@arm.com  Wrapper result_;
141413481Sgiacomo.travaglini@arm.com
141513481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
141613481Sgiacomo.travaglini@arm.com};
141713481Sgiacomo.travaglini@arm.com
141813481Sgiacomo.travaglini@arm.com// Specialization for T = void.
141913481Sgiacomo.travaglini@arm.comtemplate <>
142013481Sgiacomo.travaglini@arm.comclass ActionResultHolder<void> : public UntypedActionResultHolderBase {
142113481Sgiacomo.travaglini@arm.com public:
142213481Sgiacomo.travaglini@arm.com  void Unwrap() { }
142313481Sgiacomo.travaglini@arm.com
142413481Sgiacomo.travaglini@arm.com  virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
142513481Sgiacomo.travaglini@arm.com
142613481Sgiacomo.travaglini@arm.com  // Performs the given mock function's default action and returns ownership
142713481Sgiacomo.travaglini@arm.com  // of an empty ActionResultHolder*.
142813481Sgiacomo.travaglini@arm.com  template <typename F>
142913481Sgiacomo.travaglini@arm.com  static ActionResultHolder* PerformDefaultAction(
143013481Sgiacomo.travaglini@arm.com      const FunctionMockerBase<F>* func_mocker,
143113481Sgiacomo.travaglini@arm.com      const typename Function<F>::ArgumentTuple& args,
143213481Sgiacomo.travaglini@arm.com      const string& call_description) {
143313481Sgiacomo.travaglini@arm.com    func_mocker->PerformDefaultAction(args, call_description);
143413481Sgiacomo.travaglini@arm.com    return new ActionResultHolder;
143513481Sgiacomo.travaglini@arm.com  }
143613481Sgiacomo.travaglini@arm.com
143713481Sgiacomo.travaglini@arm.com  // Performs the given action and returns ownership of an empty
143813481Sgiacomo.travaglini@arm.com  // ActionResultHolder*.
143913481Sgiacomo.travaglini@arm.com  template <typename F>
144013481Sgiacomo.travaglini@arm.com  static ActionResultHolder* PerformAction(
144113481Sgiacomo.travaglini@arm.com      const Action<F>& action,
144213481Sgiacomo.travaglini@arm.com      const typename Function<F>::ArgumentTuple& args) {
144313481Sgiacomo.travaglini@arm.com    action.Perform(args);
144413481Sgiacomo.travaglini@arm.com    return new ActionResultHolder;
144513481Sgiacomo.travaglini@arm.com  }
144613481Sgiacomo.travaglini@arm.com
144713481Sgiacomo.travaglini@arm.com private:
144813481Sgiacomo.travaglini@arm.com  ActionResultHolder() {}
144913481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
145013481Sgiacomo.travaglini@arm.com};
145113481Sgiacomo.travaglini@arm.com
145213481Sgiacomo.travaglini@arm.com// The base of the function mocker class for the given function type.
145313481Sgiacomo.travaglini@arm.com// We put the methods in this class instead of its child to avoid code
145413481Sgiacomo.travaglini@arm.com// bloat.
145513481Sgiacomo.travaglini@arm.comtemplate <typename F>
145613481Sgiacomo.travaglini@arm.comclass FunctionMockerBase : public UntypedFunctionMockerBase {
145713481Sgiacomo.travaglini@arm.com public:
145813481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::Result Result;
145913481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
146013481Sgiacomo.travaglini@arm.com  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
146113481Sgiacomo.travaglini@arm.com
146213481Sgiacomo.travaglini@arm.com  FunctionMockerBase() : current_spec_(this) {}
146313481Sgiacomo.travaglini@arm.com
146413481Sgiacomo.travaglini@arm.com  // The destructor verifies that all expectations on this mock
146513481Sgiacomo.travaglini@arm.com  // function have been satisfied.  If not, it will report Google Test
146613481Sgiacomo.travaglini@arm.com  // non-fatal failures for the violations.
146713481Sgiacomo.travaglini@arm.com  virtual ~FunctionMockerBase()
146813481Sgiacomo.travaglini@arm.com        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
146913481Sgiacomo.travaglini@arm.com    MutexLock l(&g_gmock_mutex);
147013481Sgiacomo.travaglini@arm.com    VerifyAndClearExpectationsLocked();
147113481Sgiacomo.travaglini@arm.com    Mock::UnregisterLocked(this);
147213481Sgiacomo.travaglini@arm.com    ClearDefaultActionsLocked();
147313481Sgiacomo.travaglini@arm.com  }
147413481Sgiacomo.travaglini@arm.com
147513481Sgiacomo.travaglini@arm.com  // Returns the ON_CALL spec that matches this mock function with the
147613481Sgiacomo.travaglini@arm.com  // given arguments; returns NULL if no matching ON_CALL is found.
147713481Sgiacomo.travaglini@arm.com  // L = *
147813481Sgiacomo.travaglini@arm.com  const OnCallSpec<F>* FindOnCallSpec(
147913481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args) const {
148013481Sgiacomo.travaglini@arm.com    for (UntypedOnCallSpecs::const_reverse_iterator it
148113481Sgiacomo.travaglini@arm.com             = untyped_on_call_specs_.rbegin();
148213481Sgiacomo.travaglini@arm.com         it != untyped_on_call_specs_.rend(); ++it) {
148313481Sgiacomo.travaglini@arm.com      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
148413481Sgiacomo.travaglini@arm.com      if (spec->Matches(args))
148513481Sgiacomo.travaglini@arm.com        return spec;
148613481Sgiacomo.travaglini@arm.com    }
148713481Sgiacomo.travaglini@arm.com
148813481Sgiacomo.travaglini@arm.com    return NULL;
148913481Sgiacomo.travaglini@arm.com  }
149013481Sgiacomo.travaglini@arm.com
149113481Sgiacomo.travaglini@arm.com  // Performs the default action of this mock function on the given
149213481Sgiacomo.travaglini@arm.com  // arguments and returns the result. Asserts (or throws if
149313481Sgiacomo.travaglini@arm.com  // exceptions are enabled) with a helpful call descrption if there
149413481Sgiacomo.travaglini@arm.com  // is no valid return value. This method doesn't depend on the
149513481Sgiacomo.travaglini@arm.com  // mutable state of this object, and thus can be called concurrently
149613481Sgiacomo.travaglini@arm.com  // without locking.
149713481Sgiacomo.travaglini@arm.com  // L = *
149813481Sgiacomo.travaglini@arm.com  Result PerformDefaultAction(const ArgumentTuple& args,
149913481Sgiacomo.travaglini@arm.com                              const string& call_description) const {
150013481Sgiacomo.travaglini@arm.com    const OnCallSpec<F>* const spec =
150113481Sgiacomo.travaglini@arm.com        this->FindOnCallSpec(args);
150213481Sgiacomo.travaglini@arm.com    if (spec != NULL) {
150313481Sgiacomo.travaglini@arm.com      return spec->GetAction().Perform(args);
150413481Sgiacomo.travaglini@arm.com    }
150513481Sgiacomo.travaglini@arm.com    const string message = call_description +
150613481Sgiacomo.travaglini@arm.com        "\n    The mock function has no default action "
150713481Sgiacomo.travaglini@arm.com        "set, and its return type has no default value set.";
150813481Sgiacomo.travaglini@arm.com#if GTEST_HAS_EXCEPTIONS
150913481Sgiacomo.travaglini@arm.com    if (!DefaultValue<Result>::Exists()) {
151013481Sgiacomo.travaglini@arm.com      throw std::runtime_error(message);
151113481Sgiacomo.travaglini@arm.com    }
151213481Sgiacomo.travaglini@arm.com#else
151313481Sgiacomo.travaglini@arm.com    Assert(DefaultValue<Result>::Exists(), "", -1, message);
151413481Sgiacomo.travaglini@arm.com#endif
151513481Sgiacomo.travaglini@arm.com    return DefaultValue<Result>::Get();
151613481Sgiacomo.travaglini@arm.com  }
151713481Sgiacomo.travaglini@arm.com
151813481Sgiacomo.travaglini@arm.com  // Performs the default action with the given arguments and returns
151913481Sgiacomo.travaglini@arm.com  // the action's result.  The call description string will be used in
152013481Sgiacomo.travaglini@arm.com  // the error message to describe the call in the case the default
152113481Sgiacomo.travaglini@arm.com  // action fails.  The caller is responsible for deleting the result.
152213481Sgiacomo.travaglini@arm.com  // L = *
152313481Sgiacomo.travaglini@arm.com  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
152413481Sgiacomo.travaglini@arm.com      const void* untyped_args,  // must point to an ArgumentTuple
152513481Sgiacomo.travaglini@arm.com      const string& call_description) const {
152613481Sgiacomo.travaglini@arm.com    const ArgumentTuple& args =
152713481Sgiacomo.travaglini@arm.com        *static_cast<const ArgumentTuple*>(untyped_args);
152813481Sgiacomo.travaglini@arm.com    return ResultHolder::PerformDefaultAction(this, args, call_description);
152913481Sgiacomo.travaglini@arm.com  }
153013481Sgiacomo.travaglini@arm.com
153113481Sgiacomo.travaglini@arm.com  // Performs the given action with the given arguments and returns
153213481Sgiacomo.travaglini@arm.com  // the action's result.  The caller is responsible for deleting the
153313481Sgiacomo.travaglini@arm.com  // result.
153413481Sgiacomo.travaglini@arm.com  // L = *
153513481Sgiacomo.travaglini@arm.com  virtual UntypedActionResultHolderBase* UntypedPerformAction(
153613481Sgiacomo.travaglini@arm.com      const void* untyped_action, const void* untyped_args) const {
153713481Sgiacomo.travaglini@arm.com    // Make a copy of the action before performing it, in case the
153813481Sgiacomo.travaglini@arm.com    // action deletes the mock object (and thus deletes itself).
153913481Sgiacomo.travaglini@arm.com    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
154013481Sgiacomo.travaglini@arm.com    const ArgumentTuple& args =
154113481Sgiacomo.travaglini@arm.com        *static_cast<const ArgumentTuple*>(untyped_args);
154213481Sgiacomo.travaglini@arm.com    return ResultHolder::PerformAction(action, args);
154313481Sgiacomo.travaglini@arm.com  }
154413481Sgiacomo.travaglini@arm.com
154513481Sgiacomo.travaglini@arm.com  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
154613481Sgiacomo.travaglini@arm.com  // clears the ON_CALL()s set on this mock function.
154713481Sgiacomo.travaglini@arm.com  virtual void ClearDefaultActionsLocked()
154813481Sgiacomo.travaglini@arm.com      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
154913481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
155013481Sgiacomo.travaglini@arm.com
155113481Sgiacomo.travaglini@arm.com    // Deleting our default actions may trigger other mock objects to be
155213481Sgiacomo.travaglini@arm.com    // deleted, for example if an action contains a reference counted smart
155313481Sgiacomo.travaglini@arm.com    // pointer to that mock object, and that is the last reference. So if we
155413481Sgiacomo.travaglini@arm.com    // delete our actions within the context of the global mutex we may deadlock
155513481Sgiacomo.travaglini@arm.com    // when this method is called again. Instead, make a copy of the set of
155613481Sgiacomo.travaglini@arm.com    // actions to delete, clear our set within the mutex, and then delete the
155713481Sgiacomo.travaglini@arm.com    // actions outside of the mutex.
155813481Sgiacomo.travaglini@arm.com    UntypedOnCallSpecs specs_to_delete;
155913481Sgiacomo.travaglini@arm.com    untyped_on_call_specs_.swap(specs_to_delete);
156013481Sgiacomo.travaglini@arm.com
156113481Sgiacomo.travaglini@arm.com    g_gmock_mutex.Unlock();
156213481Sgiacomo.travaglini@arm.com    for (UntypedOnCallSpecs::const_iterator it =
156313481Sgiacomo.travaglini@arm.com             specs_to_delete.begin();
156413481Sgiacomo.travaglini@arm.com         it != specs_to_delete.end(); ++it) {
156513481Sgiacomo.travaglini@arm.com      delete static_cast<const OnCallSpec<F>*>(*it);
156613481Sgiacomo.travaglini@arm.com    }
156713481Sgiacomo.travaglini@arm.com
156813481Sgiacomo.travaglini@arm.com    // Lock the mutex again, since the caller expects it to be locked when we
156913481Sgiacomo.travaglini@arm.com    // return.
157013481Sgiacomo.travaglini@arm.com    g_gmock_mutex.Lock();
157113481Sgiacomo.travaglini@arm.com  }
157213481Sgiacomo.travaglini@arm.com
157313481Sgiacomo.travaglini@arm.com protected:
157413481Sgiacomo.travaglini@arm.com  template <typename Function>
157513481Sgiacomo.travaglini@arm.com  friend class MockSpec;
157613481Sgiacomo.travaglini@arm.com
157713481Sgiacomo.travaglini@arm.com  typedef ActionResultHolder<Result> ResultHolder;
157813481Sgiacomo.travaglini@arm.com
157913481Sgiacomo.travaglini@arm.com  // Returns the result of invoking this mock function with the given
158013481Sgiacomo.travaglini@arm.com  // arguments.  This function can be safely called from multiple
158113481Sgiacomo.travaglini@arm.com  // threads concurrently.
158213481Sgiacomo.travaglini@arm.com  Result InvokeWith(const ArgumentTuple& args)
158313481Sgiacomo.travaglini@arm.com        GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
158413481Sgiacomo.travaglini@arm.com    scoped_ptr<ResultHolder> holder(
158513481Sgiacomo.travaglini@arm.com        DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
158613481Sgiacomo.travaglini@arm.com    return holder->Unwrap();
158713481Sgiacomo.travaglini@arm.com  }
158813481Sgiacomo.travaglini@arm.com
158913481Sgiacomo.travaglini@arm.com  // Adds and returns a default action spec for this mock function.
159013481Sgiacomo.travaglini@arm.com  OnCallSpec<F>& AddNewOnCallSpec(
159113481Sgiacomo.travaglini@arm.com      const char* file, int line,
159213481Sgiacomo.travaglini@arm.com      const ArgumentMatcherTuple& m)
159313481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
159413481Sgiacomo.travaglini@arm.com    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
159513481Sgiacomo.travaglini@arm.com    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
159613481Sgiacomo.travaglini@arm.com    untyped_on_call_specs_.push_back(on_call_spec);
159713481Sgiacomo.travaglini@arm.com    return *on_call_spec;
159813481Sgiacomo.travaglini@arm.com  }
159913481Sgiacomo.travaglini@arm.com
160013481Sgiacomo.travaglini@arm.com  // Adds and returns an expectation spec for this mock function.
160113481Sgiacomo.travaglini@arm.com  TypedExpectation<F>& AddNewExpectation(
160213481Sgiacomo.travaglini@arm.com      const char* file,
160313481Sgiacomo.travaglini@arm.com      int line,
160413481Sgiacomo.travaglini@arm.com      const string& source_text,
160513481Sgiacomo.travaglini@arm.com      const ArgumentMatcherTuple& m)
160613481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
160713481Sgiacomo.travaglini@arm.com    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
160813481Sgiacomo.travaglini@arm.com    TypedExpectation<F>* const expectation =
160913481Sgiacomo.travaglini@arm.com        new TypedExpectation<F>(this, file, line, source_text, m);
161013481Sgiacomo.travaglini@arm.com    const linked_ptr<ExpectationBase> untyped_expectation(expectation);
161113481Sgiacomo.travaglini@arm.com    untyped_expectations_.push_back(untyped_expectation);
161213481Sgiacomo.travaglini@arm.com
161313481Sgiacomo.travaglini@arm.com    // Adds this expectation into the implicit sequence if there is one.
161413481Sgiacomo.travaglini@arm.com    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
161513481Sgiacomo.travaglini@arm.com    if (implicit_sequence != NULL) {
161613481Sgiacomo.travaglini@arm.com      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
161713481Sgiacomo.travaglini@arm.com    }
161813481Sgiacomo.travaglini@arm.com
161913481Sgiacomo.travaglini@arm.com    return *expectation;
162013481Sgiacomo.travaglini@arm.com  }
162113481Sgiacomo.travaglini@arm.com
162213481Sgiacomo.travaglini@arm.com  // The current spec (either default action spec or expectation spec)
162313481Sgiacomo.travaglini@arm.com  // being described on this function mocker.
162413481Sgiacomo.travaglini@arm.com  MockSpec<F>& current_spec() { return current_spec_; }
162513481Sgiacomo.travaglini@arm.com
162613481Sgiacomo.travaglini@arm.com private:
162713481Sgiacomo.travaglini@arm.com  template <typename Func> friend class TypedExpectation;
162813481Sgiacomo.travaglini@arm.com
162913481Sgiacomo.travaglini@arm.com  // Some utilities needed for implementing UntypedInvokeWith().
163013481Sgiacomo.travaglini@arm.com
163113481Sgiacomo.travaglini@arm.com  // Describes what default action will be performed for the given
163213481Sgiacomo.travaglini@arm.com  // arguments.
163313481Sgiacomo.travaglini@arm.com  // L = *
163413481Sgiacomo.travaglini@arm.com  void DescribeDefaultActionTo(const ArgumentTuple& args,
163513481Sgiacomo.travaglini@arm.com                               ::std::ostream* os) const {
163613481Sgiacomo.travaglini@arm.com    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
163713481Sgiacomo.travaglini@arm.com
163813481Sgiacomo.travaglini@arm.com    if (spec == NULL) {
163913481Sgiacomo.travaglini@arm.com      *os << (internal::type_equals<Result, void>::value ?
164013481Sgiacomo.travaglini@arm.com              "returning directly.\n" :
164113481Sgiacomo.travaglini@arm.com              "returning default value.\n");
164213481Sgiacomo.travaglini@arm.com    } else {
164313481Sgiacomo.travaglini@arm.com      *os << "taking default action specified at:\n"
164413481Sgiacomo.travaglini@arm.com          << FormatFileLocation(spec->file(), spec->line()) << "\n";
164513481Sgiacomo.travaglini@arm.com    }
164613481Sgiacomo.travaglini@arm.com  }
164713481Sgiacomo.travaglini@arm.com
164813481Sgiacomo.travaglini@arm.com  // Writes a message that the call is uninteresting (i.e. neither
164913481Sgiacomo.travaglini@arm.com  // explicitly expected nor explicitly unexpected) to the given
165013481Sgiacomo.travaglini@arm.com  // ostream.
165113481Sgiacomo.travaglini@arm.com  virtual void UntypedDescribeUninterestingCall(
165213481Sgiacomo.travaglini@arm.com      const void* untyped_args,
165313481Sgiacomo.travaglini@arm.com      ::std::ostream* os) const
165413481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
165513481Sgiacomo.travaglini@arm.com    const ArgumentTuple& args =
165613481Sgiacomo.travaglini@arm.com        *static_cast<const ArgumentTuple*>(untyped_args);
165713481Sgiacomo.travaglini@arm.com    *os << "Uninteresting mock function call - ";
165813481Sgiacomo.travaglini@arm.com    DescribeDefaultActionTo(args, os);
165913481Sgiacomo.travaglini@arm.com    *os << "    Function call: " << Name();
166013481Sgiacomo.travaglini@arm.com    UniversalPrint(args, os);
166113481Sgiacomo.travaglini@arm.com  }
166213481Sgiacomo.travaglini@arm.com
166313481Sgiacomo.travaglini@arm.com  // Returns the expectation that matches the given function arguments
166413481Sgiacomo.travaglini@arm.com  // (or NULL is there's no match); when a match is found,
166513481Sgiacomo.travaglini@arm.com  // untyped_action is set to point to the action that should be
166613481Sgiacomo.travaglini@arm.com  // performed (or NULL if the action is "do default"), and
166713481Sgiacomo.travaglini@arm.com  // is_excessive is modified to indicate whether the call exceeds the
166813481Sgiacomo.travaglini@arm.com  // expected number.
166913481Sgiacomo.travaglini@arm.com  //
167013481Sgiacomo.travaglini@arm.com  // Critical section: We must find the matching expectation and the
167113481Sgiacomo.travaglini@arm.com  // corresponding action that needs to be taken in an ATOMIC
167213481Sgiacomo.travaglini@arm.com  // transaction.  Otherwise another thread may call this mock
167313481Sgiacomo.travaglini@arm.com  // method in the middle and mess up the state.
167413481Sgiacomo.travaglini@arm.com  //
167513481Sgiacomo.travaglini@arm.com  // However, performing the action has to be left out of the critical
167613481Sgiacomo.travaglini@arm.com  // section.  The reason is that we have no control on what the
167713481Sgiacomo.travaglini@arm.com  // action does (it can invoke an arbitrary user function or even a
167813481Sgiacomo.travaglini@arm.com  // mock function) and excessive locking could cause a dead lock.
167913481Sgiacomo.travaglini@arm.com  virtual const ExpectationBase* UntypedFindMatchingExpectation(
168013481Sgiacomo.travaglini@arm.com      const void* untyped_args,
168113481Sgiacomo.travaglini@arm.com      const void** untyped_action, bool* is_excessive,
168213481Sgiacomo.travaglini@arm.com      ::std::ostream* what, ::std::ostream* why)
168313481Sgiacomo.travaglini@arm.com          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
168413481Sgiacomo.travaglini@arm.com    const ArgumentTuple& args =
168513481Sgiacomo.travaglini@arm.com        *static_cast<const ArgumentTuple*>(untyped_args);
168613481Sgiacomo.travaglini@arm.com    MutexLock l(&g_gmock_mutex);
168713481Sgiacomo.travaglini@arm.com    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
168813481Sgiacomo.travaglini@arm.com    if (exp == NULL) {  // A match wasn't found.
168913481Sgiacomo.travaglini@arm.com      this->FormatUnexpectedCallMessageLocked(args, what, why);
169013481Sgiacomo.travaglini@arm.com      return NULL;
169113481Sgiacomo.travaglini@arm.com    }
169213481Sgiacomo.travaglini@arm.com
169313481Sgiacomo.travaglini@arm.com    // This line must be done before calling GetActionForArguments(),
169413481Sgiacomo.travaglini@arm.com    // which will increment the call count for *exp and thus affect
169513481Sgiacomo.travaglini@arm.com    // its saturation status.
169613481Sgiacomo.travaglini@arm.com    *is_excessive = exp->IsSaturated();
169713481Sgiacomo.travaglini@arm.com    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
169813481Sgiacomo.travaglini@arm.com    if (action != NULL && action->IsDoDefault())
169913481Sgiacomo.travaglini@arm.com      action = NULL;  // Normalize "do default" to NULL.
170013481Sgiacomo.travaglini@arm.com    *untyped_action = action;
170113481Sgiacomo.travaglini@arm.com    return exp;
170213481Sgiacomo.travaglini@arm.com  }
170313481Sgiacomo.travaglini@arm.com
170413481Sgiacomo.travaglini@arm.com  // Prints the given function arguments to the ostream.
170513481Sgiacomo.travaglini@arm.com  virtual void UntypedPrintArgs(const void* untyped_args,
170613481Sgiacomo.travaglini@arm.com                                ::std::ostream* os) const {
170713481Sgiacomo.travaglini@arm.com    const ArgumentTuple& args =
170813481Sgiacomo.travaglini@arm.com        *static_cast<const ArgumentTuple*>(untyped_args);
170913481Sgiacomo.travaglini@arm.com    UniversalPrint(args, os);
171013481Sgiacomo.travaglini@arm.com  }
171113481Sgiacomo.travaglini@arm.com
171213481Sgiacomo.travaglini@arm.com  // Returns the expectation that matches the arguments, or NULL if no
171313481Sgiacomo.travaglini@arm.com  // expectation matches them.
171413481Sgiacomo.travaglini@arm.com  TypedExpectation<F>* FindMatchingExpectationLocked(
171513481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args) const
171613481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
171713481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
171813481Sgiacomo.travaglini@arm.com    for (typename UntypedExpectations::const_reverse_iterator it =
171913481Sgiacomo.travaglini@arm.com             untyped_expectations_.rbegin();
172013481Sgiacomo.travaglini@arm.com         it != untyped_expectations_.rend(); ++it) {
172113481Sgiacomo.travaglini@arm.com      TypedExpectation<F>* const exp =
172213481Sgiacomo.travaglini@arm.com          static_cast<TypedExpectation<F>*>(it->get());
172313481Sgiacomo.travaglini@arm.com      if (exp->ShouldHandleArguments(args)) {
172413481Sgiacomo.travaglini@arm.com        return exp;
172513481Sgiacomo.travaglini@arm.com      }
172613481Sgiacomo.travaglini@arm.com    }
172713481Sgiacomo.travaglini@arm.com    return NULL;
172813481Sgiacomo.travaglini@arm.com  }
172913481Sgiacomo.travaglini@arm.com
173013481Sgiacomo.travaglini@arm.com  // Returns a message that the arguments don't match any expectation.
173113481Sgiacomo.travaglini@arm.com  void FormatUnexpectedCallMessageLocked(
173213481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args,
173313481Sgiacomo.travaglini@arm.com      ::std::ostream* os,
173413481Sgiacomo.travaglini@arm.com      ::std::ostream* why) const
173513481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
173613481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
173713481Sgiacomo.travaglini@arm.com    *os << "\nUnexpected mock function call - ";
173813481Sgiacomo.travaglini@arm.com    DescribeDefaultActionTo(args, os);
173913481Sgiacomo.travaglini@arm.com    PrintTriedExpectationsLocked(args, why);
174013481Sgiacomo.travaglini@arm.com  }
174113481Sgiacomo.travaglini@arm.com
174213481Sgiacomo.travaglini@arm.com  // Prints a list of expectations that have been tried against the
174313481Sgiacomo.travaglini@arm.com  // current mock function call.
174413481Sgiacomo.travaglini@arm.com  void PrintTriedExpectationsLocked(
174513481Sgiacomo.travaglini@arm.com      const ArgumentTuple& args,
174613481Sgiacomo.travaglini@arm.com      ::std::ostream* why) const
174713481Sgiacomo.travaglini@arm.com          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
174813481Sgiacomo.travaglini@arm.com    g_gmock_mutex.AssertHeld();
174913481Sgiacomo.travaglini@arm.com    const int count = static_cast<int>(untyped_expectations_.size());
175013481Sgiacomo.travaglini@arm.com    *why << "Google Mock tried the following " << count << " "
175113481Sgiacomo.travaglini@arm.com         << (count == 1 ? "expectation, but it didn't match" :
175213481Sgiacomo.travaglini@arm.com             "expectations, but none matched")
175313481Sgiacomo.travaglini@arm.com         << ":\n";
175413481Sgiacomo.travaglini@arm.com    for (int i = 0; i < count; i++) {
175513481Sgiacomo.travaglini@arm.com      TypedExpectation<F>* const expectation =
175613481Sgiacomo.travaglini@arm.com          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
175713481Sgiacomo.travaglini@arm.com      *why << "\n";
175813481Sgiacomo.travaglini@arm.com      expectation->DescribeLocationTo(why);
175913481Sgiacomo.travaglini@arm.com      if (count > 1) {
176013481Sgiacomo.travaglini@arm.com        *why << "tried expectation #" << i << ": ";
176113481Sgiacomo.travaglini@arm.com      }
176213481Sgiacomo.travaglini@arm.com      *why << expectation->source_text() << "...\n";
176313481Sgiacomo.travaglini@arm.com      expectation->ExplainMatchResultTo(args, why);
176413481Sgiacomo.travaglini@arm.com      expectation->DescribeCallCountTo(why);
176513481Sgiacomo.travaglini@arm.com    }
176613481Sgiacomo.travaglini@arm.com  }
176713481Sgiacomo.travaglini@arm.com
176813481Sgiacomo.travaglini@arm.com  // The current spec (either default action spec or expectation spec)
176913481Sgiacomo.travaglini@arm.com  // being described on this function mocker.
177013481Sgiacomo.travaglini@arm.com  MockSpec<F> current_spec_;
177113481Sgiacomo.travaglini@arm.com
177213481Sgiacomo.travaglini@arm.com  // There is no generally useful and implementable semantics of
177313481Sgiacomo.travaglini@arm.com  // copying a mock object, so copying a mock is usually a user error.
177413481Sgiacomo.travaglini@arm.com  // Thus we disallow copying function mockers.  If the user really
177513481Sgiacomo.travaglini@arm.com  // wants to copy a mock object, he should implement his own copy
177613481Sgiacomo.travaglini@arm.com  // operation, for example:
177713481Sgiacomo.travaglini@arm.com  //
177813481Sgiacomo.travaglini@arm.com  //   class MockFoo : public Foo {
177913481Sgiacomo.travaglini@arm.com  //    public:
178013481Sgiacomo.travaglini@arm.com  //     // Defines a copy constructor explicitly.
178113481Sgiacomo.travaglini@arm.com  //     MockFoo(const MockFoo& src) {}
178213481Sgiacomo.travaglini@arm.com  //     ...
178313481Sgiacomo.travaglini@arm.com  //   };
178413481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(FunctionMockerBase);
178513481Sgiacomo.travaglini@arm.com};  // class FunctionMockerBase
178613481Sgiacomo.travaglini@arm.com
178713481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER
178813481Sgiacomo.travaglini@arm.com# pragma warning(pop)  // Restores the warning state.
178913481Sgiacomo.travaglini@arm.com#endif  // _MSV_VER
179013481Sgiacomo.travaglini@arm.com
179113481Sgiacomo.travaglini@arm.com// Implements methods of FunctionMockerBase.
179213481Sgiacomo.travaglini@arm.com
179313481Sgiacomo.travaglini@arm.com// Verifies that all expectations on this mock function have been
179413481Sgiacomo.travaglini@arm.com// satisfied.  Reports one or more Google Test non-fatal failures and
179513481Sgiacomo.travaglini@arm.com// returns false if not.
179613481Sgiacomo.travaglini@arm.com
179713481Sgiacomo.travaglini@arm.com// Reports an uninteresting call (whose description is in msg) in the
179813481Sgiacomo.travaglini@arm.com// manner specified by 'reaction'.
179913481Sgiacomo.travaglini@arm.comvoid ReportUninterestingCall(CallReaction reaction, const string& msg);
180013481Sgiacomo.travaglini@arm.com
180113481Sgiacomo.travaglini@arm.com}  // namespace internal
180213481Sgiacomo.travaglini@arm.com
180313481Sgiacomo.travaglini@arm.com// The style guide prohibits "using" statements in a namespace scope
180413481Sgiacomo.travaglini@arm.com// inside a header file.  However, the MockSpec class template is
180513481Sgiacomo.travaglini@arm.com// meant to be defined in the ::testing namespace.  The following line
180613481Sgiacomo.travaglini@arm.com// is just a trick for working around a bug in MSVC 8.0, which cannot
180713481Sgiacomo.travaglini@arm.com// handle it if we define MockSpec in ::testing.
180813481Sgiacomo.travaglini@arm.comusing internal::MockSpec;
180913481Sgiacomo.travaglini@arm.com
181013481Sgiacomo.travaglini@arm.com// Const(x) is a convenient function for obtaining a const reference
181113481Sgiacomo.travaglini@arm.com// to x.  This is useful for setting expectations on an overloaded
181213481Sgiacomo.travaglini@arm.com// const mock method, e.g.
181313481Sgiacomo.travaglini@arm.com//
181413481Sgiacomo.travaglini@arm.com//   class MockFoo : public FooInterface {
181513481Sgiacomo.travaglini@arm.com//    public:
181613481Sgiacomo.travaglini@arm.com//     MOCK_METHOD0(Bar, int());
181713481Sgiacomo.travaglini@arm.com//     MOCK_CONST_METHOD0(Bar, int&());
181813481Sgiacomo.travaglini@arm.com//   };
181913481Sgiacomo.travaglini@arm.com//
182013481Sgiacomo.travaglini@arm.com//   MockFoo foo;
182113481Sgiacomo.travaglini@arm.com//   // Expects a call to non-const MockFoo::Bar().
182213481Sgiacomo.travaglini@arm.com//   EXPECT_CALL(foo, Bar());
182313481Sgiacomo.travaglini@arm.com//   // Expects a call to const MockFoo::Bar().
182413481Sgiacomo.travaglini@arm.com//   EXPECT_CALL(Const(foo), Bar());
182513481Sgiacomo.travaglini@arm.comtemplate <typename T>
182613481Sgiacomo.travaglini@arm.cominline const T& Const(const T& x) { return x; }
182713481Sgiacomo.travaglini@arm.com
182813481Sgiacomo.travaglini@arm.com// Constructs an Expectation object that references and co-owns exp.
182913481Sgiacomo.travaglini@arm.cominline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
183013481Sgiacomo.travaglini@arm.com    : expectation_base_(exp.GetHandle().expectation_base()) {}
183113481Sgiacomo.travaglini@arm.com
183213481Sgiacomo.travaglini@arm.com}  // namespace testing
183313481Sgiacomo.travaglini@arm.com
183413481Sgiacomo.travaglini@arm.com// A separate macro is required to avoid compile errors when the name
183513481Sgiacomo.travaglini@arm.com// of the method used in call is a result of macro expansion.
183613481Sgiacomo.travaglini@arm.com// See CompilesWithMethodNameExpandedFromMacro tests in
183713481Sgiacomo.travaglini@arm.com// internal/gmock-spec-builders_test.cc for more details.
183813481Sgiacomo.travaglini@arm.com#define GMOCK_ON_CALL_IMPL_(obj, call) \
183913481Sgiacomo.travaglini@arm.com    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
184013481Sgiacomo.travaglini@arm.com                                                    #obj, #call)
184113481Sgiacomo.travaglini@arm.com#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)
184213481Sgiacomo.travaglini@arm.com
184313481Sgiacomo.travaglini@arm.com#define GMOCK_EXPECT_CALL_IMPL_(obj, call) \
184413481Sgiacomo.travaglini@arm.com    ((obj).gmock_##call).InternalExpectedAt(__FILE__, __LINE__, #obj, #call)
184513481Sgiacomo.travaglini@arm.com#define EXPECT_CALL(obj, call) GMOCK_EXPECT_CALL_IMPL_(obj, call)
184613481Sgiacomo.travaglini@arm.com
184713481Sgiacomo.travaglini@arm.com#endif  // GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
1848