DUnit Overview
Go Up to Testing Applications Index
DUnit is an open-source unit test framework based on the JUnit test framework. The DUnit framework enables you to build and execute tests against Delphi Win32 applications. The RAD Studio integration of DUnit framework enables you to develop and execute tests against Delphi Win32 and C++Builder applications.
The DUnit testing framework provides its own set of methods for testing conditions. The methods represent common assertions. You can also create your own custom assertions. You can use the provided methods to test a large number of conditions.
Also, see the DUnit home page at http://dunit.sourceforge.net/
Contents
Installing DUnit
To install the DUnit feature, follow these steps:
- Select Tools > Manage Platforms to open the Feature Manager Dialog.
- On the Additional Options tab, check the DUnit Testing Frameworks feature to add it to your RAD Studio installation.
- Select Apply to apply the selected changes.
When the changes are applied, the Feature Manager Dialog shows an Operation Complete screen.
Developing Delphi DUnit Tests
Every DUnit test implements a class of type TTestCase.
The following sample Delphi Win32 program defines two functions that perform simple addition and subtraction:
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.
The following example shows the test case skeleton file that you need to modify to test the two functions, Add and Sub, in the preceding code.
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;
initialization
// Register any test cases with the test runner
RegisterTest(TestTCalc.Suite);
end.
Developing C++ DUnit Tests
Every DUnit test implements a class of type TTestCase.
The following sample C++ Win32 header file and program define two functions that perform simple addition and subtraction:
#ifndef Unit7H
#define Unit7H
//-------------------------------------------------
class TCalc
{
public:
int Add(int x, int y);
int Sub(int x, int y);
};
#endif
The following example (TestUnit7.cpp) contains a Testcase for the TCalc class. The Wizard generated this example, but the user is expected to write tests that exercise the functions Add and Sub. The example illustrates the DUnit scaffolding for 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 Functions
DUnit provides a number of functions that you can use in your tests.
| Function | Description |
|---|---|
|
Check |
Checks to see if a condition was met. |
|
CheckEquals |
Checks to see that the two items are equal. |
|
CheckNotEquals |
Checks to see if items are not equal. |
|
CheckNotNull |
Checks to see that an item is not null. |
|
CheckNull |
Checks to see that an item is null. |
|
CheckSame |
Checks to see that the two items have the same value. |
|
EqualsErrorMessage |
Checks to see that an error message emitted by the application matches a specified error message. |
|
Fail |
Checks that a routine fails. |
|
FailEquals |
Checks to see that a failure equals a specified failure condition. |
|
FailNotEquals |
Checks to see that a failure condition does not equal a specified failure condition. |
|
FailNotSame |
Checks to see that two failure conditions are not the same. |
|
NotEqualsErrorMessage |
Checks to see that the two error messages are not the same. |
|
NotSameErrorMessage |
Checks that one error message does not match a specified error message. |
For more information on the syntax and usage of these and other DUnit functions, see the DUnit help files in \source\dunit\doc.
DUnit Test Runners
A test runner allows you to run your tests independently of your application. In a DUnit test project, the test runner code from the DUnit framework is compiled directly into the generated executable making the test project itself a test runner. The integrated DUnit framework provides two test runners:
- The GUI Test Runner This displays test results interactively in a GUI window, with results color-coded to indicate success or failure.
- The Console Test Runner This sends all test output to the console.
The DUnit GUI Test Runner is very useful when actively developing unit tests for the code you are testing. The DUnit GUI Test Runner displays a green bar over a test that completes successfully, a red bar over a test that fails, and a yellow bar over a test that is skipped.
The DUnit Console Test Runner is useful when you want to run completed code and tests from automated build scripts.