Ü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. Die RAD Studio-Integration des DUnit-Frameworks ermöglicht das Entwickeln und Ausführen von Tests für Delphi Win32- und C++Builder-Anwendungen.
Jedes Test-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/
Inhaltsverzeichnis |
DUnit-Tests für Delphi entwickeln
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
// Testmethoden für Klasse 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: Hier Testcode hinzufügen
end;
procedure TestTCalc.TestSub;
var
_result: System.Integer;
y: System.Integer;
x: System.Integer;
begin
_result := aTCalc.Sub(x, y);
// TODO: Hier Testcode hinzufügen
end;
initialization
// Alle Testfälle bei Testprogramm registrieren
RegisterTest(TestTCalc.Suite);
end.
DUnit-Tests für C++ entwickeln
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. Der Experte hat dieses Beispiel generiert, aber der Benutzer soll Tests schreiben, die die Funktionen Add und Sub prüfen. 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
/* [NUr zum Debuggen - Muss bald entfernt werden!!]
GenerateHeaderComment=true
DefaultExtension=.cpp
FileName=C:\Users\bbabet\Documents\RAD Studio\Projects\DUnitSample\Test\TestUnit7.cpp
TestFramework=DUnit / C++ Win32
OutputPersonality=CPlusPlusBuilder.Personality
TestProject=C:\Users\bbabet\Documents\RAD Studio\Projects\DUnitSample\Test\Project3Tests.cbproj
UnitUnderTest=C:\Users\bbabet\Documents\RAD Studio\Projects\DUnitSample\Unit7.h
NameOfUnitUnderTest=Unit7.h
TestCaseBaseClass=TTestCase
TestCasePrefix=Test
UnitName=TestUnit7
Namespace=TestUnit7
TestClasses=
<0>
Name=TCalc
Methods=
<0>
Name=Add
Signature=int Add(int x, int y)
<1>
Name=Sub
Signature=int Sub(int x, int y)
TestClass=
Method=
*/
DUnit-Funktionen
DUnit verfügt über verschiedene Funktionen, 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, so dass das Testprojekt zu einem Test-Runner wird. Dies unterscheidet sich vom NUnit-Framework, das einen separaten Test-Runner zur Ausführung von Tests verwendet. 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 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 fertig gestellten Quelltext testen oder die Tests über automatisierte Build-Scripts ausführen.