Comment tester l'ordre des appels de fonction

StackOverflow https://stackoverflow.com/questions/78723

  •  09-06-2019
  •  | 
  •  

Question

Considérant un tel code: 

class ToBeTested {
public:
  void doForEach() {
    for (vector<Contained>::iterator it = m_contained.begin(); it != m_contained.end(); it++) {
       doOnce(*it);
       doTwice(*it);
       doTwice(*it);
    }
  }
  void doOnce(Contained & c) {
    // do something
  }
  void doTwice(Contained & c) {
    // do something
  }

  // other methods
private:
  vector<Contained> m_contained;
}

Je veux vérifier que si je remplis le vecteur avec 3 valeurs, mes fonctions seront appelées dans le bon ordre et en quantité appropriée. Par exemple, mon test peut ressembler à quelque chose comme ça: 

tobeTested.AddContained(one);
tobeTested.AddContained(two);
tobeTested.AddContained(three);

BEGIN_PROC_TEST()
SHOULD_BE_CALLED(doOnce, 1)
SHOULD_BE_CALLED(doTwice, 2)
SHOULD_BE_CALLED(doOnce, 1)
SHOULD_BE_CALLED(doTwice, 2)
SHOULD_BE_CALLED(doOnce, 1)
SHOULD_BE_CALLED(doTwice, 2)

tobeTested.doForEach()
END_PROC_TEST()

Comment recommandez-vous de tester cela? Y a-t-il un moyen de faire cela avec les frameworks CppUnit ou GoogleTest? Peut-être qu'un autre framework de tests unitaires permettra de réaliser de tels tests?

Je comprends que cela est probablement impossible sans appeler des fonctions de débogage à partir de ces fonctions, mais au moins cela peut-il être fait automatiquement dans un cadre de test. Je n'aime pas analyser les journaux de trace et vérifier leur exactitude.

UPD : j'essaie de vérifier non seulement le état d'un objet, mais également le ordre d'exécution pour éviter les problèmes de performances sur le plus tôt possible (et en général, je veux savoir que mon code est exécuté exactement comme prévu).

Était-ce utile?

La solution

Si les performances vous intéressent, je vous recommande de rédiger un test mesurant les performances.

Vérifiez l'heure actuelle, exécutez la méthode qui vous intéresse, puis vérifiez à nouveau l'heure. Affirmez que le temps total pris est inférieur à une valeur.

Le problème avec le fait de vérifier que les méthodes sont appelées dans un certain ordre est que votre code va devoir changer, et vous ne voulez pas avoir à mettre à jour vos tests lorsque cela se produit. Vous devez vous concentrer sur le test de la configuration requise au lieu de tester les détails de la mise en œuvre qui répondent à cette configuration.

Cela dit, si vous voulez vraiment vérifier que vos méthodes sont appelées dans un certain ordre, procédez comme suit:

  1. Déplacez-les dans une autre classe, appelez-le Collaborator
  2. Ajouter une instance de cette autre classe à la classe ToBeTested
  3. Utilisez un framework moqueur pour définir la variable d'instance sur ToBeTested comme un mock de la classe Collborator
  4. Appelez la méthode à tester
  5. Utilisez votre cadre moqueur pour affirmer que les méthodes ont été appelées sur votre maquette dans le bon ordre.

Je ne suis pas un locuteur natif de cpp, je ne peux donc pas vous dire quel cadre moqueur vous devriez utiliser, mais je vois que d'autres commentateurs ont ajouté leurs suggestions à cet égard.

Autres conseils

Vous pouvez consulter mockpp .

Vous devriez pouvoir utiliser n'importe quel bon cadre moqueur pour vérifier que les appels à un objet collaborant sont effectués dans un ordre spécifique.

Cependant, vous ne testez généralement pas qu'une méthode appelle des appels à d'autres méthodes de la même classe ... pourquoi voudriez-vous?

En règle générale, lorsque vous testez une classe, son seul intérêt est de tester son état visible publiquement. Si vous testez Dans tous les cas, vos tests vous empêcheront de refactoriser plus tard.

Je pourrais fournir davantage d'aide, mais je ne pense pas que votre exemple soit cohérent (Où est l'implémentation de la méthode AddContained?).

Au lieu d'essayer de savoir combien de fonctions ont été appelées et dans quel ordre, trouvez un ensemble d'entrées qui ne peuvent produire une sortie attendue que si vous appelez les choses dans le bon ordre.

Certains frameworks moqueurs vous permettent de définir des attentes ordonnées, ce qui vous permet de dire exactement quelle fonction vous appelez dans un certain ordre. Par exemple, RhinoMocks pour C # le permet.

Je ne suis pas un codeur C ++, je ne suis donc pas au courant de ce qui est disponible pour C ++, mais c'est un type d'outil qui pourrait permettre ce que vous essayez de faire.

http://msdn.microsoft.com/en-au/magazine /cc301356.aspx

Ceci est un bon article sur les objets liés au contexte. Il contient des éléments très avancés, mais si vous n’êtes pas fainéant et que vous voulez vraiment comprendre ce genre de choses, cela vous sera vraiment utile.

À la fin, vous pourrez écrire quelque chose comme: [CallTracingAttribute ()] Classe publique TraceMe: ContextBoundObject {...}

Vous pouvez utiliser des structures de débogage ACE (ou similaires) et, lors de votre test, configurer l’objet de débogage pour qu’il soit transféré dans un fichier. Ensuite, il vous suffit de vérifier le fichier.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top