Google Mock può essere un metodo con un tipo di ritorno puntatore intelligente?

Ho una fabbrica che restituisce un puntatore intelligente. Indipendentemente da quale puntatore intelligente utilizzo, non riesco a convincere Google Mock a prendere in giro il metodo factory.

L’object mock è l’implementazione di una pura interfaccia astratta in cui tutti i metodi sono virtuali. Ho un prototipo:

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

E ottengo:

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

Il tipo puntato nel puntatore intelligente è definito.

E capisco che sta tentando di accedere a uno dei costruttori dichiarato privato, ma non capisco perché. Quando questo era uno std :: auto_ptr, l’errore diceva che non esisteva un costruttore di copia, il che mi confonde.

Ad ogni modo, c’è un modo per deridere un metodo che restituisce un puntatore intelligente? O c’è un modo migliore per build una fabbrica? La mia unica decisione è di restituire un puntatore raw (blech …)?

Il mio ambiente è Visual Studio 2010 Ultimate e Windows 7. Non sto usando la CLI.

Google Mock richiede, nella maggior parte dei casi, parametri e valori restituiti dai metodi di simulazione. La documentazione di Per boost , unique_ptr non è copiabile. Hai la possibilità di restituire una delle classi di puntatori intelligenti che utilizzano la proprietà condivisa ( shared_ptr , link_ptr, ecc.) E sono quindi copiabili. O puoi usare un puntatore raw. Poiché il metodo in questione è apparentemente il metodo che costruisce un object, non vedo alcun problema inerente con la restituzione di un puntatore raw. Finché si assegna il risultato a qualche puntatore condiviso in ogni sito di chiamata, starai bene.

Una soluzione fattibile per i problemi di google mock framework con argomenti di funzione non copiabili (const) e valori di retun consiste nell’usare metodi di proxy proxy.

Supponiamo di avere la seguente definizione di interfaccia (se è bello usare lo std::unique_ptr in questo modo sembra essere più o meno una questione filosofica, personalmente mi piace far rispettare il trasferimento di proprietà):

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

La class di simulazione appropriata potrebbe essere definita in questo modo:

 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* ()); }; 

Devi solo fare attenzione, quelle configurazioni (Azioni intraprese) per il metodo nonCopyableReturnProxy() restituiscono NULL o un’istanza allocata dynamicmente nell’heap.


C’è una discussione sul forum utente di google-mock che discute questo argomento in cui uno dei manutentori afferma che il framework google-mock non verrà modificato per supportarlo in futuro sostenendo che le loro politiche scoraggiano fortemente i parametri di utilizzo std::auto_ptr . Come già detto, IMHO è un punto di vista filosofico e le capacità del framework di derisione non dovrebbero guidare il tipo di interfacce che si desidera progettare o è ansible utilizzare da API di terze parti.

Come detto la risposta descrive una soluzione fattibile .