framework - c++ google test

Evita hacer coincidir. Saldrá varias veces en Google Mock

Question

Tengo una configuración de objeto simulada que se parece a esto:

MyObject obj;
EXPECT_CALL(obj, myFunction(_))
.WillOnce(Return(1))
.WillOnce(Return(1))
.WillOnce(Return(1))
.WillRepeatedly(Return(-1));

¿Hay alguna forma de no tener que repetir .WillOnce(Return(1)) tres veces?

Answer 1

Me temo que no hay otra forma de configurar este comportamiento. No se puede encontrar una forma obvia en la documentación al menos.

Sin embargo, es posible que evite este problema introduciendo un emparejador definido por el usuario adecuado, que realiza un seguimiento del conteo de llamadas y el umbral que puede proporcionar desde sus testcases a través de los parámetros de la plantilla (no se sabe cómo inducir el ResultType automáticamente :-() :

using ::testing::MakeMatcher;
using ::testing::Matcher;
using ::testing::MatcherInterface;
using ::testing::MatchResultListener;

template
    < unsigned int CallThreshold
    , typename ResultType
    , ResultType LowerRetValue
    , ResultType HigherRetValue
    >
class MyCountingReturnMatcher 
: public MatcherInterface<ResultType>
{
public:
    MyCountingReturnMatcher()
    : callCount(0)
    {
    }

    virtual bool MatchAndExplain
        ( ResultType n
        , MatchResultListener* listener
        ) const 
    {
        ++callCount;
        if(callCount <= CallThreshold)
        {
            return n == LowerRetValue;
        }

        return n == HigherRetValue;
    }

    virtual void DescribeTo(::std::ostream* os) const 
    {
        if(callCount <= CallThreshold)
        {
            *os << "returned " << LowerRetValue;
        }
        else
        {
            *os << "returned " << HigherRetValue;
        }
    }

    virtual void DescribeNegationTo(::std::ostream* os) const 
    {
        *os << " didn''t return expected value ";
        if(callCount <= CallThreshold)
        {
            *os << "didn''t return expected " << LowerRetValue 
                << " at call #" << callCount;
        }
        else
        {
            *os << "didn''t return expected " << HigherRetValue 
                << " at call #" << callCount;
        }
    }

private:
    unsigned int callCount;
};

template
    < unsigned int CallThreshold
    , typename ResultType
    , ResultType LowerRetValue
    , ResultType HigherRetValue
    >
inline Matcher<ResultType> MyCountingReturnMatcher() 
{
    return MakeMatcher
               ( new MyCountingReturnMatcher
                    < ResultType
                    , CallThreshold 
                    , ResultType
                    , LowerRetValue
                    , HigherRetValue
                    >()
               );
}

Use entonces para esperar un resultado de llamada ciertamente contado:

EXPECT_CALL(blah,method)
   .WillRepeatedly(MyCountingReturnMatcher<1000,int,1,-1>()) // Checks that method
                                                             // returns 1000 times 1
                                                             // but -1 on subsequent 
                                                             // calls.

NOTA
No he comprobado que este código funcione correctamente, pero debería guiarlo en la dirección correcta.

Answer 2

Para completar, hay otra opción estándar / simple, aunque la respuesta aceptada parece más clara en este caso.

EXPECT_CALL(obj, myFunction(_)).WillRepeatedly(Return(-1));
EXPECT_CALL(obj, myFunction(_)).Times(3).WillRepeatedly(Return(1)).RetiresOnSaturation();

Esto puede ser útil si sabe cuál quiere que sea su última respuesta predeterminada ( -1 ), pero desea eliminar el número de veces que se llama antes de esa fecha.

Answer 3

using testing::InSequence;

MyObject obj;

{
  InSequence s;
  EXPECT_CALL(obj, myFunction(_))
      .Times(3)
      .WillRepeatedly(Return(1));
  EXPECT_CALL(obj, myFunction(_))
      .WillRepeatedly(Return(-1));
}