GMOCK a method accepting variable arguments

Question

I have a class that has a method which accepts variable arguments:

class MyClass
{
public:
virtual void myprint(const char* format, ...) = 0; 
};

I was trying to mock the above class

class Mock : public MyClass
{
public:
MOCK_METHOD1(myprint, void (const char* format, ...));
}

But it gives my compilation issues:

error: 'Result' in 'struct testing::internal::Function<void(const char*, ...)>' does not name a type
  MOCK_METHOD1(myprint, void (const char* format, ...));
  ^
error: incomplete type 'testing::internal::Function<void(const char*, ...)>' used in nested name specifier
 error: incomplete type 'testing::internal::Function<void(const char*, ...)>' used in nested name specifier
error: template argument 1 is invalid
error: field 'gmock1_print_15' has incomplete type 'testing::internal::FunctionMocker<void(const char*, ...)>'

How can I mock a method that takes variable arguments as a parameter?

This is one of many reasons I decided to make my own mock generation tool after being frustrated with what's out there. If you're open to trying something new, it might be able to help you: [mimicc.dev](https://mimicc.dev). At the very least it will let you generate a mock for the variadic function that compiles, links, and runs. There's currently no way to set automatic checks on the variadic arguments, but it may be enough for your purposes. — Jon Reeves, May 02 '21 at 23:17

frslm · Accepted Answer · 2021-04-30T04:04:23.500

Unfortunately, you cannot directly mock a variadic function in Gmock:

You cannot mock a variadic function (i.e. a function taking ellipsis (...) arguments) directly in Google Mock.

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 the protocol, and we cannot look into his head.

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 way to do it is to provide overloaded versions of the function.

Ellipsis arguments are inherited from C and not really a C++ feature. They are unsafe to use and don't work with arguments that have constructors or destructors. Therefore we recommend to avoid them in C++ as much as possible.

However, Nemelis on SO has suggested some workaround that you could use to achieve this. It involves processing your format argument along with any variadic arguments to create a single message string, and then mocking a function that takes in message as a single argument.

GMOCK a method accepting variable arguments

1 Answers1