Utiliser google mock pour le code C

j'ai trouvé un moyen de pouvoir simuler des fonctions C dans google-mock.

La solution est de déclarer foobar faible alias cartes foobarImpl. Dans le code de production vous n'implémentez pas foobar() et pour les tests unitaires vous fournissez une implémentation qui appelle un objet simulé statique.

cette solution est spécifique à GCC mais il y a d'autres compilateurs/linkers qui fournissent un aliasing faible.

• renommer la fonction void foobar(); pour void foobarImpl();
• ajouter un attribut à la fonction foobar comme: void foobar() __attribute__((weak, alias("foobarImpl") ));
• si vous voulez avoir un alias non faible, utilisez une directive preproessor pour supprimer le faible des attributs.

D'où:

#pragma once
void foobar();

devient

// header.h
#pragma once

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

et

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

ceci indiquera au gnu linker de lier les appels de foobar()foobarImpl() quand il n'y a pas de symbole appelé foobar()

puis ajouter le test 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();
}

si ce code est compilé et lié il remplacera foobar avec le simulacre d'appel. si vous voulez vraiment appeler foobar() vous pouvez toujours ajouter une invocation par défaut.

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