Google Mock peut-il utiliser une méthode avec un type de retour de pointeur intelligent?

J’ai une usine qui renvoie un pointeur intelligent. Quel que soit le pointeur intelligent que j’utilise, je ne peux pas obtenir que Google Mock se moque de la méthode d’usine.

L’object simulé est l’implémentation d’une interface abstraite pure où toutes les méthodes sont virtuelles. J’ai un prototype:

MOCK_METHOD0(Create, std::unique_ptr()); 

Et je reçois:

 "...gmock/gmock-spec-builders.h(1314): error C2248: 'std::unique_ptr::unique_ptr' : cannot access private member declared in class 'std::unique_ptr'" 

Le type pointé dans le pointeur intelligent est défini.

Et j’essaie d’essayer d’accéder à l’un des constructeurs déclarés privés, mais je ne comprends pas pourquoi. Lorsqu’il s’agissait d’un std :: auto_ptr, l’erreur indiquait qu’il n’y avait pas de constructeur de copie, ce qui me déconcerte.

De toute façon, y a-t-il un moyen de simuler une méthode qui renvoie un pointeur intelligent? Ou existe-t-il une meilleure façon de construire une usine? Est-ce que ma seule résolution est de retourner un pointeur brut (blech …)?

Mon environnement est Visual Studio 2010 Ultimate et Windows 7. Je n’utilise pas CLI.

Google Mock requirejs que les parameters et les valeurs de retour des méthodes simulées soient copiables, dans la plupart des cas. Par documentation de boost , unique_ptr n’est pas copiable. Vous avez la possibilité de renvoyer l’une des classes de pointeurs intelligents qui utilisent la propriété partagée ( shared_ptr , linked_ptr, etc.) et sont donc copiables. Ou vous pouvez utiliser un pointeur brut. Puisque la méthode en question est apparemment la méthode de construction d’un object, je ne vois aucun problème inhérent au renvoi d’un pointeur brut. Tant que vous atsortingbuez le résultat à un pointeur partagé sur chaque site d’appel, vous allez vous en sortir.

Une solution possible aux problèmes de google mock framework avec des arguments de fonction non (const) copiables et des valeurs de répétition consiste à utiliser des méthodes de simulation de proxy.

Supposons que vous ayez la définition d’interface suivante (si le bon style à utiliser std::unique_ptr semble être plus ou moins une question philosophique, je l’aime personnellement pour imposer le transfert de propriété):

 class IFooInterface { public: virtual void nonCopyableParam(std::unique_ptr uPtr) = 0; virtual std::unique_ptr nonCopyableReturn() = 0; virtual ~IFooInterface() {} }; 

La classe de simulation appropriée pourrait être définie comme ceci:

 class FooInterfaceMock : public IFooInterface { public: FooInterfaceMock() {} virtual ~FooInterfaceMock() {} virtual void nonCopyableParam(std::unique_ptr uPtr) { nonCopyableParamProxy(uPtr.get()); } virtual std::unique_ptr nonCopyableReturn() { return std::unique_ptr(nonCopyableReturnProxy()); } MOCK_METHOD1(nonCopyableParamProxy,void (IMyObjectThing*)); MOCK_METHOD0(nonCopyableReturnProxy,IMyObjectThing* ()); }; 

Il suffit de veiller à ce que les configurations (actions sockets) de la méthode nonCopyableReturnProxy() renvoient soit NULL soit une instance allouée dynamicment sur le tas.


Il y a un forum de discussion de google-mock sur ce sujet où l’un des responsables déclare que l’infrastructure google-mock ne sera pas modifiée pour supporter cela à l’avenir, arguant que leurs stratégies découragent fortement l’utilisation des parameters std::auto_ptr . Comme mentionné, il s’agit d’un sharepoint vue philosophique à mon humble avis, et les fonctionnalités du cadre moqueur ne devraient pas orienter le type d’interface que vous souhaitez concevoir ou utiliser à partir d’API tierces.

Comme indiqué, la réponse décrit une solution de rechange réalisable .