Überblick über DUnitX

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Anwendungen testen - Index

DUnitX ist ein Open Source Unit-Test-Framework, das auf dem NUnit-Test-Framework sowie auf bestimmten Konzepten aus xUnit basiert. Mit der RAD Studio-Integration des DUnitX-Frameworks können Sie Tests für Win32, Win64 und OS X und Linux in Delphi- und C++Builder-Anwendungen entwickeln und ausführen.

Jedes DUnitX-Framework verfügt über eigene Methoden für das Testen von Bedingungen. Mit den bereitgestellten Methoden kann eine große Anzahl von Bedingungen getestet werden. Diese Methoden repräsentieren allgemeine Assertions, Sie können aber auch eigene Assertions erstellen.

DUnitX verwendet Generics und anonyme Methoden. DUnitX verwendet unter der Delphi-Personality Attribute. In C++Builder verwendet DUnitX als published deklarierte Methoden.

Zusätzliche Informationen finden Sie auf der DUnitX-Homepage unter https://github.com/VSoftTechnologies/DUnitX/wiki.

Entwickeln von DUnitX-Tests für Delphi

Im folgenden Delphi-Beispielprogramm werden zwei Funktionen definiert, 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 Test-Unit, die Sie ändern müssen, um die beiden Funktionen zu testen. Sie müssen den Methoden SetUp und TearDown sowie den Testmethoden TestAdd und TestSub Code hinzufügen. Verwenden Sie dann Attribute, um die Funktionen zu testen.

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.

Entwickeln von DUnitX-Tests für C++

Im folgenden C++Builder-Beispielprogramm werden zwei Funktionen definiert, die eine einfache Addition und Subtraktion durchführen:

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;
}

Das folgende Beispiel zeigt die Test-Unit, die Sie ändern müssen, um die beiden Funktionen zu testen. Sie müssen den Methoden SetUp und TearDown sowie den Testmethoden TestAdd und TestSub Code hinzufügen.

#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

DUnitX-Funktionen

DUnitX stellt eine Assert-Klasse mit einer Reihe verschiedener Funktionen bereit, die Sie in Ihren Tests verwenden können.

Die folgende Tabelle enthält einige dieser Funktionen.

Funktion Beschreibung

Pass

Prüft, ob eine Routine funktioniert.

Fail

Prüft, ob eine Routine fehlschlägt.

AreEqual

Prüft, ob zwei Elemente gleich sind.

AreNotEqual

Prüft, ob zwei Elemente ungleich sind.

AreSame

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

AreNotSame

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

Contains

Prüft, ob sich das Element in einer Liste befindet.

DoesNotContain

Prüft, ob sich das Element nicht in einer Liste befindet.

IsTrue

Prüft, ob eine Bedingung wahr ist.

IsFalse

Prüft, ob eine Bedingung falsch ist.

IsEmpty

Prüft, ob der Wert eines Elements leer ist.

IsNotEmpty

Prüft, ob der Wert eines Elements nicht leer ist.

IsNull

Prüft, ob ein Element null ist.

IsNotNull

Prüft, ob ein Element ungleich null ist.

WillRaise

Prüft, ob die Methode eine Exception auslöst.

StartsWith

Prüft, ob ein String mit einem bestimmten Teilstring beginnt.

InheritsFrom

Prüft, ob eine Klasse von einer bestimmten Klasse abgeleitet ist.

IsMatch

Prüft, ob das Element mit einem bestimmten Muster übereinstimmt.

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

DUnitX-Test-Runner

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

  • Konsolen-Test-Runner:
    • Sendet die gesamte Testausgabe an die Konsole. Dies ist der Standardtestmodus bei der Ausführung eines DUnitX-Projekts. Das DUnitX-Framework stellt die Klasse TDUnitXConsoleLogger zur Ausgabe des Testergebnisses auf der Konsole bereit.
    • Ist hilfreich, wenn Sie den gesamten Code und alle Tests aus automatisierten Build-Skripten ausführen möchten.
  • GUI-Test-Runner:
    • Zeigt Testergebnisse interaktiv in einem GUI-Fenster an. Das DUnitX-Framework stellt die Klasse TGUIXTestRunner zum Generieren der FireMonkey-GUI-Ausgabeund die Klasse TDUnitXGuiLoggerForm für die VCL-GUI bereit.
    • Ist hilfreich beim aktiven Entwickeln von Unit-Tests für den Code, den Sie testen.

Siehe auch