Présentation de DUnitX

Remonter à Test des applications - Index

DUnitX est un framework de test unitaire, en code source libre, basé sur le framework de test NUnit, incluant également certains concepts de xUnit. L'intégration du framework DUnitX dans RAD Studio vous permet de développer et d'exécuter des tests pour Win32, Win 64 et MacOSX dans les applications Delphi et C++Builder.

Chaque framework de test DunitX propose son propre ensemble de méthodes pour les conditions de test. Vous pouvez utiliser les méthodes proposées pour tester un grand nombre de conditions. Ces méthodes représentent des assertions communes bien que vous puissiez créer vos propres assertions personnalisées.

DUnitX utilise les méthodes génériques et anonymes. DUnitX utilise des attributs sous la personnalité Delphi. Dans C++Builder, DUnitX utilise des méthodes publiées.

Voir également la page d'accueil de DUnitX à l'adresse https://github.com/VSoftTechnologies/DUnitX/wiki (EN).

Développement de tests DUnitX Delphi

L'exemple suivant de programme Delphi définit deux fonctions qui effectuent de simples additions et soustractions :

 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 l'unité de test que vous devez modifier pour tester les deux fonctions. Vous devez ajouter du code aux méthodes SetUp et TearDown ainsi qu'aux méthodes de test TestAdd et TestSub. Enfin, utilisez des attributs pour tester les fonctions.

unit TestCalcUnit;

interface
uses
  DUnitX.TestFramework, CalcUnit;

type

  [TestFixture]
  TestTCalc = class(TObject)
  strict private
    aTCalc: TCalc;
  public
    [Setup]
    procedure Setup;
    [TearDown]
    procedure TearDown;
    // Sample Methods
    // Test with TestCase Atribute to supply parameters.
    [TestCase('TestA','8,2,10')]
    procedure TestAdd(Value1, Value2, _Result: Integer);
    // Test with TestCase Atribute to supply parameters.
    [TestCase('TestB','3,4,-1')]
    procedure TestSub(Value1, Value2, _Result: Integer);
  end;

implementation

procedure TestTCalc.Setup;
begin
  aTCalc := TCalc.Create;
end;

procedure TestTCalc.TearDown;
begin
  aTCalc := nil;
end;

procedure TestTCalc.TestAdd(Value1, Value2, _Result: Integer);
var
  R: Integer;
begin
  R := aTCalc.Add(Value1, Value2);
  Assert.AreEqual(R, _Result);   // testcode
end;

procedure TestTCalc.TestSub(Value1, Value2, _Result: Integer);
var
  R: Integer;
begin
  R := aTCalc.Sub(Value1, Value2);
  Assert.AreEqual(R, _Result);  // testcode
 end;

initialization
  TDUnitX.RegisterTestFixture(TestTCalc);
end.

Développement de tests DUnitX C++

L'exemple suivant de programme C++Builder définit deux fonctions qui effectuent de simples additions et soustractions :

class TCalc
{
	 public:
	 int Add(int x,int y);
	 int Sub(int x,int y);
};

int TCalc::Add(int x, int y)
{
	 int Result = x + y;
	 return Result;
}

int TCalc::Sub(int x, int y)
{
	 int Result = x-y;
	 return Result;
}

L'exemple suivant montre l'unité de test que vous devez modifier pour tester les deux fonctions. Vous devez ajouter du code aux méthodes SetUp et TearDown ainsi qu'aux méthodes de test TestAdd et TestSub.

#include <DUnitX.TestFramework.hpp>
#include <stdio.h>

#pragma option --xrtti

class __declspec(delphirtti) TestCalc : public TObject
{
public:
  virtual void __fastcall SetUp();
  virtual void __fastcall TearDown();

__published:
  void __fastcall TestAdd();
  void __fastcall TestSub();
};

TCalc *aTCalc;

void __fastcall TestCalc::SetUp()
{
	aTCalc = new TCalc();
}

void __fastcall TestCalc::TearDown()
{
	delete aTCalc;
}

void __fastcall TestCalc::TestAdd()
{
  int R;
  R = aTCalc->Add(2, 8);
  Assert::AreEqual(R, 10);
}

void __fastcall TestCalc::TestSub()
{
  int R;
  R = aTCalc->Add(3, 4);
  Assert::AreEqual(R, -1);
}

static void registerTests()
{
  TDUnitX::RegisterTestFixture(__classid(TestCalc));
}
#pragma startup registerTests 33

Fonctions DUnitX

DUnitX fournit une classe Assert avec un nombre de fonctions que vous pouvez utiliser dans vos tests.

Le tableau présente certaines de ces fonctions.

Fonction	Description
Pass	Vérifie si une routine fonctionne.
Fail	Vérifie si une routine échoue.
AreEqual	Vérifie si les éléments sont égaux.
AreNotEqual	Vérifie si les éléments ne sont pas égaux.
AreSame	Vérifie si deux éléments ont la même valeur.
AreNotSame	Vérifie si deux éléments n'ont pas la même valeur.
Contains	Vérifie si l'élément est dans une liste.
DoesNotContain	Vérifie si l'élément n'est pas dans une liste.
IsTrue	Vérifie si une condition est vraie.
IsFalse	Vérifie si une condition est fausse.
IsEmpty	Vérifie si la valeur d'un élément est vide.
IsNotEmpty	Vérifie si la valeur d'un élément n'est pas vide.
IsNull	Vérifie si un élément est null.
IsNotNull	Vérifie si un élément n'est pas null.
WillRaise	Vérifie si la méthode déclenchera une exception.
StartsWith	Vérifie si une chaîne débute avec une sous-chaîne spécifiée.
InheritsFrom	Vérifie si une classe est descendante d'une classe spécifiée.
IsMatch	Vérifie si l'élément correspond à un modèle spécifié.

Pour plus d'informations sur la syntaxe et l'utilisation de ces fonctions et des autres fonctions DUnitX, voir les fichiers d'aide DUnitX dans \source\DUnitX.

Lanceurs de tests DUnitX

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

• Le lanceur de test Console :
  • Envoie toutes les sorties de test vers la console. C'est le mode de test par défaut lorsque vous exécutez votre projet DUnitX. Le framework DUnitX fournit la classe TDUnitXConsoleLogger pour envoyer les sorties de test vers la console.
  • Est utile lorsque vous voulez exécuter du code achevé et des tests à partir de scripts construits de manière automatisée.

• Le lanceur de test en mode GUI :
  • Affiche les résultats de test interactivement dans une fenêtre de la GUI (une pour FireMonkey et une pour la VCL). Le framework DUnitX fournit une classe TGUIXTestRunner pour générer les sorties de la GUI de FireMonkey et une classe TDUnitXGuiLoggerForm pour la GUI de la VCL.
  • Est très utile pour développer de manière interactive les tests unitaires pour le code testé.

Voir aussi

• Comment convertir les tests DUnit en DUnitX

• Développement de tests avec DUnitX
• DUnitX source and contributions (EN)