Please send your questions to the

[googlemock](http://groups.google.com/group/googlemock) discussion

group. If you need help with compiler errors, make sure you have

## When I call a method on my mock object, the method for the real object is invoked instead. What's the problem? ##

matcher to the new API. Here's what you need to do:

If you wrote your matcher like this:

// Old matcher definition that doesn't work with the latest

// Google Mock.

using ::testing::MatcherInterface;

```

you'll need to change it to:

// New matcher definition that works with the latest Google Mock.

using ::testing::MatcherInterface;

using ::testing::MatchResultListener;

If you were also using `ExplainMatchResultTo()` to improve the matcher

message:

// Old matcher definition that doesn't work with the lastest

// Google Mock.

using ::testing::MatcherInterface;

you should move the logic of `ExplainMatchResultTo()` into

`MatchAndExplain()`, using the `MatchResultListener` argument where

the `::std::ostream` was used:

// New matcher definition that works with the latest Google Mock.

using ::testing::MatcherInterface;

using ::testing::MatchResultListener;

```

If your matcher is defined using `MakePolymorphicMatcher()`:

// Old matcher definition that doesn't work with the latest

// Google Mock.

using ::testing::MakePolymorphicMatcher;

you should rename the `Matches()` method to `MatchAndExplain()` and

add a `MatchResultListener*` argument (the same as what you need to do

for matchers defined by implementing `MatcherInterface`):

// New matcher definition that works with the latest Google Mock.

using ::testing::MakePolymorphicMatcher;

using ::testing::MatchResultListener;

If your polymorphic matcher uses `ExplainMatchResultTo()` for better

failure messages:

// Old matcher definition that doesn't work with the latest

// Google Mock.

using ::testing::MakePolymorphicMatcher;

you'll need to move the logic inside `ExplainMatchResultTo()` to

`MatchAndExplain()`:

// New matcher definition that works with the latest Google Mock.

using ::testing::MakePolymorphicMatcher;

using ::testing::MatchResultListener;

The problem is that in general, there is _no way_ for a mock object to

know how many arguments are passed to the variadic method, and what

the arguments' types are. Only the _author of the base class_ knows

Therefore, to mock such a function, the _user_ must teach the mock

object how to figure out the number of arguments and their types. One

## MSVC gives me warning C4301 or C4373 when I define a mock method with a const parameter. Why? ##

If you compile this using Microsoft Visual C++ 2005 SP1:

class Foo {

...

virtual void Bar(const int i) = 0;

In C++, if you _declare_ a function with a `const` parameter, the

`const` modifier is _ignored_. Therefore, the `Foo` base class above

is equivalent to:

class Foo {

...

virtual void Bar(int i) = 0; // int or const int? Makes no difference.

If the function parameter is passed by pointer or reference, declaring

the _pointee_ or _referee_ as `const` is still meaningful. For

example, the following two declarations are _not_ equivalent:

void Bar(int* p); // Neither p nor *p is const.

void Bar(const int* p); // p is not const, but *p is.

```

## How can I assert that a function is NEVER called? ##

EXPECT_CALL(foo, Bar(_))

.Times(0);

```

virtual. Otherwise Bad Things will happen. Consider the following

code:

class Base {

public:

// Not virtual, but should be.

When people complain about this, often they are referring to code like:

// foo.Bar() should be called twice, return 1 the first time, and return

// 2 the second time. However, I have to write the expectations in the

// reverse order. This sucks big time!!!

There are two better ways to write the test spec. You could either

put the expectations in sequence:

// foo.Bar() should be called twice, return 1 the first time, and return

// 2 the second time. Using a sequence, we can write the expectations

// in their natural order.

or you can put the sequence of actions in the same expectation:

// foo.Bar() should be called twice, return 1 the first time, and return

// 2 the second time.

EXPECT_CALL(foo, Bar())

If, however, you are sure that the calls are OK, you can write

EXPECT_CALL(foo, Bar(_))

.WillRepeatedly(...);

```

instead of

ON_CALL(foo, Bar(_))

.WillByDefault(...);

```

If you find yourself needing to perform some action that's not

supported by Google Mock directly, remember that you can define your own

actions using

or you can write a stub function and invoke it using

## MOCK\_METHODn()'s second argument looks funny. Why don't you use the MOCK\_METHODn(Method, return\_type, arg\_1, ..., arg\_n) syntax? ##

has.

Try to mock a function that takes a map as an argument:

virtual int GetSize(const map<int, std::string>& m);

```

Using the proposed syntax, it would be:

MOCK_METHOD1(GetSize, int, const map<int, std::string>& m);

```

that gets in the way of your work. Google Mock's syntax avoids this

problem as the function's argument types are protected inside a pair

of parentheses:

// This compiles fine.

MOCK_METHOD1(GetSize, int(const map<int, std::string>& m));

```

initially, but usually pays for itself quickly.

This Google Testing Blog

says it excellently. Check it out.

## My mock object needs to do complex stuff. It's a lot of pain to specify the actions. Google Mock sucks! ##

side effect is, but doesn't say what the return value should be. You

need `DoAll()` to chain a `SetArgPointee()` with a `Return()`.

## My question is not in your FAQ! ##

If you cannot find the answer to your question in this FAQ, there are

some other resources you can use:

1. search the mailing list [archive](http://groups.google.com/group/googlemock/topics),

1. ask it on [googlemock@googlegroups.com](mailto:googlemock@googlegroups.com) and someone will answer it (to prevent spam, we require you to join the [discussion group](http://groups.google.com/group/googlemock) before you can post.).