Évitez de faire correspondre plusieurs fois .WillOnce dans Google Mock

J'ai une maquette de l'objet de configuration qui ressemble à ceci:

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

Est-il un moyen pour ne pas avoir à répéter .WillOnce(Return(1)) trois fois?

source d'informationauteur UXkQEZ7

  1. 24
    using testing::InSequence;

MyObject obj;

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

    À des fins d'exhaustivité, il y a un autre standard/option simple, si l'on a accepté la réponse semble claire dans ce cas.

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

    Cela peut être utile si vous savez ce que vous voulez que votre dernier/réponse par défaut (-1), mais envie de coucher avec le nombre de fois qu'elle est appelée avant.

  3. 0

    J'ai peur, il n'y a pas d'autre moyen de configurer ce comportement. Ne pouvez pas trouver un moyen évident de la documentation au moins.

    Vous aurez peut sortir de ce problème en introduisant un approprié défini par l'utilisateur matcher bien, qui garde la trace d'un appel de comte et de seuil que vous pouvez fournir à partir de votre cas de tests via les paramètres de modèle (ne sais pas vraiment comment provoquer la ResultType automatiquement 🙁 ):

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

    Utilisation puis de s'attendre à un certainement compté résultat de l'appel:

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

    NOTE

    Je n'ai pas vérifier ce code fonctionne comme prévu, mais il devrait vous guider dans la bonne direction.