c++ - google - gmock que establece las acciones predeterminadas/ON_CALL vs. EXPECT_CALL

c++ testing

Question

No entiendo la diferencia entre ON_CALL y EXPECT_CALL cuando se usa para especificar la acción predeterminada.

Hasta ahora noté / aprendí que hay dos formas de ajustar la acción predeterminada de un simulacro:

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

o

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

¿Podría alguien explicarme:

• La diferencia entre los dos métodos
• Los altibajos de cada uno
• Cuándo es apropiado usarlos (qué tipo de configuración ...)

Answer 1

Hay diferencias sutiles pero significativas entre las dos declaraciones. EXPECT_CALL establece la expectativa en un simulacro de llamadas. Escritura

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

le dice a gMock que el methodX puede methodX en mock varias veces con cualquier argumento, y cuando lo es, mock realizará do_action . Por otra parte,

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

le dice a gMock que cada methodX se invoca methodX en el mock , debe realizar do_action . Esa característica es útil en un escenario donde tiene que escribir muchas expectativas en su simulacro, y la mayoría de ellos tienen que especificar la misma acción, especialmente si es compleja. Puede especificar esa acción en ON_CALL y luego escribir EXPECT_CALL s sin especificar la acción explícitamente. P.ej,

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)));

Ahora, si tiene que escribir muchas EXPECT_CALL s, no tiene que EXPECT_CALL el comportamiento de cada vez:

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, _));

En otro ejemplo, suponiendo que Sign devuelve int , si escribe

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

el mock.Sign(10) llamada. El mock.Sign(10) devolverá 1 ya que ON_CALL proporciona un comportamiento predeterminado para una llamada especificada por EXPECT_CALL . Pero si escribes

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

la invocación de mock.Sign(10, p) devolverá 0. Se comparará con la segunda expectativa. Esa expectativa no especifica acción explícita y gMock generará una acción predeterminada para ella. Esa acción predeterminada es devolver un valor predeterminado del tipo de devolución, que es 0 para int . La primera expectativa será totalmente ignorada en este caso.

Answer 2

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

Como dijiste, estas dos líneas están haciendo exactamente lo mismo, por lo tanto, no hay diferencias en absoluto. Use de cualquier manera para establecer una acción predeterminada como lo desee.

Sin embargo, hay una diferencia lógica:

• ON_CALL(mock, methodX(_)).WillByDefault(Return(0x01)); significa que se puede llamar al método, y si eso sucede, cada llamada devolverá 0x01
• EXPECT_CALL(mock, methodX(_)).WillRepeatedly(Return(0x01)); significa que se espera que se llame al método, y cada llamada devolverá 0x01

Por cierto, hay una configuración de acciones predeterminadas en su hoja de trucos, que dice:

Para personalizar la acción predeterminada para un método en particular, use ON_CALL ():

ON_CALL(mock_object, method(matchers))
    .With(multi_argument_matcher)  ?
    .WillByDefault(action);