Using google mock for C code

Question

I\'m maintaining a legacy project written in C and it\'s unfeasible to get it running with a C++ compiler. Since the code is cross compiled it is however possible to run uni

Answer 1

I found a way to be able to mock bare C functions in google-mock.

The solution is to declare foobar to be a weak alias that maps to foobarImpl. In production code you do not implement foobar() and for unit tests you provide an implementation that calls a static mock object.

This solution is GCC specific but there are other compilers/linkers that provide weak aliasing.

• rename the function void foobar(); to void foobarImpl();
• add an attribute to the function foobar like: void foobar() __attribute__((weak, alias("foobarImpl") ));
• if you want to have a non weak alias use a preproessor directive to remove the weak from the attributes.

Hence:

#pragma once
void foobar();

becomes

// header.h
#pragma once

void foobar();    
void foobarImpl(); // real implementation

and

extern "C" {
#include "header.h"
}
// code.c
void foobarImpl() {
  /* do sth */
}
void foobar() __attribute__(( weak, alias ("foobarImpl") )); // declare foobar to be a weak alias of foobarImpl

This will tell the gnu linker to link calls of foobar() with foobarImpl() whenever there is no symbol called foobar()

then add the testing code

struct FooInterface {
   virtual ~FooInterface() {}
   virtual void invokeFoo() const { }
};

class MockFoo : public FooInterface {
public:
  MOCK_CONST_METHOD0(invokeFoo, void());
}

struct RealFoo : public FooInterface {
   virtual ~RealFoo() {}
   virtual void invokeFoo() const { foobarImpl(); }
};

MockFoo mockFoo;
RealFoo realFoo;
void foobar() {
  mockFoo.invokeFoo();
}

if this code is compiled and linked it will replace foobar with the mock call. if you really want to call foobar() you can still do add a default invocation.

ON_CALL(mockFoo, invokeFoo())
       .WillByDefault(Invoke(&realFoo,&RealFoo::invokeFoo));

Answer 2

As from the Google Mock FAQ:

My code calls a static/global function. Can I mock it?
You can, but you need to make some changes.

In general, if you find yourself needing to mock a static function, it's a sign that your modules are too tightly coupled (and less flexible, less reusable, less testable, etc). You are probably better off defining a small interface and call the function through that interface, which then can be easily mocked. It's a bit of work initially, but usually pays for itself quickly.

This Google Testing Blog post says it excellently. Check it out.

Answer 3

Your question specifically mentions Google Mock, but then does not state any other reason for using that framework. The other answer suggests using a workaround which seems unnecessarily intrusive.

Hence I hope I am allowed to make an alternative suggestion which works well without having to use weak aliases etc.

I have used CppUTest (https://cpputest.github.io/) for unit test with mock, successfully on a couple of large mainly-C projects (some C++). The mocking works without having to resort to any subterfuge of the above sort.

Unfortunately the project documentation is a little weak, some better (if a little agile-doctrinaire) information and examples in the book (also seen circulating as a PDF) "Test Driven Development for Embedded C" - James W Greening (ISBN-13: 978-1-934356-62-3)