Présentation de DUnit
Remonter à Test des applications - Index
- Avertissement : DUnit étant obsolète, il ne sera donc pas amélioré. Vous ne devriez pas entreprendre de nouveaux développements avec DUnit. Prévoyez plutôt de migrer vos tests existants de DUnit vers DUnitX. Voir Présentation de DUnitX.
- Avertissement : N'oubliez pas que DUnit ne prend pas en charge l'interface utilisateur graphique de FireMonkey pour visualiser votre sortie ; utilisez à la place DUnitX.
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/ (EN)
Sommaire
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.