Überblick über DUnit
Nach oben zu Anwendungen testen - Index
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)
Inhaltsverzeichnis
Installieren von DUnit
Führen Sie diese Schritte aus, um das DUnit-Feature zu installieren:
- Wählen Sie Tools > Plattformen verwalten, um den Feature-Manager zu öffnen.
- Aktivieren Sie auf der Registerkarte Weitere Optionen das Feature "DUnit Test-Frameworks", um es Ihrer RAD Studio-Installation hinzuzufügen.
- 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.