Google finto ByRef metodo

Question

ho una classe che prende un valore booleano come parametro di riferimento e restituisce un numero intero:

class Foo 
{ 
    public: 
    Bar my_bar; 
    virtual int myMethod(bool &my_boolean) = 0; 
} 

/*...*/ 

int Foo::myMethod(bool &my_boolean){ 
    if (my_bar == NULL){ 
    my_boolean = false; 
    return -1; 
    } 
    else{ 
    my_boolean = true; 
    return 0; 
    } 

} 

e ho creato un mock per questa classe:

class MockFoo : public Foo 
{ 
    MOCK_METHOD1(myMethod,int(bool &my_boolean)); 
} 

Sono avendo problemi su come impostare le aspettative per questo tipo di funzione, perché ho bisogno di impostare il valore di ritorno e il parametro di riferimento su valori specifici per creare correttamente i miei test di unità. Come posso gestire questo tipo di funzione con gmock? Ho provato a seguire quello che pensavo w come la soluzione alla documentazione:

using ::testing::SetArgPointee; 

class MockMutator : public Mutator { 
    public: 
    MOCK_METHOD2(Mutate, void(bool mutate, int* value)); 
    ... 
}; 
    ... 

MockMutator mutator; 
EXPECT_CALL(mutator, Mutate(true, _)) 
    .WillOnce(SetArgPointee<1>(5)); 

Ma, o non ho capito l'esempio o non era applicabile per questo case.Has chiunque occupato whith questo tipo di situazione prima?

Grazie in anticipo.

Answer 1

La tua domanda è difficile da ottenere! Anche i campioni del "libro di cucina" di google mock sono così buoni.

Vuoi riutilizzare l'implementazione per Foo::myMethod() con la tua classe di simulazione o vuoi semplicemente prendere in giro gli effetti collaterali (valore restituito e modificato dai parametri ref) per situazioni di chiamata specifiche?

Una classe di simulazione è in genere pensata per sostituire/simulare la classe , non per ereditarla direttamente o per il suo comportamento. Non so se il modo in cui definisci questo comportamento "predefinito" per un metodo puro funzionerà, ma ne dubiti. Potresti semplicemente omettere lo = 0 allora. L'approccio migliore sarebbe quella di separare una dichiarazione di interfaccia reale come:

struct IFoo 
{ 
    virtual int myMethod(bool &my_boolean) = 0; 
    virtual ~IFoo() {} 
}; 

class Foo : public IFoo 
{ 
    // ... 
}; 

class MockFoo : public IFoo 
{ 
    MOCK_METHOD1(myMethod,int(bool &my_boolean)); 
}; 

Se avete quest'ultimo caso, si dovrebbe ottenere via con testing::Return(value) e testing::SetArgReferee<N>(value) (scoperto che nel molto utile 'Cheat Sheet').

La chiamata aspettativa dovrebbe essere simile a questo, allora:

MockFoo foo; 

// Expect call to myMethod() return -1 and set the by ref argument to true 
EXPECT_CALL(foo, myMethod(_)) 
    .WillOnce(DoAll(SetArgReferee<0>(true),Return(-1))); 

// Expect call to myMethod() return 0 and set the by ref argument to false 
EXPECT_CALL(foo, myMethod(_)) 
    .WillOnce(DoAll(SetArgReferee<0>(false),Return(0))); 

Se davvero si vuole riutilizzare la logica classi originale per myMethod() uno sguardo a 'Delegating calls to a parent class', resp. 'Delegating Calls to a Real Object'