Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F69715648
gmock-spec-builders.h
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Wed, Jul 3, 03:40
Size
71 KB
Mime Type
text/x-c++
Expires
Fri, Jul 5, 03:40 (2 d)
Engine
blob
Format
Raw Data
Handle
18746529
Attached To
R9484 sp4e-homework-lars-bertil
gmock-spec-builders.h
View Options
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Google Mock - a framework for writing C++ mock classes.
//
// This file implements the ON_CALL() and EXPECT_CALL() macros.
//
// A user can use the ON_CALL() macro to specify the default action of
// a mock method. The syntax is:
//
// ON_CALL(mock_object, Method(argument-matchers))
// .With(multi-argument-matcher)
// .WillByDefault(action);
//
// where the .With() clause is optional.
//
// A user can use the EXPECT_CALL() macro to specify an expectation on
// a mock method. The syntax is:
//
// EXPECT_CALL(mock_object, Method(argument-matchers))
// .With(multi-argument-matchers)
// .Times(cardinality)
// .InSequence(sequences)
// .After(expectations)
// .WillOnce(action)
// .WillRepeatedly(action)
// .RetiresOnSaturation();
//
// where all clauses are optional, and .InSequence()/.After()/
// .WillOnce() can appear any number of times.
// GOOGLETEST_CM0002 DO NOT DELETE
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "gmock/gmock-actions.h"
#include "gmock/gmock-cardinalities.h"
#include "gmock/gmock-matchers.h"
#include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h"
#if GTEST_HAS_EXCEPTIONS
# include <stdexcept>
// NOLINT
#endif
GTEST_DISABLE_MSC_WARNINGS_PUSH_
(
4251
\
/* class A needs to have dll-interface to be used by clients of class B */
)
namespace
testing
{
// An abstract handle of an expectation.
class
Expectation
;
// A set of expectation handles.
class
ExpectationSet
;
// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
// and MUST NOT BE USED IN USER CODE!!!
namespace
internal
{
// Implements a mock function.
template
<
typename
F
>
class
FunctionMocker
;
// Base class for expectations.
class
ExpectationBase
;
// Implements an expectation.
template
<
typename
F
>
class
TypedExpectation
;
// Helper class for testing the Expectation class template.
class
ExpectationTester
;
// Base class for function mockers.
template
<
typename
F
>
class
FunctionMockerBase
;
// Protects the mock object registry (in class Mock), all function
// mockers, and all expectations.
//
// The reason we don't use more fine-grained protection is: when a
// mock function Foo() is called, it needs to consult its expectations
// to see which one should be picked. If another thread is allowed to
// call a mock function (either Foo() or a different one) at the same
// time, it could affect the "retired" attributes of Foo()'s
// expectations when InSequence() is used, and thus affect which
// expectation gets picked. Therefore, we sequence all mock function
// calls to ensure the integrity of the mock objects' states.
GTEST_API_
GTEST_DECLARE_STATIC_MUTEX_
(
g_gmock_mutex
);
// Untyped base class for ActionResultHolder<R>.
class
UntypedActionResultHolderBase
;
// Abstract base class of FunctionMockerBase. This is the
// type-agnostic part of the function mocker interface. Its pure
// virtual methods are implemented by FunctionMockerBase.
class
GTEST_API_
UntypedFunctionMockerBase
{
public:
UntypedFunctionMockerBase
();
virtual
~
UntypedFunctionMockerBase
();
// Verifies that all expectations on this mock function have been
// satisfied. Reports one or more Google Test non-fatal failures
// and returns false if not.
bool
VerifyAndClearExpectationsLocked
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
);
// Clears the ON_CALL()s set on this mock function.
virtual
void
ClearDefaultActionsLocked
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
=
0
;
// In all of the following Untyped* functions, it's the caller's
// responsibility to guarantee the correctness of the arguments'
// types.
// Performs the default action with the given arguments and returns
// the action's result. The call description string will be used in
// the error message to describe the call in the case the default
// action fails.
// L = *
virtual
UntypedActionResultHolderBase
*
UntypedPerformDefaultAction
(
void
*
untyped_args
,
const
std
::
string
&
call_description
)
const
=
0
;
// Performs the given action with the given arguments and returns
// the action's result.
// L = *
virtual
UntypedActionResultHolderBase
*
UntypedPerformAction
(
const
void
*
untyped_action
,
void
*
untyped_args
)
const
=
0
;
// Writes a message that the call is uninteresting (i.e. neither
// explicitly expected nor explicitly unexpected) to the given
// ostream.
virtual
void
UntypedDescribeUninterestingCall
(
const
void
*
untyped_args
,
::
std
::
ostream
*
os
)
const
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
=
0
;
// Returns the expectation that matches the given function arguments
// (or NULL is there's no match); when a match is found,
// untyped_action is set to point to the action that should be
// performed (or NULL if the action is "do default"), and
// is_excessive is modified to indicate whether the call exceeds the
// expected number.
virtual
const
ExpectationBase
*
UntypedFindMatchingExpectation
(
const
void
*
untyped_args
,
const
void
**
untyped_action
,
bool
*
is_excessive
,
::
std
::
ostream
*
what
,
::
std
::
ostream
*
why
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
=
0
;
// Prints the given function arguments to the ostream.
virtual
void
UntypedPrintArgs
(
const
void
*
untyped_args
,
::
std
::
ostream
*
os
)
const
=
0
;
// Sets the mock object this mock method belongs to, and registers
// this information in the global mock registry. Will be called
// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
// method.
// FIXME: rename to SetAndRegisterOwner().
void
RegisterOwner
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
);
// Sets the mock object this mock method belongs to, and sets the
// name of the mock function. Will be called upon each invocation
// of this mock function.
void
SetOwnerAndName
(
const
void
*
mock_obj
,
const
char
*
name
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
);
// Returns the mock object this mock method belongs to. Must be
// called after RegisterOwner() or SetOwnerAndName() has been
// called.
const
void
*
MockObject
()
const
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
);
// Returns the name of this mock method. Must be called after
// SetOwnerAndName() has been called.
const
char
*
Name
()
const
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
);
// Returns the result of invoking this mock function with the given
// arguments. This function can be safely called from multiple
// threads concurrently. The caller is responsible for deleting the
// result.
UntypedActionResultHolderBase
*
UntypedInvokeWith
(
void
*
untyped_args
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
);
protected:
typedef
std
::
vector
<
const
void
*>
UntypedOnCallSpecs
;
typedef
std
::
vector
<
internal
::
linked_ptr
<
ExpectationBase
>
>
UntypedExpectations
;
// Returns an Expectation object that references and co-owns exp,
// which must be an expectation on this mock function.
Expectation
GetHandleOf
(
ExpectationBase
*
exp
);
// Address of the mock object this mock method belongs to. Only
// valid after this mock method has been called or
// ON_CALL/EXPECT_CALL has been invoked on it.
const
void
*
mock_obj_
;
// Protected by g_gmock_mutex.
// Name of the function being mocked. Only valid after this mock
// method has been called.
const
char
*
name_
;
// Protected by g_gmock_mutex.
// All default action specs for this function mocker.
UntypedOnCallSpecs
untyped_on_call_specs_
;
// All expectations for this function mocker.
//
// It's undefined behavior to interleave expectations (EXPECT_CALLs
// or ON_CALLs) and mock function calls. Also, the order of
// expectations is important. Therefore it's a logic race condition
// to read/write untyped_expectations_ concurrently. In order for
// tools like tsan to catch concurrent read/write accesses to
// untyped_expectations, we deliberately leave accesses to it
// unprotected.
UntypedExpectations
untyped_expectations_
;
};
// class UntypedFunctionMockerBase
// Untyped base class for OnCallSpec<F>.
class
UntypedOnCallSpecBase
{
public:
// The arguments are the location of the ON_CALL() statement.
UntypedOnCallSpecBase
(
const
char
*
a_file
,
int
a_line
)
:
file_
(
a_file
),
line_
(
a_line
),
last_clause_
(
kNone
)
{}
// Where in the source file was the default action spec defined?
const
char
*
file
()
const
{
return
file_
;
}
int
line
()
const
{
return
line_
;
}
protected:
// Gives each clause in the ON_CALL() statement a name.
enum
Clause
{
// Do not change the order of the enum members! The run-time
// syntax checking relies on it.
kNone
,
kWith
,
kWillByDefault
};
// Asserts that the ON_CALL() statement has a certain property.
void
AssertSpecProperty
(
bool
property
,
const
std
::
string
&
failure_message
)
const
{
Assert
(
property
,
file_
,
line_
,
failure_message
);
}
// Expects that the ON_CALL() statement has a certain property.
void
ExpectSpecProperty
(
bool
property
,
const
std
::
string
&
failure_message
)
const
{
Expect
(
property
,
file_
,
line_
,
failure_message
);
}
const
char
*
file_
;
int
line_
;
// The last clause in the ON_CALL() statement as seen so far.
// Initially kNone and changes as the statement is parsed.
Clause
last_clause_
;
};
// class UntypedOnCallSpecBase
// This template class implements an ON_CALL spec.
template
<
typename
F
>
class
OnCallSpec
:
public
UntypedOnCallSpecBase
{
public:
typedef
typename
Function
<
F
>::
ArgumentTuple
ArgumentTuple
;
typedef
typename
Function
<
F
>::
ArgumentMatcherTuple
ArgumentMatcherTuple
;
// Constructs an OnCallSpec object from the information inside
// the parenthesis of an ON_CALL() statement.
OnCallSpec
(
const
char
*
a_file
,
int
a_line
,
const
ArgumentMatcherTuple
&
matchers
)
:
UntypedOnCallSpecBase
(
a_file
,
a_line
),
matchers_
(
matchers
),
// By default, extra_matcher_ should match anything. However,
// we cannot initialize it with _ as that triggers a compiler
// bug in Symbian's C++ compiler (cannot decide between two
// overloaded constructors of Matcher<const ArgumentTuple&>).
extra_matcher_
(
A
<
const
ArgumentTuple
&>
())
{
}
// Implements the .With() clause.
OnCallSpec
&
With
(
const
Matcher
<
const
ArgumentTuple
&>&
m
)
{
// Makes sure this is called at most once.
ExpectSpecProperty
(
last_clause_
<
kWith
,
".With() cannot appear "
"more than once in an ON_CALL()."
);
last_clause_
=
kWith
;
extra_matcher_
=
m
;
return
*
this
;
}
// Implements the .WillByDefault() clause.
OnCallSpec
&
WillByDefault
(
const
Action
<
F
>&
action
)
{
ExpectSpecProperty
(
last_clause_
<
kWillByDefault
,
".WillByDefault() must appear "
"exactly once in an ON_CALL()."
);
last_clause_
=
kWillByDefault
;
ExpectSpecProperty
(
!
action
.
IsDoDefault
(),
"DoDefault() cannot be used in ON_CALL()."
);
action_
=
action
;
return
*
this
;
}
// Returns true iff the given arguments match the matchers.
bool
Matches
(
const
ArgumentTuple
&
args
)
const
{
return
TupleMatches
(
matchers_
,
args
)
&&
extra_matcher_
.
Matches
(
args
);
}
// Returns the action specified by the user.
const
Action
<
F
>&
GetAction
()
const
{
AssertSpecProperty
(
last_clause_
==
kWillByDefault
,
".WillByDefault() must appear exactly "
"once in an ON_CALL()."
);
return
action_
;
}
private:
// The information in statement
//
// ON_CALL(mock_object, Method(matchers))
// .With(multi-argument-matcher)
// .WillByDefault(action);
//
// is recorded in the data members like this:
//
// source file that contains the statement => file_
// line number of the statement => line_
// matchers => matchers_
// multi-argument-matcher => extra_matcher_
// action => action_
ArgumentMatcherTuple
matchers_
;
Matcher
<
const
ArgumentTuple
&>
extra_matcher_
;
Action
<
F
>
action_
;
};
// class OnCallSpec
// Possible reactions on uninteresting calls.
enum
CallReaction
{
kAllow
,
kWarn
,
kFail
,
};
}
// namespace internal
// Utilities for manipulating mock objects.
class
GTEST_API_
Mock
{
public:
// The following public methods can be called concurrently.
// Tells Google Mock to ignore mock_obj when checking for leaked
// mock objects.
static
void
AllowLeak
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Verifies and clears all expectations on the given mock object.
// If the expectations aren't satisfied, generates one or more
// Google Test non-fatal failures and returns false.
static
bool
VerifyAndClearExpectations
(
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Verifies all expectations on the given mock object and clears its
// default actions and expectations. Returns true iff the
// verification was successful.
static
bool
VerifyAndClear
(
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Returns whether the mock was created as a naggy mock (default)
static
bool
IsNaggy
(
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Returns whether the mock was created as a nice mock
static
bool
IsNice
(
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Returns whether the mock was created as a strict mock
static
bool
IsStrict
(
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
private:
friend
class
internal
::
UntypedFunctionMockerBase
;
// Needed for a function mocker to register itself (so that we know
// how to clear a mock object).
template
<
typename
F
>
friend
class
internal
::
FunctionMockerBase
;
template
<
typename
M
>
friend
class
NiceMock
;
template
<
typename
M
>
friend
class
NaggyMock
;
template
<
typename
M
>
friend
class
StrictMock
;
// Tells Google Mock to allow uninteresting calls on the given mock
// object.
static
void
AllowUninterestingCalls
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Tells Google Mock to warn the user about uninteresting calls on
// the given mock object.
static
void
WarnUninterestingCalls
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Tells Google Mock to fail uninteresting calls on the given mock
// object.
static
void
FailUninterestingCalls
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Tells Google Mock the given mock object is being destroyed and
// its entry in the call-reaction table should be removed.
static
void
UnregisterCallReaction
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Returns the reaction Google Mock will have on uninteresting calls
// made on the given mock object.
static
internal
::
CallReaction
GetReactionOnUninterestingCalls
(
const
void
*
mock_obj
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Verifies that all expectations on the given mock object have been
// satisfied. Reports one or more Google Test non-fatal failures
// and returns false if not.
static
bool
VerifyAndClearExpectationsLocked
(
void
*
mock_obj
)
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
internal
::
g_gmock_mutex
);
// Clears all ON_CALL()s set on the given mock object.
static
void
ClearDefaultActionsLocked
(
void
*
mock_obj
)
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
internal
::
g_gmock_mutex
);
// Registers a mock object and a mock method it owns.
static
void
Register
(
const
void
*
mock_obj
,
internal
::
UntypedFunctionMockerBase
*
mocker
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Tells Google Mock where in the source code mock_obj is used in an
// ON_CALL or EXPECT_CALL. In case mock_obj is leaked, this
// information helps the user identify which object it is.
static
void
RegisterUseByOnCallOrExpectCall
(
const
void
*
mock_obj
,
const
char
*
file
,
int
line
)
GTEST_LOCK_EXCLUDED_
(
internal
::
g_gmock_mutex
);
// Unregisters a mock method; removes the owning mock object from
// the registry when the last mock method associated with it has
// been unregistered. This is called only in the destructor of
// FunctionMockerBase.
static
void
UnregisterLocked
(
internal
::
UntypedFunctionMockerBase
*
mocker
)
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
internal
::
g_gmock_mutex
);
};
// class Mock
// An abstract handle of an expectation. Useful in the .After()
// clause of EXPECT_CALL() for setting the (partial) order of
// expectations. The syntax:
//
// Expectation e1 = EXPECT_CALL(...)...;
// EXPECT_CALL(...).After(e1)...;
//
// sets two expectations where the latter can only be matched after
// the former has been satisfied.
//
// Notes:
// - This class is copyable and has value semantics.
// - Constness is shallow: a const Expectation object itself cannot
// be modified, but the mutable methods of the ExpectationBase
// object it references can be called via expectation_base().
// - The constructors and destructor are defined out-of-line because
// the Symbian WINSCW compiler wants to otherwise instantiate them
// when it sees this class definition, at which point it doesn't have
// ExpectationBase available yet, leading to incorrect destruction
// in the linked_ptr (or compilation errors if using a checking
// linked_ptr).
class
GTEST_API_
Expectation
{
public:
// Constructs a null object that doesn't reference any expectation.
Expectation
();
~
Expectation
();
// This single-argument ctor must not be explicit, in order to support the
// Expectation e = EXPECT_CALL(...);
// syntax.
//
// A TypedExpectation object stores its pre-requisites as
// Expectation objects, and needs to call the non-const Retire()
// method on the ExpectationBase objects they reference. Therefore
// Expectation must receive a *non-const* reference to the
// ExpectationBase object.
Expectation
(
internal
::
ExpectationBase
&
exp
);
// NOLINT
// The compiler-generated copy ctor and operator= work exactly as
// intended, so we don't need to define our own.
// Returns true iff rhs references the same expectation as this object does.
bool
operator
==
(
const
Expectation
&
rhs
)
const
{
return
expectation_base_
==
rhs
.
expectation_base_
;
}
bool
operator
!=
(
const
Expectation
&
rhs
)
const
{
return
!
(
*
this
==
rhs
);
}
private:
friend
class
ExpectationSet
;
friend
class
Sequence
;
friend
class
::
testing
::
internal
::
ExpectationBase
;
friend
class
::
testing
::
internal
::
UntypedFunctionMockerBase
;
template
<
typename
F
>
friend
class
::
testing
::
internal
::
FunctionMockerBase
;
template
<
typename
F
>
friend
class
::
testing
::
internal
::
TypedExpectation
;
// This comparator is needed for putting Expectation objects into a set.
class
Less
{
public:
bool
operator
()(
const
Expectation
&
lhs
,
const
Expectation
&
rhs
)
const
{
return
lhs
.
expectation_base_
.
get
()
<
rhs
.
expectation_base_
.
get
();
}
};
typedef
::
std
::
set
<
Expectation
,
Less
>
Set
;
Expectation
(
const
internal
::
linked_ptr
<
internal
::
ExpectationBase
>&
expectation_base
);
// Returns the expectation this object references.
const
internal
::
linked_ptr
<
internal
::
ExpectationBase
>&
expectation_base
()
const
{
return
expectation_base_
;
}
// A linked_ptr that co-owns the expectation this handle references.
internal
::
linked_ptr
<
internal
::
ExpectationBase
>
expectation_base_
;
};
// A set of expectation handles. Useful in the .After() clause of
// EXPECT_CALL() for setting the (partial) order of expectations. The
// syntax:
//
// ExpectationSet es;
// es += EXPECT_CALL(...)...;
// es += EXPECT_CALL(...)...;
// EXPECT_CALL(...).After(es)...;
//
// sets three expectations where the last one can only be matched
// after the first two have both been satisfied.
//
// This class is copyable and has value semantics.
class
ExpectationSet
{
public:
// A bidirectional iterator that can read a const element in the set.
typedef
Expectation
::
Set
::
const_iterator
const_iterator
;
// An object stored in the set. This is an alias of Expectation.
typedef
Expectation
::
Set
::
value_type
value_type
;
// Constructs an empty set.
ExpectationSet
()
{}
// This single-argument ctor must not be explicit, in order to support the
// ExpectationSet es = EXPECT_CALL(...);
// syntax.
ExpectationSet
(
internal
::
ExpectationBase
&
exp
)
{
// NOLINT
*
this
+=
Expectation
(
exp
);
}
// This single-argument ctor implements implicit conversion from
// Expectation and thus must not be explicit. This allows either an
// Expectation or an ExpectationSet to be used in .After().
ExpectationSet
(
const
Expectation
&
e
)
{
// NOLINT
*
this
+=
e
;
}
// The compiler-generator ctor and operator= works exactly as
// intended, so we don't need to define our own.
// Returns true iff rhs contains the same set of Expectation objects
// as this does.
bool
operator
==
(
const
ExpectationSet
&
rhs
)
const
{
return
expectations_
==
rhs
.
expectations_
;
}
bool
operator
!=
(
const
ExpectationSet
&
rhs
)
const
{
return
!
(
*
this
==
rhs
);
}
// Implements the syntax
// expectation_set += EXPECT_CALL(...);
ExpectationSet
&
operator
+=
(
const
Expectation
&
e
)
{
expectations_
.
insert
(
e
);
return
*
this
;
}
int
size
()
const
{
return
static_cast
<
int
>
(
expectations_
.
size
());
}
const_iterator
begin
()
const
{
return
expectations_
.
begin
();
}
const_iterator
end
()
const
{
return
expectations_
.
end
();
}
private:
Expectation
::
Set
expectations_
;
};
// Sequence objects are used by a user to specify the relative order
// in which the expectations should match. They are copyable (we rely
// on the compiler-defined copy constructor and assignment operator).
class
GTEST_API_
Sequence
{
public:
// Constructs an empty sequence.
Sequence
()
:
last_expectation_
(
new
Expectation
)
{}
// Adds an expectation to this sequence. The caller must ensure
// that no other thread is accessing this Sequence object.
void
AddExpectation
(
const
Expectation
&
expectation
)
const
;
private:
// The last expectation in this sequence. We use a linked_ptr here
// because Sequence objects are copyable and we want the copies to
// be aliases. The linked_ptr allows the copies to co-own and share
// the same Expectation object.
internal
::
linked_ptr
<
Expectation
>
last_expectation_
;
};
// class Sequence
// An object of this type causes all EXPECT_CALL() statements
// encountered in its scope to be put in an anonymous sequence. The
// work is done in the constructor and destructor. You should only
// create an InSequence object on the stack.
//
// The sole purpose for this class is to support easy definition of
// sequential expectations, e.g.
//
// {
// InSequence dummy; // The name of the object doesn't matter.
//
// // The following expectations must match in the order they appear.
// EXPECT_CALL(a, Bar())...;
// EXPECT_CALL(a, Baz())...;
// ...
// EXPECT_CALL(b, Xyz())...;
// }
//
// You can create InSequence objects in multiple threads, as long as
// they are used to affect different mock objects. The idea is that
// each thread can create and set up its own mocks as if it's the only
// thread. However, for clarity of your tests we recommend you to set
// up mocks in the main thread unless you have a good reason not to do
// so.
class
GTEST_API_
InSequence
{
public:
InSequence
();
~
InSequence
();
private:
bool
sequence_created_
;
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
InSequence
);
// NOLINT
}
GTEST_ATTRIBUTE_UNUSED_
;
namespace
internal
{
// Points to the implicit sequence introduced by a living InSequence
// object (if any) in the current thread or NULL.
GTEST_API_
extern
ThreadLocal
<
Sequence
*>
g_gmock_implicit_sequence
;
// Base class for implementing expectations.
//
// There are two reasons for having a type-agnostic base class for
// Expectation:
//
// 1. We need to store collections of expectations of different
// types (e.g. all pre-requisites of a particular expectation, all
// expectations in a sequence). Therefore these expectation objects
// must share a common base class.
//
// 2. We can avoid binary code bloat by moving methods not depending
// on the template argument of Expectation to the base class.
//
// This class is internal and mustn't be used by user code directly.
class
GTEST_API_
ExpectationBase
{
public:
// source_text is the EXPECT_CALL(...) source that created this Expectation.
ExpectationBase
(
const
char
*
file
,
int
line
,
const
std
::
string
&
source_text
);
virtual
~
ExpectationBase
();
// Where in the source file was the expectation spec defined?
const
char
*
file
()
const
{
return
file_
;
}
int
line
()
const
{
return
line_
;
}
const
char
*
source_text
()
const
{
return
source_text_
.
c_str
();
}
// Returns the cardinality specified in the expectation spec.
const
Cardinality
&
cardinality
()
const
{
return
cardinality_
;
}
// Describes the source file location of this expectation.
void
DescribeLocationTo
(
::
std
::
ostream
*
os
)
const
{
*
os
<<
FormatFileLocation
(
file
(),
line
())
<<
" "
;
}
// Describes how many times a function call matching this
// expectation has occurred.
void
DescribeCallCountTo
(
::
std
::
ostream
*
os
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
);
// If this mock method has an extra matcher (i.e. .With(matcher)),
// describes it to the ostream.
virtual
void
MaybeDescribeExtraMatcherTo
(
::
std
::
ostream
*
os
)
=
0
;
protected:
friend
class
::
testing
::
Expectation
;
friend
class
UntypedFunctionMockerBase
;
enum
Clause
{
// Don't change the order of the enum members!
kNone
,
kWith
,
kTimes
,
kInSequence
,
kAfter
,
kWillOnce
,
kWillRepeatedly
,
kRetiresOnSaturation
};
typedef
std
::
vector
<
const
void
*>
UntypedActions
;
// Returns an Expectation object that references and co-owns this
// expectation.
virtual
Expectation
GetHandle
()
=
0
;
// Asserts that the EXPECT_CALL() statement has the given property.
void
AssertSpecProperty
(
bool
property
,
const
std
::
string
&
failure_message
)
const
{
Assert
(
property
,
file_
,
line_
,
failure_message
);
}
// Expects that the EXPECT_CALL() statement has the given property.
void
ExpectSpecProperty
(
bool
property
,
const
std
::
string
&
failure_message
)
const
{
Expect
(
property
,
file_
,
line_
,
failure_message
);
}
// Explicitly specifies the cardinality of this expectation. Used
// by the subclasses to implement the .Times() clause.
void
SpecifyCardinality
(
const
Cardinality
&
cardinality
);
// Returns true iff the user specified the cardinality explicitly
// using a .Times().
bool
cardinality_specified
()
const
{
return
cardinality_specified_
;
}
// Sets the cardinality of this expectation spec.
void
set_cardinality
(
const
Cardinality
&
a_cardinality
)
{
cardinality_
=
a_cardinality
;
}
// The following group of methods should only be called after the
// EXPECT_CALL() statement, and only when g_gmock_mutex is held by
// the current thread.
// Retires all pre-requisites of this expectation.
void
RetireAllPreRequisites
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
);
// Returns true iff this expectation is retired.
bool
is_retired
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
retired_
;
}
// Retires this expectation.
void
Retire
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
retired_
=
true
;
}
// Returns true iff this expectation is satisfied.
bool
IsSatisfied
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
cardinality
().
IsSatisfiedByCallCount
(
call_count_
);
}
// Returns true iff this expectation is saturated.
bool
IsSaturated
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
cardinality
().
IsSaturatedByCallCount
(
call_count_
);
}
// Returns true iff this expectation is over-saturated.
bool
IsOverSaturated
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
cardinality
().
IsOverSaturatedByCallCount
(
call_count_
);
}
// Returns true iff all pre-requisites of this expectation are satisfied.
bool
AllPrerequisitesAreSatisfied
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
);
// Adds unsatisfied pre-requisites of this expectation to 'result'.
void
FindUnsatisfiedPrerequisites
(
ExpectationSet
*
result
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
);
// Returns the number this expectation has been invoked.
int
call_count
()
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
call_count_
;
}
// Increments the number this expectation has been invoked.
void
IncrementCallCount
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
call_count_
++
;
}
// Checks the action count (i.e. the number of WillOnce() and
// WillRepeatedly() clauses) against the cardinality if this hasn't
// been done before. Prints a warning if there are too many or too
// few actions.
void
CheckActionCountIfNotDone
()
const
GTEST_LOCK_EXCLUDED_
(
mutex_
);
friend
class
::
testing
::
Sequence
;
friend
class
::
testing
::
internal
::
ExpectationTester
;
template
<
typename
Function
>
friend
class
TypedExpectation
;
// Implements the .Times() clause.
void
UntypedTimes
(
const
Cardinality
&
a_cardinality
);
// This group of fields are part of the spec and won't change after
// an EXPECT_CALL() statement finishes.
const
char
*
file_
;
// The file that contains the expectation.
int
line_
;
// The line number of the expectation.
const
std
::
string
source_text_
;
// The EXPECT_CALL(...) source text.
// True iff the cardinality is specified explicitly.
bool
cardinality_specified_
;
Cardinality
cardinality_
;
// The cardinality of the expectation.
// The immediate pre-requisites (i.e. expectations that must be
// satisfied before this expectation can be matched) of this
// expectation. We use linked_ptr in the set because we want an
// Expectation object to be co-owned by its FunctionMocker and its
// successors. This allows multiple mock objects to be deleted at
// different times.
ExpectationSet
immediate_prerequisites_
;
// This group of fields are the current state of the expectation,
// and can change as the mock function is called.
int
call_count_
;
// How many times this expectation has been invoked.
bool
retired_
;
// True iff this expectation has retired.
UntypedActions
untyped_actions_
;
bool
extra_matcher_specified_
;
bool
repeated_action_specified_
;
// True if a WillRepeatedly() was specified.
bool
retires_on_saturation_
;
Clause
last_clause_
;
mutable
bool
action_count_checked_
;
// Under mutex_.
mutable
Mutex
mutex_
;
// Protects action_count_checked_.
GTEST_DISALLOW_ASSIGN_
(
ExpectationBase
);
};
// class ExpectationBase
// Impements an expectation for the given function type.
template
<
typename
F
>
class
TypedExpectation
:
public
ExpectationBase
{
public:
typedef
typename
Function
<
F
>::
ArgumentTuple
ArgumentTuple
;
typedef
typename
Function
<
F
>::
ArgumentMatcherTuple
ArgumentMatcherTuple
;
typedef
typename
Function
<
F
>::
Result
Result
;
TypedExpectation
(
FunctionMockerBase
<
F
>*
owner
,
const
char
*
a_file
,
int
a_line
,
const
std
::
string
&
a_source_text
,
const
ArgumentMatcherTuple
&
m
)
:
ExpectationBase
(
a_file
,
a_line
,
a_source_text
),
owner_
(
owner
),
matchers_
(
m
),
// By default, extra_matcher_ should match anything. However,
// we cannot initialize it with _ as that triggers a compiler
// bug in Symbian's C++ compiler (cannot decide between two
// overloaded constructors of Matcher<const ArgumentTuple&>).
extra_matcher_
(
A
<
const
ArgumentTuple
&>
()),
repeated_action_
(
DoDefault
())
{}
virtual
~
TypedExpectation
()
{
// Check the validity of the action count if it hasn't been done
// yet (for example, if the expectation was never used).
CheckActionCountIfNotDone
();
for
(
UntypedActions
::
const_iterator
it
=
untyped_actions_
.
begin
();
it
!=
untyped_actions_
.
end
();
++
it
)
{
delete
static_cast
<
const
Action
<
F
>*>
(
*
it
);
}
}
// Implements the .With() clause.
TypedExpectation
&
With
(
const
Matcher
<
const
ArgumentTuple
&>&
m
)
{
if
(
last_clause_
==
kWith
)
{
ExpectSpecProperty
(
false
,
".With() cannot appear "
"more than once in an EXPECT_CALL()."
);
}
else
{
ExpectSpecProperty
(
last_clause_
<
kWith
,
".With() must be the first "
"clause in an EXPECT_CALL()."
);
}
last_clause_
=
kWith
;
extra_matcher_
=
m
;
extra_matcher_specified_
=
true
;
return
*
this
;
}
// Implements the .Times() clause.
TypedExpectation
&
Times
(
const
Cardinality
&
a_cardinality
)
{
ExpectationBase
::
UntypedTimes
(
a_cardinality
);
return
*
this
;
}
// Implements the .Times() clause.
TypedExpectation
&
Times
(
int
n
)
{
return
Times
(
Exactly
(
n
));
}
// Implements the .InSequence() clause.
TypedExpectation
&
InSequence
(
const
Sequence
&
s
)
{
ExpectSpecProperty
(
last_clause_
<=
kInSequence
,
".InSequence() cannot appear after .After(),"
" .WillOnce(), .WillRepeatedly(), or "
".RetiresOnSaturation()."
);
last_clause_
=
kInSequence
;
s
.
AddExpectation
(
GetHandle
());
return
*
this
;
}
TypedExpectation
&
InSequence
(
const
Sequence
&
s1
,
const
Sequence
&
s2
)
{
return
InSequence
(
s1
).
InSequence
(
s2
);
}
TypedExpectation
&
InSequence
(
const
Sequence
&
s1
,
const
Sequence
&
s2
,
const
Sequence
&
s3
)
{
return
InSequence
(
s1
,
s2
).
InSequence
(
s3
);
}
TypedExpectation
&
InSequence
(
const
Sequence
&
s1
,
const
Sequence
&
s2
,
const
Sequence
&
s3
,
const
Sequence
&
s4
)
{
return
InSequence
(
s1
,
s2
,
s3
).
InSequence
(
s4
);
}
TypedExpectation
&
InSequence
(
const
Sequence
&
s1
,
const
Sequence
&
s2
,
const
Sequence
&
s3
,
const
Sequence
&
s4
,
const
Sequence
&
s5
)
{
return
InSequence
(
s1
,
s2
,
s3
,
s4
).
InSequence
(
s5
);
}
// Implements that .After() clause.
TypedExpectation
&
After
(
const
ExpectationSet
&
s
)
{
ExpectSpecProperty
(
last_clause_
<=
kAfter
,
".After() cannot appear after .WillOnce(),"
" .WillRepeatedly(), or "
".RetiresOnSaturation()."
);
last_clause_
=
kAfter
;
for
(
ExpectationSet
::
const_iterator
it
=
s
.
begin
();
it
!=
s
.
end
();
++
it
)
{
immediate_prerequisites_
+=
*
it
;
}
return
*
this
;
}
TypedExpectation
&
After
(
const
ExpectationSet
&
s1
,
const
ExpectationSet
&
s2
)
{
return
After
(
s1
).
After
(
s2
);
}
TypedExpectation
&
After
(
const
ExpectationSet
&
s1
,
const
ExpectationSet
&
s2
,
const
ExpectationSet
&
s3
)
{
return
After
(
s1
,
s2
).
After
(
s3
);
}
TypedExpectation
&
After
(
const
ExpectationSet
&
s1
,
const
ExpectationSet
&
s2
,
const
ExpectationSet
&
s3
,
const
ExpectationSet
&
s4
)
{
return
After
(
s1
,
s2
,
s3
).
After
(
s4
);
}
TypedExpectation
&
After
(
const
ExpectationSet
&
s1
,
const
ExpectationSet
&
s2
,
const
ExpectationSet
&
s3
,
const
ExpectationSet
&
s4
,
const
ExpectationSet
&
s5
)
{
return
After
(
s1
,
s2
,
s3
,
s4
).
After
(
s5
);
}
// Implements the .WillOnce() clause.
TypedExpectation
&
WillOnce
(
const
Action
<
F
>&
action
)
{
ExpectSpecProperty
(
last_clause_
<=
kWillOnce
,
".WillOnce() cannot appear after "
".WillRepeatedly() or .RetiresOnSaturation()."
);
last_clause_
=
kWillOnce
;
untyped_actions_
.
push_back
(
new
Action
<
F
>
(
action
));
if
(
!
cardinality_specified
())
{
set_cardinality
(
Exactly
(
static_cast
<
int
>
(
untyped_actions_
.
size
())));
}
return
*
this
;
}
// Implements the .WillRepeatedly() clause.
TypedExpectation
&
WillRepeatedly
(
const
Action
<
F
>&
action
)
{
if
(
last_clause_
==
kWillRepeatedly
)
{
ExpectSpecProperty
(
false
,
".WillRepeatedly() cannot appear "
"more than once in an EXPECT_CALL()."
);
}
else
{
ExpectSpecProperty
(
last_clause_
<
kWillRepeatedly
,
".WillRepeatedly() cannot appear "
"after .RetiresOnSaturation()."
);
}
last_clause_
=
kWillRepeatedly
;
repeated_action_specified_
=
true
;
repeated_action_
=
action
;
if
(
!
cardinality_specified
())
{
set_cardinality
(
AtLeast
(
static_cast
<
int
>
(
untyped_actions_
.
size
())));
}
// Now that no more action clauses can be specified, we check
// whether their count makes sense.
CheckActionCountIfNotDone
();
return
*
this
;
}
// Implements the .RetiresOnSaturation() clause.
TypedExpectation
&
RetiresOnSaturation
()
{
ExpectSpecProperty
(
last_clause_
<
kRetiresOnSaturation
,
".RetiresOnSaturation() cannot appear "
"more than once."
);
last_clause_
=
kRetiresOnSaturation
;
retires_on_saturation_
=
true
;
// Now that no more action clauses can be specified, we check
// whether their count makes sense.
CheckActionCountIfNotDone
();
return
*
this
;
}
// Returns the matchers for the arguments as specified inside the
// EXPECT_CALL() macro.
const
ArgumentMatcherTuple
&
matchers
()
const
{
return
matchers_
;
}
// Returns the matcher specified by the .With() clause.
const
Matcher
<
const
ArgumentTuple
&>&
extra_matcher
()
const
{
return
extra_matcher_
;
}
// Returns the action specified by the .WillRepeatedly() clause.
const
Action
<
F
>&
repeated_action
()
const
{
return
repeated_action_
;
}
// If this mock method has an extra matcher (i.e. .With(matcher)),
// describes it to the ostream.
virtual
void
MaybeDescribeExtraMatcherTo
(
::
std
::
ostream
*
os
)
{
if
(
extra_matcher_specified_
)
{
*
os
<<
" Expected args: "
;
extra_matcher_
.
DescribeTo
(
os
);
*
os
<<
"
\n
"
;
}
}
private:
template
<
typename
Function
>
friend
class
FunctionMockerBase
;
// Returns an Expectation object that references and co-owns this
// expectation.
virtual
Expectation
GetHandle
()
{
return
owner_
->
GetHandleOf
(
this
);
}
// The following methods will be called only after the EXPECT_CALL()
// statement finishes and when the current thread holds
// g_gmock_mutex.
// Returns true iff this expectation matches the given arguments.
bool
Matches
(
const
ArgumentTuple
&
args
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
return
TupleMatches
(
matchers_
,
args
)
&&
extra_matcher_
.
Matches
(
args
);
}
// Returns true iff this expectation should handle the given arguments.
bool
ShouldHandleArguments
(
const
ArgumentTuple
&
args
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
// In case the action count wasn't checked when the expectation
// was defined (e.g. if this expectation has no WillRepeatedly()
// or RetiresOnSaturation() clause), we check it when the
// expectation is used for the first time.
CheckActionCountIfNotDone
();
return
!
is_retired
()
&&
AllPrerequisitesAreSatisfied
()
&&
Matches
(
args
);
}
// Describes the result of matching the arguments against this
// expectation to the given ostream.
void
ExplainMatchResultTo
(
const
ArgumentTuple
&
args
,
::
std
::
ostream
*
os
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
if
(
is_retired
())
{
*
os
<<
" Expected: the expectation is active
\n
"
<<
" Actual: it is retired
\n
"
;
}
else
if
(
!
Matches
(
args
))
{
if
(
!
TupleMatches
(
matchers_
,
args
))
{
ExplainMatchFailureTupleTo
(
matchers_
,
args
,
os
);
}
StringMatchResultListener
listener
;
if
(
!
extra_matcher_
.
MatchAndExplain
(
args
,
&
listener
))
{
*
os
<<
" Expected args: "
;
extra_matcher_
.
DescribeTo
(
os
);
*
os
<<
"
\n
Actual: don't match"
;
internal
::
PrintIfNotEmpty
(
listener
.
str
(),
os
);
*
os
<<
"
\n
"
;
}
}
else
if
(
!
AllPrerequisitesAreSatisfied
())
{
*
os
<<
" Expected: all pre-requisites are satisfied
\n
"
<<
" Actual: the following immediate pre-requisites "
<<
"are not satisfied:
\n
"
;
ExpectationSet
unsatisfied_prereqs
;
FindUnsatisfiedPrerequisites
(
&
unsatisfied_prereqs
);
int
i
=
0
;
for
(
ExpectationSet
::
const_iterator
it
=
unsatisfied_prereqs
.
begin
();
it
!=
unsatisfied_prereqs
.
end
();
++
it
)
{
it
->
expectation_base
()
->
DescribeLocationTo
(
os
);
*
os
<<
"pre-requisite #"
<<
i
++
<<
"
\n
"
;
}
*
os
<<
" (end of pre-requisites)
\n
"
;
}
else
{
// This line is here just for completeness' sake. It will never
// be executed as currently the ExplainMatchResultTo() function
// is called only when the mock function call does NOT match the
// expectation.
*
os
<<
"The call matches the expectation.
\n
"
;
}
}
// Returns the action that should be taken for the current invocation.
const
Action
<
F
>&
GetCurrentAction
(
const
FunctionMockerBase
<
F
>*
mocker
,
const
ArgumentTuple
&
args
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
const
int
count
=
call_count
();
Assert
(
count
>=
1
,
__FILE__
,
__LINE__
,
"call_count() is <= 0 when GetCurrentAction() is "
"called - this should never happen."
);
const
int
action_count
=
static_cast
<
int
>
(
untyped_actions_
.
size
());
if
(
action_count
>
0
&&
!
repeated_action_specified_
&&
count
>
action_count
)
{
// If there is at least one WillOnce() and no WillRepeatedly(),
// we warn the user when the WillOnce() clauses ran out.
::
std
::
stringstream
ss
;
DescribeLocationTo
(
&
ss
);
ss
<<
"Actions ran out in "
<<
source_text
()
<<
"...
\n
"
<<
"Called "
<<
count
<<
" times, but only "
<<
action_count
<<
" WillOnce()"
<<
(
action_count
==
1
?
" is"
:
"s are"
)
<<
" specified - "
;
mocker
->
DescribeDefaultActionTo
(
args
,
&
ss
);
Log
(
kWarning
,
ss
.
str
(),
1
);
}
return
count
<=
action_count
?
*
static_cast
<
const
Action
<
F
>*>
(
untyped_actions_
[
static_cast
<
size_t
>
(
count
-
1
)])
:
repeated_action
();
}
// Given the arguments of a mock function call, if the call will
// over-saturate this expectation, returns the default action;
// otherwise, returns the next action in this expectation. Also
// describes *what* happened to 'what', and explains *why* Google
// Mock does it to 'why'. This method is not const as it calls
// IncrementCallCount(). A return value of NULL means the default
// action.
const
Action
<
F
>*
GetActionForArguments
(
const
FunctionMockerBase
<
F
>*
mocker
,
const
ArgumentTuple
&
args
,
::
std
::
ostream
*
what
,
::
std
::
ostream
*
why
)
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
if
(
IsSaturated
())
{
// We have an excessive call.
IncrementCallCount
();
*
what
<<
"Mock function called more times than expected - "
;
mocker
->
DescribeDefaultActionTo
(
args
,
what
);
DescribeCallCountTo
(
why
);
// FIXME: allow the user to control whether
// unexpected calls should fail immediately or continue using a
// flag --gmock_unexpected_calls_are_fatal.
return
nullptr
;
}
IncrementCallCount
();
RetireAllPreRequisites
();
if
(
retires_on_saturation_
&&
IsSaturated
())
{
Retire
();
}
// Must be done after IncrementCount()!
*
what
<<
"Mock function call matches "
<<
source_text
()
<<
"...
\n
"
;
return
&
(
GetCurrentAction
(
mocker
,
args
));
}
// All the fields below won't change once the EXPECT_CALL()
// statement finishes.
FunctionMockerBase
<
F
>*
const
owner_
;
ArgumentMatcherTuple
matchers_
;
Matcher
<
const
ArgumentTuple
&>
extra_matcher_
;
Action
<
F
>
repeated_action_
;
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
TypedExpectation
);
};
// class TypedExpectation
// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
// specifying the default behavior of, or expectation on, a mock
// function.
// Note: class MockSpec really belongs to the ::testing namespace.
// However if we define it in ::testing, MSVC will complain when
// classes in ::testing::internal declare it as a friend class
// template. To workaround this compiler bug, we define MockSpec in
// ::testing::internal and import it into ::testing.
// Logs a message including file and line number information.
GTEST_API_
void
LogWithLocation
(
testing
::
internal
::
LogSeverity
severity
,
const
char
*
file
,
int
line
,
const
std
::
string
&
message
);
template
<
typename
F
>
class
MockSpec
{
public:
typedef
typename
internal
::
Function
<
F
>::
ArgumentTuple
ArgumentTuple
;
typedef
typename
internal
::
Function
<
F
>::
ArgumentMatcherTuple
ArgumentMatcherTuple
;
// Constructs a MockSpec object, given the function mocker object
// that the spec is associated with.
MockSpec
(
internal
::
FunctionMockerBase
<
F
>*
function_mocker
,
const
ArgumentMatcherTuple
&
matchers
)
:
function_mocker_
(
function_mocker
),
matchers_
(
matchers
)
{}
// Adds a new default action spec to the function mocker and returns
// the newly created spec.
internal
::
OnCallSpec
<
F
>&
InternalDefaultActionSetAt
(
const
char
*
file
,
int
line
,
const
char
*
obj
,
const
char
*
call
)
{
LogWithLocation
(
internal
::
kInfo
,
file
,
line
,
std
::
string
(
"ON_CALL("
)
+
obj
+
", "
+
call
+
") invoked"
);
return
function_mocker_
->
AddNewOnCallSpec
(
file
,
line
,
matchers_
);
}
// Adds a new expectation spec to the function mocker and returns
// the newly created spec.
internal
::
TypedExpectation
<
F
>&
InternalExpectedAt
(
const
char
*
file
,
int
line
,
const
char
*
obj
,
const
char
*
call
)
{
const
std
::
string
source_text
(
std
::
string
(
"EXPECT_CALL("
)
+
obj
+
", "
+
call
+
")"
);
LogWithLocation
(
internal
::
kInfo
,
file
,
line
,
source_text
+
" invoked"
);
return
function_mocker_
->
AddNewExpectation
(
file
,
line
,
source_text
,
matchers_
);
}
// This operator overload is used to swallow the superfluous parameter list
// introduced by the ON/EXPECT_CALL macros. See the macro comments for more
// explanation.
MockSpec
<
F
>&
operator
()(
const
internal
::
WithoutMatchers
&
,
void
*
const
)
{
return
*
this
;
}
private:
template
<
typename
Function
>
friend
class
internal
::
FunctionMocker
;
// The function mocker that owns this spec.
internal
::
FunctionMockerBase
<
F
>*
const
function_mocker_
;
// The argument matchers specified in the spec.
ArgumentMatcherTuple
matchers_
;
GTEST_DISALLOW_ASSIGN_
(
MockSpec
);
};
// class MockSpec
// Wrapper type for generically holding an ordinary value or lvalue reference.
// If T is not a reference type, it must be copyable or movable.
// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
// T is a move-only value type (which means that it will always be copyable
// if the current platform does not support move semantics).
//
// The primary template defines handling for values, but function header
// comments describe the contract for the whole template (including
// specializations).
template
<
typename
T
>
class
ReferenceOrValueWrapper
{
public:
// Constructs a wrapper from the given value/reference.
explicit
ReferenceOrValueWrapper
(
T
value
)
:
value_
(
std
::
move
(
value
))
{
}
// Unwraps and returns the underlying value/reference, exactly as
// originally passed. The behavior of calling this more than once on
// the same object is unspecified.
T
Unwrap
()
{
return
std
::
move
(
value_
);
}
// Provides nondestructive access to the underlying value/reference.
// Always returns a const reference (more precisely,
// const RemoveReference<T>&). The behavior of calling this after
// calling Unwrap on the same object is unspecified.
const
T
&
Peek
()
const
{
return
value_
;
}
private:
T
value_
;
};
// Specialization for lvalue reference types. See primary template
// for documentation.
template
<
typename
T
>
class
ReferenceOrValueWrapper
<
T
&>
{
public:
// Workaround for debatable pass-by-reference lint warning (c-library-team
// policy precludes NOLINT in this context)
typedef
T
&
reference
;
explicit
ReferenceOrValueWrapper
(
reference
ref
)
:
value_ptr_
(
&
ref
)
{}
T
&
Unwrap
()
{
return
*
value_ptr_
;
}
const
T
&
Peek
()
const
{
return
*
value_ptr_
;
}
private:
T
*
value_ptr_
;
};
// MSVC warns about using 'this' in base member initializer list, so
// we need to temporarily disable the warning. We have to do it for
// the entire class to suppress the warning, even though it's about
// the constructor only.
GTEST_DISABLE_MSC_WARNINGS_PUSH_
(
4355
)
// C++ treats the void type specially. For example, you cannot define
// a void-typed variable or pass a void value to a function.
// ActionResultHolder<T> holds a value of type T, where T must be a
// copyable type or void (T doesn't need to be default-constructable).
// It hides the syntactic difference between void and other types, and
// is used to unify the code for invoking both void-returning and
// non-void-returning mock functions.
// Untyped base class for ActionResultHolder<T>.
class
UntypedActionResultHolderBase
{
public:
virtual
~
UntypedActionResultHolderBase
()
{}
// Prints the held value as an action's result to os.
virtual
void
PrintAsActionResult
(
::
std
::
ostream
*
os
)
const
=
0
;
};
// This generic definition is used when T is not void.
template
<
typename
T
>
class
ActionResultHolder
:
public
UntypedActionResultHolderBase
{
public:
// Returns the held value. Must not be called more than once.
T
Unwrap
()
{
return
result_
.
Unwrap
();
}
// Prints the held value as an action's result to os.
virtual
void
PrintAsActionResult
(
::
std
::
ostream
*
os
)
const
{
*
os
<<
"
\n
Returns: "
;
// T may be a reference type, so we don't use UniversalPrint().
UniversalPrinter
<
T
>::
Print
(
result_
.
Peek
(),
os
);
}
// Performs the given mock function's default action and returns the
// result in a new-ed ActionResultHolder.
template
<
typename
F
>
static
ActionResultHolder
*
PerformDefaultAction
(
const
FunctionMockerBase
<
F
>*
func_mocker
,
typename
Function
<
F
>::
ArgumentTuple
&&
args
,
const
std
::
string
&
call_description
)
{
return
new
ActionResultHolder
(
Wrapper
(
func_mocker
->
PerformDefaultAction
(
std
::
move
(
args
),
call_description
)));
}
// Performs the given action and returns the result in a new-ed
// ActionResultHolder.
template
<
typename
F
>
static
ActionResultHolder
*
PerformAction
(
const
Action
<
F
>&
action
,
typename
Function
<
F
>::
ArgumentTuple
&&
args
)
{
return
new
ActionResultHolder
(
Wrapper
(
action
.
Perform
(
std
::
move
(
args
))));
}
private:
typedef
ReferenceOrValueWrapper
<
T
>
Wrapper
;
explicit
ActionResultHolder
(
Wrapper
result
)
:
result_
(
std
::
move
(
result
))
{
}
Wrapper
result_
;
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
ActionResultHolder
);
};
// Specialization for T = void.
template
<>
class
ActionResultHolder
<
void
>
:
public
UntypedActionResultHolderBase
{
public:
void
Unwrap
()
{
}
virtual
void
PrintAsActionResult
(
::
std
::
ostream
*
/* os */
)
const
{}
// Performs the given mock function's default action and returns ownership
// of an empty ActionResultHolder*.
template
<
typename
F
>
static
ActionResultHolder
*
PerformDefaultAction
(
const
FunctionMockerBase
<
F
>*
func_mocker
,
typename
Function
<
F
>::
ArgumentTuple
&&
args
,
const
std
::
string
&
call_description
)
{
func_mocker
->
PerformDefaultAction
(
std
::
move
(
args
),
call_description
);
return
new
ActionResultHolder
;
}
// Performs the given action and returns ownership of an empty
// ActionResultHolder*.
template
<
typename
F
>
static
ActionResultHolder
*
PerformAction
(
const
Action
<
F
>&
action
,
typename
Function
<
F
>::
ArgumentTuple
&&
args
)
{
action
.
Perform
(
std
::
move
(
args
));
return
new
ActionResultHolder
;
}
private:
ActionResultHolder
()
{}
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
ActionResultHolder
);
};
// The base of the function mocker class for the given function type.
// We put the methods in this class instead of its child to avoid code
// bloat.
template
<
typename
F
>
class
FunctionMockerBase
:
public
UntypedFunctionMockerBase
{
public:
typedef
typename
Function
<
F
>::
Result
Result
;
typedef
typename
Function
<
F
>::
ArgumentTuple
ArgumentTuple
;
typedef
typename
Function
<
F
>::
ArgumentMatcherTuple
ArgumentMatcherTuple
;
FunctionMockerBase
()
{}
// The destructor verifies that all expectations on this mock
// function have been satisfied. If not, it will report Google Test
// non-fatal failures for the violations.
virtual
~
FunctionMockerBase
()
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
MutexLock
l
(
&
g_gmock_mutex
);
VerifyAndClearExpectationsLocked
();
Mock
::
UnregisterLocked
(
this
);
ClearDefaultActionsLocked
();
}
// Returns the ON_CALL spec that matches this mock function with the
// given arguments; returns NULL if no matching ON_CALL is found.
// L = *
const
OnCallSpec
<
F
>*
FindOnCallSpec
(
const
ArgumentTuple
&
args
)
const
{
for
(
UntypedOnCallSpecs
::
const_reverse_iterator
it
=
untyped_on_call_specs_
.
rbegin
();
it
!=
untyped_on_call_specs_
.
rend
();
++
it
)
{
const
OnCallSpec
<
F
>*
spec
=
static_cast
<
const
OnCallSpec
<
F
>*>
(
*
it
);
if
(
spec
->
Matches
(
args
))
return
spec
;
}
return
nullptr
;
}
// Performs the default action of this mock function on the given
// arguments and returns the result. Asserts (or throws if
// exceptions are enabled) with a helpful call descrption if there
// is no valid return value. This method doesn't depend on the
// mutable state of this object, and thus can be called concurrently
// without locking.
// L = *
Result
PerformDefaultAction
(
typename
Function
<
F
>::
ArgumentTuple
&&
args
,
const
std
::
string
&
call_description
)
const
{
const
OnCallSpec
<
F
>*
const
spec
=
this
->
FindOnCallSpec
(
args
);
if
(
spec
!=
nullptr
)
{
return
spec
->
GetAction
().
Perform
(
std
::
move
(
args
));
}
const
std
::
string
message
=
call_description
+
"
\n
The mock function has no default action "
"set, and its return type has no default value set."
;
#if GTEST_HAS_EXCEPTIONS
if
(
!
DefaultValue
<
Result
>::
Exists
())
{
throw
std
::
runtime_error
(
message
);
}
#else
Assert
(
DefaultValue
<
Result
>::
Exists
(),
""
,
-
1
,
message
);
#endif
return
DefaultValue
<
Result
>::
Get
();
}
// Performs the default action with the given arguments and returns
// the action's result. The call description string will be used in
// the error message to describe the call in the case the default
// action fails. The caller is responsible for deleting the result.
// L = *
virtual
UntypedActionResultHolderBase
*
UntypedPerformDefaultAction
(
void
*
untyped_args
,
// must point to an ArgumentTuple
const
std
::
string
&
call_description
)
const
{
ArgumentTuple
*
args
=
static_cast
<
ArgumentTuple
*>
(
untyped_args
);
return
ResultHolder
::
PerformDefaultAction
(
this
,
std
::
move
(
*
args
),
call_description
);
}
// Performs the given action with the given arguments and returns
// the action's result. The caller is responsible for deleting the
// result.
// L = *
virtual
UntypedActionResultHolderBase
*
UntypedPerformAction
(
const
void
*
untyped_action
,
void
*
untyped_args
)
const
{
// Make a copy of the action before performing it, in case the
// action deletes the mock object (and thus deletes itself).
const
Action
<
F
>
action
=
*
static_cast
<
const
Action
<
F
>*>
(
untyped_action
);
ArgumentTuple
*
args
=
static_cast
<
ArgumentTuple
*>
(
untyped_args
);
return
ResultHolder
::
PerformAction
(
action
,
std
::
move
(
*
args
));
}
// Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
// clears the ON_CALL()s set on this mock function.
virtual
void
ClearDefaultActionsLocked
()
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
// Deleting our default actions may trigger other mock objects to be
// deleted, for example if an action contains a reference counted smart
// pointer to that mock object, and that is the last reference. So if we
// delete our actions within the context of the global mutex we may deadlock
// when this method is called again. Instead, make a copy of the set of
// actions to delete, clear our set within the mutex, and then delete the
// actions outside of the mutex.
UntypedOnCallSpecs
specs_to_delete
;
untyped_on_call_specs_
.
swap
(
specs_to_delete
);
g_gmock_mutex
.
Unlock
();
for
(
UntypedOnCallSpecs
::
const_iterator
it
=
specs_to_delete
.
begin
();
it
!=
specs_to_delete
.
end
();
++
it
)
{
delete
static_cast
<
const
OnCallSpec
<
F
>*>
(
*
it
);
}
// Lock the mutex again, since the caller expects it to be locked when we
// return.
g_gmock_mutex
.
Lock
();
}
protected:
template
<
typename
Function
>
friend
class
MockSpec
;
typedef
ActionResultHolder
<
Result
>
ResultHolder
;
// Returns the result of invoking this mock function with the given
// arguments. This function can be safely called from multiple
// threads concurrently.
Result
InvokeWith
(
typename
Function
<
F
>::
ArgumentTuple
&&
args
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
// const_cast is required since in C++98 we still pass ArgumentTuple around
// by const& instead of rvalue reference.
void
*
untyped_args
=
const_cast
<
void
*>
(
static_cast
<
const
void
*>
(
&
args
));
scoped_ptr
<
ResultHolder
>
holder
(
DownCast_
<
ResultHolder
*>
(
this
->
UntypedInvokeWith
(
untyped_args
)));
return
holder
->
Unwrap
();
}
// Adds and returns a default action spec for this mock function.
OnCallSpec
<
F
>&
AddNewOnCallSpec
(
const
char
*
file
,
int
line
,
const
ArgumentMatcherTuple
&
m
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
Mock
::
RegisterUseByOnCallOrExpectCall
(
MockObject
(),
file
,
line
);
OnCallSpec
<
F
>*
const
on_call_spec
=
new
OnCallSpec
<
F
>
(
file
,
line
,
m
);
untyped_on_call_specs_
.
push_back
(
on_call_spec
);
return
*
on_call_spec
;
}
// Adds and returns an expectation spec for this mock function.
TypedExpectation
<
F
>&
AddNewExpectation
(
const
char
*
file
,
int
line
,
const
std
::
string
&
source_text
,
const
ArgumentMatcherTuple
&
m
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
Mock
::
RegisterUseByOnCallOrExpectCall
(
MockObject
(),
file
,
line
);
TypedExpectation
<
F
>*
const
expectation
=
new
TypedExpectation
<
F
>
(
this
,
file
,
line
,
source_text
,
m
);
const
linked_ptr
<
ExpectationBase
>
untyped_expectation
(
expectation
);
// See the definition of untyped_expectations_ for why access to
// it is unprotected here.
untyped_expectations_
.
push_back
(
untyped_expectation
);
// Adds this expectation into the implicit sequence if there is one.
Sequence
*
const
implicit_sequence
=
g_gmock_implicit_sequence
.
get
();
if
(
implicit_sequence
!=
nullptr
)
{
implicit_sequence
->
AddExpectation
(
Expectation
(
untyped_expectation
));
}
return
*
expectation
;
}
private:
template
<
typename
Func
>
friend
class
TypedExpectation
;
// Some utilities needed for implementing UntypedInvokeWith().
// Describes what default action will be performed for the given
// arguments.
// L = *
void
DescribeDefaultActionTo
(
const
ArgumentTuple
&
args
,
::
std
::
ostream
*
os
)
const
{
const
OnCallSpec
<
F
>*
const
spec
=
FindOnCallSpec
(
args
);
if
(
spec
==
nullptr
)
{
*
os
<<
(
internal
::
type_equals
<
Result
,
void
>::
value
?
"returning directly.
\n
"
:
"returning default value.
\n
"
);
}
else
{
*
os
<<
"taking default action specified at:
\n
"
<<
FormatFileLocation
(
spec
->
file
(),
spec
->
line
())
<<
"
\n
"
;
}
}
// Writes a message that the call is uninteresting (i.e. neither
// explicitly expected nor explicitly unexpected) to the given
// ostream.
virtual
void
UntypedDescribeUninterestingCall
(
const
void
*
untyped_args
,
::
std
::
ostream
*
os
)
const
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
const
ArgumentTuple
&
args
=
*
static_cast
<
const
ArgumentTuple
*>
(
untyped_args
);
*
os
<<
"Uninteresting mock function call - "
;
DescribeDefaultActionTo
(
args
,
os
);
*
os
<<
" Function call: "
<<
Name
();
UniversalPrint
(
args
,
os
);
}
// Returns the expectation that matches the given function arguments
// (or NULL is there's no match); when a match is found,
// untyped_action is set to point to the action that should be
// performed (or NULL if the action is "do default"), and
// is_excessive is modified to indicate whether the call exceeds the
// expected number.
//
// Critical section: We must find the matching expectation and the
// corresponding action that needs to be taken in an ATOMIC
// transaction. Otherwise another thread may call this mock
// method in the middle and mess up the state.
//
// However, performing the action has to be left out of the critical
// section. The reason is that we have no control on what the
// action does (it can invoke an arbitrary user function or even a
// mock function) and excessive locking could cause a dead lock.
virtual
const
ExpectationBase
*
UntypedFindMatchingExpectation
(
const
void
*
untyped_args
,
const
void
**
untyped_action
,
bool
*
is_excessive
,
::
std
::
ostream
*
what
,
::
std
::
ostream
*
why
)
GTEST_LOCK_EXCLUDED_
(
g_gmock_mutex
)
{
const
ArgumentTuple
&
args
=
*
static_cast
<
const
ArgumentTuple
*>
(
untyped_args
);
MutexLock
l
(
&
g_gmock_mutex
);
TypedExpectation
<
F
>*
exp
=
this
->
FindMatchingExpectationLocked
(
args
);
if
(
exp
==
nullptr
)
{
// A match wasn't found.
this
->
FormatUnexpectedCallMessageLocked
(
args
,
what
,
why
);
return
nullptr
;
}
// This line must be done before calling GetActionForArguments(),
// which will increment the call count for *exp and thus affect
// its saturation status.
*
is_excessive
=
exp
->
IsSaturated
();
const
Action
<
F
>*
action
=
exp
->
GetActionForArguments
(
this
,
args
,
what
,
why
);
if
(
action
!=
nullptr
&&
action
->
IsDoDefault
())
action
=
nullptr
;
// Normalize "do default" to NULL.
*
untyped_action
=
action
;
return
exp
;
}
// Prints the given function arguments to the ostream.
virtual
void
UntypedPrintArgs
(
const
void
*
untyped_args
,
::
std
::
ostream
*
os
)
const
{
const
ArgumentTuple
&
args
=
*
static_cast
<
const
ArgumentTuple
*>
(
untyped_args
);
UniversalPrint
(
args
,
os
);
}
// Returns the expectation that matches the arguments, or NULL if no
// expectation matches them.
TypedExpectation
<
F
>*
FindMatchingExpectationLocked
(
const
ArgumentTuple
&
args
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
// See the definition of untyped_expectations_ for why access to
// it is unprotected here.
for
(
typename
UntypedExpectations
::
const_reverse_iterator
it
=
untyped_expectations_
.
rbegin
();
it
!=
untyped_expectations_
.
rend
();
++
it
)
{
TypedExpectation
<
F
>*
const
exp
=
static_cast
<
TypedExpectation
<
F
>*>
(
it
->
get
());
if
(
exp
->
ShouldHandleArguments
(
args
))
{
return
exp
;
}
}
return
nullptr
;
}
// Returns a message that the arguments don't match any expectation.
void
FormatUnexpectedCallMessageLocked
(
const
ArgumentTuple
&
args
,
::
std
::
ostream
*
os
,
::
std
::
ostream
*
why
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
*
os
<<
"
\n
Unexpected mock function call - "
;
DescribeDefaultActionTo
(
args
,
os
);
PrintTriedExpectationsLocked
(
args
,
why
);
}
// Prints a list of expectations that have been tried against the
// current mock function call.
void
PrintTriedExpectationsLocked
(
const
ArgumentTuple
&
args
,
::
std
::
ostream
*
why
)
const
GTEST_EXCLUSIVE_LOCK_REQUIRED_
(
g_gmock_mutex
)
{
g_gmock_mutex
.
AssertHeld
();
const
size_t
count
=
untyped_expectations_
.
size
();
*
why
<<
"Google Mock tried the following "
<<
count
<<
" "
<<
(
count
==
1
?
"expectation, but it didn't match"
:
"expectations, but none matched"
)
<<
":
\n
"
;
for
(
size_t
i
=
0
;
i
<
count
;
i
++
)
{
TypedExpectation
<
F
>*
const
expectation
=
static_cast
<
TypedExpectation
<
F
>*>
(
untyped_expectations_
[
i
].
get
());
*
why
<<
"
\n
"
;
expectation
->
DescribeLocationTo
(
why
);
if
(
count
>
1
)
{
*
why
<<
"tried expectation #"
<<
i
<<
": "
;
}
*
why
<<
expectation
->
source_text
()
<<
"...
\n
"
;
expectation
->
ExplainMatchResultTo
(
args
,
why
);
expectation
->
DescribeCallCountTo
(
why
);
}
}
// There is no generally useful and implementable semantics of
// copying a mock object, so copying a mock is usually a user error.
// Thus we disallow copying function mockers. If the user really
// wants to copy a mock object, they should implement their own copy
// operation, for example:
//
// class MockFoo : public Foo {
// public:
// // Defines a copy constructor explicitly.
// MockFoo(const MockFoo& src) {}
// ...
// };
GTEST_DISALLOW_COPY_AND_ASSIGN_
(
FunctionMockerBase
);
};
// class FunctionMockerBase
GTEST_DISABLE_MSC_WARNINGS_POP_
()
// 4355
// Implements methods of FunctionMockerBase.
// Verifies that all expectations on this mock function have been
// satisfied. Reports one or more Google Test non-fatal failures and
// returns false if not.
// Reports an uninteresting call (whose description is in msg) in the
// manner specified by 'reaction'.
void
ReportUninterestingCall
(
CallReaction
reaction
,
const
std
::
string
&
msg
);
}
// namespace internal
// The style guide prohibits "using" statements in a namespace scope
// inside a header file. However, the MockSpec class template is
// meant to be defined in the ::testing namespace. The following line
// is just a trick for working around a bug in MSVC 8.0, which cannot
// handle it if we define MockSpec in ::testing.
using
internal
::
MockSpec
;
// Const(x) is a convenient function for obtaining a const reference
// to x. This is useful for setting expectations on an overloaded
// const mock method, e.g.
//
// class MockFoo : public FooInterface {
// public:
// MOCK_METHOD0(Bar, int());
// MOCK_CONST_METHOD0(Bar, int&());
// };
//
// MockFoo foo;
// // Expects a call to non-const MockFoo::Bar().
// EXPECT_CALL(foo, Bar());
// // Expects a call to const MockFoo::Bar().
// EXPECT_CALL(Const(foo), Bar());
template
<
typename
T
>
inline
const
T
&
Const
(
const
T
&
x
)
{
return
x
;
}
// Constructs an Expectation object that references and co-owns exp.
inline
Expectation
::
Expectation
(
internal
::
ExpectationBase
&
exp
)
// NOLINT
:
expectation_base_
(
exp
.
GetHandle
().
expectation_base
())
{}
}
// namespace testing
GTEST_DISABLE_MSC_WARNINGS_POP_
()
// 4251
// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
// required to avoid compile errors when the name of the method used in call is
// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
// tests in internal/gmock-spec-builders_test.cc for more details.
//
// This macro supports statements both with and without parameter matchers. If
// the parameter list is omitted, gMock will accept any parameters, which allows
// tests to be written that don't need to encode the number of method
// parameter. This technique may only be used for non-overloaded methods.
//
// // These are the same:
// ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
// ON_CALL(mock, NoArgsMethod).WillByDefault(...);
//
// // As are these:
// ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
// ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
//
// // Can also specify args if you want, of course:
// ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
//
// // Overloads work as long as you specify parameters:
// ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
// ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
//
// // Oops! Which overload did you want?
// ON_CALL(mock, OverloadedMethod).WillByDefault(...);
// => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
//
// How this works: The mock class uses two overloads of the gmock_Method
// expectation setter method plus an operator() overload on the MockSpec object.
// In the matcher list form, the macro expands to:
//
// // This statement:
// ON_CALL(mock, TwoArgsMethod(_, 45))...
//
// // ...expands to:
// mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
// |-------------v---------------||------------v-------------|
// invokes first overload swallowed by operator()
//
// // ...which is essentially:
// mock.gmock_TwoArgsMethod(_, 45)...
//
// Whereas the form without a matcher list:
//
// // This statement:
// ON_CALL(mock, TwoArgsMethod)...
//
// // ...expands to:
// mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
// |-----------------------v--------------------------|
// invokes second overload
//
// // ...which is essentially:
// mock.gmock_TwoArgsMethod(_, _)...
//
// The WithoutMatchers() argument is used to disambiguate overloads and to
// block the caller from accidentally invoking the second overload directly. The
// second argument is an internal type derived from the method signature. The
// failure to disambiguate two overloads of this method in the ON_CALL statement
// is how we block callers from setting expectations on overloaded methods.
#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call) \
((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), nullptr) \
.Setter(__FILE__, __LINE__, #mock_expr, #call)
#define ON_CALL(obj, call) \
GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
#define EXPECT_CALL(obj, call) \
GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
#endif
// GMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
Event Timeline
Log In to Comment