DUnitX Overview

Go Up to Testing Applications Index

Note: DUnitX uses Delphi language features that are not supported in C++. For C++ developers, DUnit is the best tool. C++ can also be tested using other frameworks such as Google Test, available via GetIt Package Manager.

DUnitX is an open-source unit test framework based on the NUnit test framework, including some ideas from xUnit as well. The RAD Studio integration of DUnitX framework enables you to develop and execute tests against Win32, Win 64, macOS, and Linux in Delphi applications.

The DUnitX testing framework provides its own set of methods for testing conditions. You can use the provided methods to test a large number of conditions. These methods represent common assertions although you can also create your own custom assertions.

DUnitX uses Generics and Anonymous methods. DUnitX uses attributes under Delphi personality.

Also see the DUnitX home page at https://github.com/VSoftTechnologies/DUnitX/wiki.

Developing Delphi DUnitX Tests

The following sample Delphi program defines two functions that perform a 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 unit that you need to modify to test the two functions. You have to add code to the SetUp and TearDown methods as well as to the test methods TestAdd and TestSub. Finally, make use of attributes to test the functions.

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.

DUnitX Functions

DUnitX provides Assert class with a number of functions that you can use in your tests.

The table shows some of these functions.

Function	Description
Pass	Checks that a routine works.
Fail	Checks that a routine fails.
AreEqual	Checks to see if items are equal.
AreNotEqual	Checks to see if items are not equal.
AreSame	Checks to see that two items have the same value.
AreNotSame	Checks to see that two items do not have the same value.
Contains	Checks to see if the item is in a list.
DoesNotContain	Checks to see if the item is not in a list.
IsTrue	Checks that a condition is true.
IsFalse	Checks that a condition is false.
IsEmpty	Checks to see if the value of an item is empty.
IsNotEmpty	Checks to see if the value of an item is not empty.
IsNull	Checks to see that an item is null.
IsNotNull	Checks to see that an item is not null.
WillRaise	Checks to see if the method will raise an exception.
StartsWith	Checks if a string starts with a specified substring.
InheritsFrom	Checks if a class is descendant of a specified class.
IsMatch	Checks if the item matches with a specified pattern.

For more information about the syntax and usage of these and other DUnitX functions, see the DUnitX help files in \source\DUnitX.

DUnitX Test Runners

A test runner allows you to run your tests independently of your application. In a DUnitX test project, the test runner code from the DUnitX framework is compiled directly into the generated executable making the test project itself a test runner. The integrated DUnitX framework provides two test runners:

• The Console Test Runner:
  • Sends all test output to the console. This is the testing mode by default when you run your DUnitX project. DUnitX framework provides TDUnitXConsoleLogger class to run the testing output to the console.
  • Is useful when you want to run completed code and tests from automated build scripts.

• The GUI Test Runner:
  • Displays test results interactively in a GUI window. DUnitX framework provides a TGUIXTestRunner class to generate the FireMonkey GUI output and a TDUnitXGuiLoggerForm class for the VCL GUI.
  • Is very useful when actively developing unit tests for the code you are testing.

See Also

• How to convert DUnit Tests to DUnitX
• Developing Tests with DUnitX
• DUnitX source and contributions