HippoMocks - mocking di una funzione che restituisce un unique_ptr

Question

Attualmente non sto riuscendo a simulare un'interfaccia che restituisce un unique_ptr. Ad esempio, dato

struct IFoo {  
    virtual std::unique_ptr<IFoo> foo = 0; 
}; 


int main() 
{ 
    MockRepository mocks; 
    auto foo = mocks.Mock<IFoo>(); 
    mocks.OnCall(foo, IFoo::foo) 
     .Return(std::unique_ptr<IFoo>()); 
} 

Questo non riesce a compilare perché l'implementazione Return fa una copia del unique_ptr

Call &Return(Y obj) { retVal = new ReturnValueWrapper<Y>(obj); return *this; } 

e l'aspettativa tenta di restituire l'unique_ptr

template <typename Z> 
Z MockRepository::DoExpectation(base_mock *mock, std::pair<int, int> funcno, const base_tuple &tuple) 
{ 
    ... 
    return ((ReturnValueWrapper<Z> *)call->retVal)->rv; 
} 

ho provato Do, come suggerito for a similar problem with returned references.

Ho anche provato a scrivere il mio ValueWrapper<T> che genera un unique_ptr, ma da qualche parte il valore ottiene sempre copiati. In questo momento sono a corto di idee.

Answer 1

Una soluzione al problema è quello di creare un'interfaccia derivata con un metodo aggiuntivo che restituisce il valore restituito come un temporaneo

template <class T> 
class TypedReturnValueHolder : public ReturnValueHolder { 
public: 
    virtual T rv() = 0; 
}; 

e modificare l'originale ReturnValueHolder

template <class T> 
class ReturnValueWrapper : public ReturnValueHolder { 
public: 
typename no_cref<T>::type rv; 
ReturnValueWrapper(T rv) : rv(rv) {} 
}; 

ereditare da e implementare l'interfaccia derivata.

template <class T> 
class ReturnValueWrapper : public TypedReturnValueHolder<T> { 
    typename no_cref<T>::type prv; 
public: 
    ReturnValueWrapper(T rv) : prv(rv) {} 
    virtual T rv() { return prv; }; 
}; 

Una volta che è stato fatto, il ritorno da DoExpectation può essere scritta come

 if (call->retVal) 
      return ((TypedReturnValueHolder<Z> *)call->retVal)->rv(); 

L'esempio dalla domanda quando riscritto per utilizzare Do

mocks.OnCall(foo, IFoo::foo) 
    .Do([](){ return std::unique_ptr<IFoo>(); }); 

quindi compila e viene eseguito come previsto.