googlemock EXPECT_CALL avec de petites variations de comportement

Question

Avec l'aide de googlemock et googletest, j'ai mis en place un test qui vérifie que les différentes erreurs de moquerie sont correctement traitées par la méthode testée. Fondamentalement, mon code ressemble à ceci:

// setup mock object, and object under test 

    // setup initial EXPECT_CALL expectations 

    // this expected method call in the middle mocks a failure 
    EXPECT_CALL(*mock, method(arg_in)). 
    Times(1). 
    WillOnce(Throw(exception_of_type_A)); 

    // setup cleanup EXPECT_CALL expectations 

    // Now invoke method in object under test. 
    // Expect exception has been translated to different type. 
    EXPECT_THROW(x.method_under_test(), exception_type_B); 

    // destructor of mock object will check the mock method invocations 

Maintenant, ma méthode raillé qui ne ici peut non seulement échouer en lançant une exception de type A, mais aussi en lançant une exception de type B, ou en retournant une valeur de retour inattendu .

Je peux implémenter ceci assez facilement en copiant et en collant le TEST complet() et en changeant juste ce que fera la méthode mockée mal conduite1. Mais cela rendra le code désordonné. Même si je documente que ces 3 tests sont exactement les mêmes, sauf pour la façon dont la méthode mocked1 échoue dans la spécification d'action WillOnce(), un lecteur humain devrait encore comparer avec soin si cela est toujours vrai.

Quelle serait la bonne façon dans googletest/googlemock de partager le code commun entre les trois TESTS et de les faire différer dans l'action WillOnce()? À mon avis, il y a des macros, des boucles sur un conteneur avec des actions de WillOnce(), des appareils Googletest, des méthodes statiques pour l'installation et le nettoyage. Je suis toujours nouveau à googletest et je ne sais pas comment résoudre ce problème.

Answer 1

Pour l'instant, je mets en œuvre la logique de test dans une fonction statique basé sur un modèle qui accepte une action en tant que paramètre:

template <typename A> 
static void paramererizeable_test(A failingAction) { 
    // set everything up 
    EXPECT_CALL(*mock, method(arg_in)). 
    Times(1). 
    WillOnce(failingAction); 
    // set up more expectations 
    // trigger the calls 
} 

TEST(Section, Method) { 
    paramererizeable_test(Throw(exception_of_type_A)); 
    paramererizeable_test(Throw(exception_of_type_B)); 
    paramererizeable_test(Return(unexpected_return_value)); 
} 

Je ne sais pas si cela est la façon dont il doit être fait, ou s'il y a une meilleure façon , mais cela fonctionne et est lisible.