gmock setting default actions / on CALL vs. EXPECT CALL

Je ne comprends pas la différence entre ON_CALL et EXPECT_CALL quand je l'utilise pour spécifier l'action par défaut.

Jusqu'à présent j'ai remarqué / appris qu'il y a deux façons d'ajuster l'action par défaut d'une simulation:

ON_CALL(mock, methodX(_)).WillByDefault(Return(0x01));

ou

EXPECT_CALL(mock, methodX(_)).WillRepeatedly(Return(0x01));

quelqu'un Pourrait-il m'expliquer:

  • La différence entre les deux méthodes
  • les hauts et Les bas de chacun
  • Quand est-il approprié de les utiliser (ce genre de configuration ...)
33
demandé sur isaac_ngl 2012-12-18 16:52:41

2 réponses

il y a des différences subtiles mais significatives entre les deux énoncés. EXPECT_CALL définit l'attente sur un appel simulé. Écrit

EXPECT_CALL(mock, methodX(_)).WillRepeatedly(do_action);

dit à gMock que methodX peut être appelée mock n'importe quel nombre de fois avec des arguments, et quand il l'est, mock exécuter do_action. D'autre part, 

ON_CALL(mock, methodX(_)).WillByDefault(do_action);

dit à gMock que chaque fois que methodX est appelée sur mock, il doit procéder à do_action. Cette fonctionnalité est utile dans un scénario où vous avez à écrivez beaucoup d'attentes sur votre mock, et la plupart / tous doivent spécifier la même action -- surtout si c'est complexe. Vous pouvez spécifier cette action dans ON_CALL, et puis écrire EXPECT_CALL s sans spécifier explicitement l'action. E. g.,

ON_CALL(mock, Sign(Eq(0), _))
  .WillByDefault(DoAll(SetArgPointee<1>("argument is zero"), Return(0)));
ON_CALL(mock, Sign(Gt(0), _))
  .WillByDefault(DoAll(SetArgPointee<1>("argument is positive"), Return(1)));
ON_CALL(mock, Sign(Lt(0), _))
  .WillByDefault(DoAll(SetArgPointee<1>("argument is negative"), Return(-1)));

maintenant, si vous devez écrire beaucoup de EXPECT_CALLs, vous n'avez pas à mock ' s spécifiez le comportement à chaque fois:

EXPECT_CALL(mock, Sign(-4, _));
EXPECT_CALL(mock, Sign(0, _));
EXPECT_CALL(mock, Sign(1, _)).Times(2);
EXPECT_CALL(mock, Sign(2, _));
EXPECT_CALL(mock, Sign(3, _));
EXPECT_CALL(mock, Sign(5, _));

dans un autre exemple, en supposant que le signe retourne int si vous Ecrire

ON_CALL(mock, Sign(Gt(0), _)).WillByDefault(Return(1));
EXPECT_CALL(mock, Sign(10, _));

l'appel mock.Sign(10) retourne 1 ON_CALL fournit comportement par défaut pour un appel spécifié par EXPECT_CALL. Mais si vous écrivez

EXPECT_CALL(mock, Sign(Gt(0), _).WillRepeatedly(Return(1));
EXPECT_CALL(mock, Sign(10, _));

l'invocation de mock.Sign(10, p) renvoie 0. Il sera comparé à la deuxième attente. Cette attente ne spécifie aucune action explicite et gMock générera une action par défaut pour elle. Que l'action par défaut est de retourner une valeur par défaut du type de retour, qui est 0 int. La première attente sera être totalement ignoré dans ce cas.

37
répondu VladLosev 2012-12-19 17:40:35 
ON_CALL(mock, methodX(_)).WillByDefault(Return(0x01));
EXPECT_CALL(mock, methodX(_)).WillRepeatedly(Return(0x01));

comme vous l'avez dit, ces deux lignes font exactement la même chose, donc il n'y a aucune différence. Utilisez l'une ou l'autre des méthodes pour définir une action par défaut comme vous le souhaitez.

cependant, il y a une différence logique:

  • ON_CALL(mock, methodX(_)).WillByDefault(Return(0x01)); signifie que la méthode pourrait être appelée, et si cela arrive, chaque appel retournera 0x01
  • EXPECT_CALL(mock, methodX(_)).WillRepeatedly(Return(0x01)); signifie que l'on s'attend à ce que la méthode soit appelée, et chaque appel retournera 0x01

Par ailleurs, il y a un définition des actions par défaut dans leur antisèche, qui dit:

pour personnaliser l'action par défaut pour une méthode particulière, utilisez ON_CALL ():

ON_CALL(mock_object, method(matchers))
    .With(multi_argument_matcher)  ?
    .WillByDefault(action);
8
répondu BЈовић 2012-12-18 21:16:14