Comment spécifier des retours consécutifs dans gmock?

Question

En Mockito nous pouvons spécifier plusieurs retours comme (extrait de here):

//you can set different behavior for consecutive method calls. 
//Last stubbing (e.g: thenReturn("foo")) determines the behavior of further consecutive calls. 
when(mock.someMethod("some arg")) 
    .thenReturn(new RuntimeException()) 
    .thenReturn("foo"); 

//There is a shorter way of consecutive stubbing: 
when(mock.someMethod()).thenReturn(1,2,3); 
when(mock.otherMethod()).thenThrow(exc1, exc2); 

est-il un moyen de spécifier plusieurs déclarations pour une maquette faite avec gmock? Actuellement j'ai:

store_mock_ = std::make_shared<StorageMock>(); 
ON_CALL(*store_mock_, getFileName(_)).Return("file1").Return("file2"); 

qui ne compile pas parce que je ne peux pas comprendre plusieurs retours dans gmock. Est-ce possible avec gmock? Sinon, existe-t-il un autre moyen de résoudre ce problème? J'ai trouvé que nous pouvons EXPECT plusieurs valeurs de retour comme:

using ::testing::Return;... 
EXPECT_CALL(turtle, GetX()) 
    .WillOnce(Return(100)) 
    .WillOnce(Return(200)) 
    .WillOnce(Return(300)); 

Cependant, je n'ai pas trouvé de documents pour se moquant des retours multiples avec ON_CALL.

Answer 1

ON_CALL est plus utilisé pour définir le comportement par défaut de la fonction. C'est à dire. vous savez que dans le code testé, la fonction simulée est appelée, vous voulez définir une valeur par défaut, mais ce n'est pas vraiment important combien de fois la fonction est appelée.

Le example:

ON_CALL(foo, Sign(_)) 
     .WillByDefault(Return(-1)); 
    ON_CALL(foo, Sign(0)) 
     .WillByDefault(Return(0)); 
    ON_CALL(foo, Sign(Gt(0))) 
     .WillByDefault(Return(1)); 

Pour obtenir votre comportement désiré j'utiliser expectations - vous avez déjà fourni quelques exemples en question, juste pour montrer plus - un exemple lorsque vous attendez 1, 2 alors toujours 3:

EXPECT_CALL(foo, Sign(_)) 
     .WillOnce(Return(1)) 
     .WillOnce(Return(2)) 
     .WillRepeatedly(Return(3)); 

EXPECT_CALL « voie » pourrait être gênant quand vous voulez configurer dans banc d'essai SetUp - et quelques essais m appelez le foo seulement une fois. Mais, bien sûr, il existe des moyens de « contrôler » la valeur ON_CALL de retour pour les prochains appels - mais vous devez le faire avec des actions spéciales - comme obtenir résultat d'une fonction - comme dans cet exemple:

class IDummy 
{ 
public: 
    virtual int foo() = 0; 
}; 

class DummyMock : public IDummy 
{ 
public: 
    MOCK_METHOD0(foo, int()); 
}; 
using namespace ::testing; 
class DummyTestSuite : public Test 
{ 
protected: 
    DummyMock dummy; 
    void SetUp() override 
    { 
     ON_CALL(dummy, foo()) 
      .WillByDefault(
       InvokeWithoutArgs(this, &DummyTestSuite::IncrementDummy)); 
    } 
    int dummyValue = 0; 
    int IncrementDummy() 
    { 
     return ++dummyValue; 
    } 

}; 


TEST_F(DummyTestSuite, aaa) 
{ 
    ASSERT_EQ(1, dummy.foo()); 
    ASSERT_EQ(2, dummy.foo()); 
    ASSERT_EQ(3, dummy.foo()); 

}