DELPHI2010 source的源代码

Using DUnit

by Yong Yoon Kit

020606 yky Created

020607 yky Modified UML diagram, added some Questions

020610 yky Modified changed example to TCounter from TPDObject added UML diag.

Abstract

This document will briefly introduce one aspect of eXtreme Programming (XP)

which we will use in our development cycle, the DUnit. It will describe how to Use

before implementation. After implementation, ALL tests should pass. If you can

think of different scenarios, write the test cases, testing for the correct results. And

remember, when a bug is found, the developer will only test that bug once

manually because he MUST write a test case to keep testing for that bug in the

future.

On unit tests, please refer to this page:

http://www.extremeprogramming.org/rules/unittests.html

SUnit, JUnit, CUnit, etc...

DUnit is a member of the *Unit family for all the different programming languages.

It is developed as an Open Source project in sourceforge (dunit.sourceforge.net)

that the process does not affect the end result.

Refactoring is this process of going back into old code, improving it, and ensuring

that the results are the same if not better.

This is especially important for the case of OO Programming where changes in

the Base class may have dire consequences to the inherited classes. So if we

have tests written throughout the hierarchy, changes which change the behaviour

of descendant classes can be detected.

eXtreme Programming (XP)

On more about eXtreme Programming as a software development methodology,

please go to www.extremeprogramming.org or

4.run the test harness expecting errors because of the incomplete implementation

5.implement each function one by one

6.continuously test our creation iteratively

The example is to create a simple Counting object called TCounter which takes in

an input value and when functions like double, factorial, power are called, it will do

the operation on the value and also return the values.

Here is the UML diagram which describes the classes inheritance, the attributes

and functions we need to implement.

For any Class, there must be another Class to test it.

For example, TCounter will have a TCounterTest, and this should exist in a

seperate application from the actual usable app.

4.Replace Application.Initialize and Application.Run with

GUITestRunner.runRegisteredTests

5.Thats all you have to do, and the project code should look something like this:

program CounterObjectTest;

uses

CounterCls in 'CounterCls.pas',

CounterTest in 'CounterTest.pas',

TestFramework in '..\..\..\Tests\DUnit\TestFramework.pas',

GUITestRunner in '..\..\..\Tests\DUnit\GUITestRunner.pas' {GUITestRunner};

{$R *.res}

In it, we must use TestFrameWork from DUnit. Of course we will also use the

objects which we want to test which is CounterCls.pas

unit CounterTest;

{ 020607 yky Created to illustrate the use of DUnit

This unit will test the TCounter Class.

}

interface

TestFrameWork, CounterCls;

Inheriting TTestCase

The first thing to do is to create a Test Case Object, and to do so, we inherit from

TearDown.

TCounterTest = class(TTestCase)

protected

mCounter: TCounter;

procedure SetUp; override;

procedure TearDown; override;

published

procedure testDouble;

procedure testPower;

procedure testFactorial;

end;

mCounter := TCounter.Create;

end;

The FObj is usually the object we intend to test.

TearDown

For everything that has been Created, we will need to destroy. So TearDown

would look something like this:

procedure TCounterTest.TearDown;

begin

inherited;

mCounter.Free;

end;

TCounter = class(TObject)

published

property input: real;

property DoubleIt: real;

property PowerIt: real;

property FactorialIt: real;

end;

This object is rather basic. Given and input, it can calculate the double with

DoubleIt, the power of itself with PowerIt and the factorial with FactorialIt.

Now that we know what our Class to be tested is suppose to do, we can proceed

Harness Class should look something like this:

procedure SetUp; override;

procedure TearDown; override;

published

procedure testDouble;

procedure testPower;

procedure testFactorial;

procedure testFactorialNegative;

end;

Using Check

Check is a DUnit function which takes in two parameters; the first is the logical