Présentation de DUnit

De RAD Studio
Aller à : navigation, rechercher

Remonter à Test des applications - Index

Attention: N'oubliez pas que DUnit ne prend pas en charge l'interface utilisateur graphique de FireMonkey pour visualiser votre sortie ; utilisez à la place DUnitX.
Remarque: DUnitX utilise des fonctionnalités du langage Delphi qui ne sont pas prises en charge dans C++. Pour les développeurs C++, DUnit est le meilleur outil. C++ peut également être testé à l'aide d'autres frameworks comme Google Test, disponible via le Gestionnaire de packages GetIt.

DUnit est un framework de test unitaire open-source basé sur le framework de test JUnit. Le framework DUnit vous permet de construire et d'exécuter des tests sur des applications Delphi Win32. L'intégration du framework DUnit dans RAD Studio vous permet de développer et d'exécuter des tests sur des applications Delphi Win32 et C++Builder.

Le framework de test DUnit propose son propre ensemble de méthodes pour les conditions de test. Les méthodes représentent des assertions communes. Vous pouvez également créer vos propres assertions personnalisées. Vous pouvez utiliser les méthodes proposées pour tester un grand nombre de conditions.

Voir également la page d'accueil DUnit sur http://dunit.sourceforge.net/

Installation de DUnit

Pour installer la fonctionnalité DUnit, procédez comme suit :

  1. Sélectionnez Outils > Gérer les plates-formes pour ouvrir le Gestionnaire de fonctionnalités.
  2. Sur l'onglet Autres options, cochez la fonctionnalité Frameworks de test unitaire DUnit pour l'ajouter à votre installation de RAD Studio.
  3. Sélectionnez Appliquer pour appliquer les modifications sélectionnées.

Une fois les modifications appliquées, le Gestionnaire de fonctionnalités affiche un écran Opération terminée.

Développement de tests DUnit Delphi

Chaque test DUnit implémente une classe de type TTestCase.

L'exemple suivant de programme Delphi Win32 définit deux fonctions qui effectuent une simple addition et soustraction :

 unit CalcUnit;
 
 interface
 
 type
 
 { TCalc }
 
   TCalc = class
   public
     function Add(x, y: Integer): Integer;
     function Sub(x, y: Integer): Integer;
   end;
 
 implementation
 
 { TCalc }
 
 function TCalc.Add(x, y: Integer): Integer;
 begin
   Result := x + y;
 end;
 
 function TCalc.Sub(X, Y: Integer): Integer;
 begin
   Result := x - y;
 end;
 
 end.

L'exemple suivant montre le fichier squelette des cas de test qu'il est nécessaire de modifier pour tester les deux fonctions, Add et Sub, du code précédent.

 unit TestCalcUnit;
 
 interface
 
 uses
   TestFramework, CalcUnit;
 type
   // Test methods for class TCalc
   TestTCalc = class(TTestCase)
   strict private
     aTCalc: TCalc;
   public
     procedure SetUp; override;
     procedure TearDown; override;
   published
     procedure TestAdd;
     procedure TestSub;
   end;
 
 implementation
 
 procedure TestTCalc.SetUp;
 begin
   aTCalc := TCalc.Create;
 end;
 
 procedure TestTCalc.TearDown;
 begin
   aTCalc := nil;
 end;
 
 procedure TestTCalc.TestAdd;
 var
   _result: System.Integer;
   y: System.Integer;
   x: System.Integer;
 begin
   _result := aTCalc.Add(x, y);
   // TODO: Add testcode here
 end;
 
 procedure TestTCalc.TestSub;
 var
   _result: System.Integer;
   y: System.Integer;
   x: System.Integer;
 begin
   _result := aTCalc.Sub(x, y);
   // TODO: Add testcode here
 end;
 
 initialisation
   // Register any test cases with the test runner
   RegisterTest(TestTCalc.Suite);
 end.

Développement de tests DUnit C++

Chaque test DUnit implémente une classe de type TTestCase.

