Überblick über DUnit

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Anwendungen testen - Index

Achtung: Beachten Sie, dass DUnit zum Anzeigen Ihrer Ausgabe die FireMonkey-GUI nicht unterstützt. Verwenden Sie stattdessen DUnitX.
Hinweis: DUnitX verwendet Delphi-Sprachfeatures, die in C++ nicht unterstützt werden. Für C++-Entwickler ist DUnit das geeignetere Tool. C++ kann auch mit anderen Frameworks getestet werden, beispielsweise mit Google Test, das über den GetIt-Package-Manager verfügbar ist.

DUnit ist ein Open Source Test-Framework, das auf JUnit basiert. Mit DUnit können Tests für Delphi-Win32-Anwendungen erstellt und ausgeführt werden. Mit der RAD Studio-Integration des DUnit-Frameworks können Sie Tests für Delphi-Win32- und C++Builder-Anwendungen entwickeln und ausführen.

Jedes DUnit-Framework verfügt über eigene Methoden für das Testen von Bedingungen. Die Methoden entsprechen gebräuchlichen Annahmen. Sie können auch eigene Annahmen erstellen. Mit den bereitgestellten Methoden kann eine große Anzahl von Bedingungen getestet werden.

Siehe auch die DUnit-Homepage unter http://dunit.sourceforge.net/ (EN)

Installieren von DUnit

Führen Sie diese Schritte aus, um das DUnit-Feature zu installieren:

  1. Wählen Sie Tools > Plattformen verwalten, um den Feature-Manager zu öffnen.
  2. Aktivieren Sie auf der Registerkarte Weitere Optionen das Feature "DUnit Test-Frameworks", um es Ihrer RAD Studio-Installation hinzuzufügen.
  3. Klicken Sie zur Übernahme der ausgewählten Änderungen auf Übernehmen.

Nachdem die Änderungen übernommen wurden, wird im Feature-Manager die Meldung Vorgang beendet angezeigt.

Entwickeln von DUnit-Tests für Delphi

Jeder DUnit-Test implementiert eine Klasse mit dem Typ TTestCase.

Das folgende Delphi-Win32-Beispielprogramm definiert zwei Funktionen, die eine einfache Addition und Subtraktion durchführen:

 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.

Das folgende Beispiel zeigt die Testfall-Skeleton-Datei, die Sie ändern müssen, um die zwei Funktionen Add und Sub zu testen.

 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.

Entwickeln von DUnit-Tests für C++

Jeder DUnit-Test implementiert eine Klasse mit dem Typ TTestCase.

Die folgende C++-Win32-Header-Datei und das Beispielprogramm definieren zwei Funktionen, die eine einfache Addition und Subtraktion durchführen:

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

Das folgende Beispiel (TestUnit7.cpp) enthält einen Testfall für die Klasse TCalc. Dieses Beispiel wurde vom Experten generiert, aber vom Benutzer wird erwartet, dass er Tests zum Überprüfen der Funktionen Add und Sub schreibt. Das Beispiel illustriert das DUnit-Gerüst für Unit-Tests.

 #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

DUnit-Funktionen

DUnit stellt eine Reihe von Funktionen bereit, die Sie in Ihren Tests verwenden können.

Funktion Beschreibung

Check

Prüft, ob eine Bedingung erfüllt wird.

CheckEquals

Prüft, ob zwei Elemente gleich sind.

CheckNotEquals

Prüft, ob zwei Elemente ungleich sind.

CheckNotNull

Prüft, ob ein Element ungleich null ist.

CheckNull

Prüft, ob ein Element null ist.

CheckSame

Prüft, ob zwei Elemente den gleichen Wert haben.

EqualsErrorMessage

Prüft, ob eine von der Anwendung ausgegebene Fehlermeldung mit einer bestimmten Fehlermeldung übereinstimmt.

Fail

Prüft, ob eine Routine fehlschlägt.

FailEquals

Prüft, ob ein Fehler einer bestimmten Fehlerbedingung entspricht.

FailNotEquals

Prüft, ob ein Fehler einer bestimmten Fehlerbedingung nicht entspricht.

FailNotSame

Prüft, ob zwei Fehlerbedingungen identisch sind.

NotEqualsErrorMessage

Prüft, ob zwei Fehlermeldungen identisch sind.

NotSameErrorMessage

Prüft, ob eine Fehlermeldung nicht mit einer bestimmten Fehlermeldung identisch ist.

Weitere Informationen zur Syntax und Verwendung dieser und anderer DUnit-Funktionen finden Sie in den DUnit-Hilfedateien im Verzeichnis \source\dunit\doc.

DUnit-Test-Runner

Mit einem Testprogramm (Runner) können Sie die Tests unabhängig von Ihrer Anwendung ausführen. In einem DUnit-Testprojekt wird der Test-Runner-Code aus dem DUnit-Framework direkt in die erzeugte ausführbare Datei compiliert, sodass das Testprojekt zu einem Test-Runner wird. Das integrierte DUnit-Framework stellt zwei Test-Runner bereit:

  • Der GUI Test-Runner zeigt die Testergebnisse interaktiv in einem GUI-Fenster mit Farbcodierungen zum Kennzeichnen von Erfolg oder Fehlschlag an.
  • Der Konsolen-Test-Runner leitet die gesamte Testausgabe an die Konsole.

Der DUnit GUI Test-Runner ist besonders hilfreich, wenn Sie interaktiv Unit-Tests oder den zu testenden Quelltext entwickeln. Die erfolgreichen Tests werden durch einen grünen, die fehlgeschlagenen Tests durch einen roten und die ausgelassenen Tests durch einen gelben Balken hervorgehoben.

Verwenden Sie den DUnit Konsolen-Test-Runner, wenn Sie fertiggestellten Quelltext testen oder die Tests über automatisierte Build-Skripte ausführen.

Siehe auch