L'exemple suivant (programme et fichier d'en-tête C++ Win32) définit deux fonctions qui effectuent une simple addition et soustraction :

 #ifndef Unit7H
 #define Unit7H
 //-------------------------------------------------
 
 
 class TCalc
 {
 public:
   int Add(int x, int y);
   int Sub(int x, int y);
 };
 
 
 #endif

L'exemple suivant (TestUnit7.cpp) contient un cas de test pour la classe TCalc. L'expert a généré cet exemple, mais l'utilisateur devrait écrire des tests à titre d'exercice des fonctions Add et Sub. L'exemple illustre la structure DUnit des tests unitaires.

 #include <vcl.h>
 #pragma hdrstop
 
 #include <TestFramework.hpp>
 
 class TTestTCalc : public TTestCase
 {
 public:
   __fastcall virtual TTestTCalc(AnsiString name) : TTestCase(name) {}
   virtual void __fastcall SetUp();
   virtual void __fastcall TearDown();
 
 __published:
   void __fastcall TestAdd();
   void __fastcall TestSub();
 };
 
 
 void __fastcall TTestTCalc::SetUp()
 {
 }
 
 void __fastcall TTestTCalc::TearDown()
 {
 }
 
 void __fastcall TTestTCalc::TestAdd()
 {
   // int Add(int x, int y)
 }
 
 void __fastcall TTestTCalc::TestSub()
 {
   // int Sub(int x, int y)
 }
 
 
 static void registerTests()
 {
   _di_ITestSuite iSuite;
   TTestSuite* testSuite = new TTestSuite("Testing Unit7.h");
   if (testSuite->GetInterface(iSuite)) {
     testSuite->AddTests(__classid(TTestTCalc));
     Testframework::RegisterTest(iSuite);
   } else {
     delete testSuite;
   }
 }
 #pragma startup registerTests 33

Fonctions DUnit

DUnit fournit un certain nombre de fonctions utilisables dans vos tests.

Fonction Description

Check

Vérifie si une condition a été rencontrée.

CheckEquals

Vérifie si deux éléments sont égaux.

CheckNotEquals

Vérifie si les éléments ne sont pas égaux.

CheckNotNull

Vérifie si un élément n'est pas null.

CheckNull

Vérifie si un élément est null.

CheckSame

Vérifie si deux éléments ont la même valeur.

EqualsErrorMessage

Vérifie si un message d'erreur émis par l'application correspond à un message d'erreur spécifié.

Fail

Vérifie si une routine échoue.

FailEquals

Vérifie si un échec correspond à une condition d'échec spécifiée.

FailNotEquals

Vérifie si une condition d'échec est différente d'une condition d'échec spécifiée.

FailNotSame

Vérifie si deux conditions d'échec ne sont pas identiques.

NotEqualsErrorMessage

Vérifie si deux messages d'erreur ne sont pas identiques.

NotSameErrorMessage

Vérifie si un message d'erreur ne correspond pas à un message d'erreur spécifié.

Pour plus d'informations sur la syntaxe et l'utilisation de ces fonctions et des autres fonctions DUnit, voir les fichiers d'aide DUnit dans \source\dunit\doc (EN).

Lanceurs de tests DUnit.

Un lanceur de test vous permet d'exécuter vos tests indépendamment de votre application. Dans un projet test DUnit, le code du lanceur de test du framework DUnit est directement compilé dans l'exécutable généré, transformant ainsi le projet test lui-même en lanceur de test. Le framework DUnit intégré fournit deux lanceurs de tests :

  • Le lanceur de test en mode GUI. Affiche les résultats de test de manière interactive dans une fenêtre de l'interface utilisateur graphique, avec les résultats codés en couleur indiquant la réussite ou l'échec des tests.
  • Le lanceur de test en mode console. Oriente la sortie des tests vers la console.

Le lanceur de test DUnit en mode GUI est très utile pour développer de manière interactive les tests unitaires pour le code testé. Le lanceur de test DUnit en mode GUI affiche une barre verte sur un test qui s'est terminé avec succès, une barre rouge sur un test qui a échoué et une barre jaune sur un test qui a été ignoré.

Le lanceur de test DUnit en mode console est utile lorsque vous voulez exécuter du code achevé et des tests à partir de scripts construits de manière automatisée.

Voir aussi