1. An Introduction to Test-Driven Development (TDD)

2. An Introduction to Test-Driven Development (TDD)
Disclaimer
Developer = Programmer
We’re talking about unit testing – i.e. testing the internals of a class
Black box testing for objects
Classes are testing in isolation
Loosely coupled, highly cohesive architectures
An Introduction to Test-Driven Development (TDD)

3. An Introduction to Test-Driven Development (TDD)
Agenda
Motivation
What is TDD?
TDD Stages
TDD in Delphi
Demonstration
Delphi
C#Builder using csUnit
Why TDD?
Summary
Notable Quotes
An Introduction to Test-Driven Development (TDD)

4. An Introduction to Test-Driven Development (TDD)
Motivation
One of my goals for Q3/Q was to become evangelical about eXtreme Programming (XP) and Test-Driven Development (TDD)
TDD sits nicely in the XP “way of doing things”
TDD can be used without practicing XP
Writing articles and giving presentations is one such way of achieving that goal
To reduce the amount of re-testing that is required
Especially with legacy applications
To avoid introducing new bugs after refactoring existing code
An Introduction to Test-Driven Development (TDD)

5. An Introduction to Test-Driven Development (TDD)
What is TDD?
“Before you write code, think about what it will do.
Write a test that will use the methods you haven’t even written yet.”
Extreme Programming Applied: Playing To Win
Ken Auer, Roy Miller
“The Purple Book”
A test is not something you “do”, it is something you “write” and run once, twice, three times, etc.
It is a piece of code
Testing is therefore “automated”
Repeatedly executed, even after small changes
An Introduction to Test-Driven Development (TDD)

6. An Introduction to Test-Driven Development (TDD)
What is TDD?
TDD is a technique whereby you write your test cases before you write any implementation code
Tests drive or dictate the code that is developed
An indication of “intent”
Tests provide a specification of “what” a piece of code actually does
Some might argue that “tests are part of the documentation”
An Introduction to Test-Driven Development (TDD)

7. An Introduction to Test-Driven Development (TDD)
Agenda
Motivation
What is TDD?
TDD Stages
TDD in Delphi
Demonstration
Delphi
C#Builder using csUnit
Why TDD?
Summary
Notable Quotes
An Introduction to Test-Driven Development (TDD)

8. An Introduction to Test-Driven Development (TDD)
TDD Stages
In Extreme Programming Explored (The Green Book), Bill Wake describes the test / code cycle:
Write a single test
Compile it. It shouldn’t compile because you’ve not written the implementation code
Implement just enough code to get the test to compile
Run the test and see it fail
Implement just enough code to get the test to pass
Run the test and see it pass
Refactor for clarity and “once and only once”
Repeat
An Introduction to Test-Driven Development (TDD)

9. An Introduction to Test-Driven Development (TDD)
TDD Stages
Write a test
Refactor code (and test)
Compile
Run test, watch it pass
Fix compile errors
Write code
Run test, watch it fail
An Introduction to Test-Driven Development (TDD)

10. An Introduction to Test-Driven Development (TDD)
Agenda
Motivation
What is TDD?
TDD Stages
TDD in Delphi
Demonstration
Delphi
C#Builder using csUnit
Why TDD?
Summary
Notable Quotes
An Introduction to Test-Driven Development (TDD)

11. An Introduction to Test-Driven Development (TDD)
TDD in Delphi
DUnit
An xUnit implementation for Delphi
xUnit is a colloquial umbrella term
Platform-specific implementations
e.g. sUnit, JUnit, XMLUnit
Provides classes with methods to help us write test cases
TTestCase
“Check” functions…
An Introduction to Test-Driven Development (TDD)

12. TDD in Delphi using DUnit
TObject
TTestCase
TYourClass
TTestYourClass
Test
SomeMethod1
SomeMethod2
Test
SomeMethod2
SomeMethod1
Test
SomeMethod1
and SomeMethod2
An Introduction to Test-Driven Development (TDD)

13. TDD in Delphi using DUnit
Check (condition: boolean; msg: string = '');
CheckEquals (expected, actual: integer; msg: string = '');
procedure TTestCaseList.TestAdd;
var AddObject: TObject;
FEmpty : TList;
Begin
FEmpty := TList.Create;
AddObject := TObject.Create;
FEmpty.Add(AddObject);
// The following calls check to see if everything went OK.
// When check fails, it will end up in the TestResult as a failure.
Check(FEmpty.Count = 1);
Check(FEmpty.Items[0] = AddObject);
end;
An Introduction to Test-Driven Development (TDD)

14. An Introduction to Test-Driven Development (TDD)
Test Complexity
Do the simplest thing
Dave Astels: “Strive for simplicity”
Write a test that fails (red)
Make the test pass (green)
Refactor implementation code (change the internal design)
Use the compiler – let it tell you about errors and omissions
One assertion (Check/Assert) per test
Subject of furious debate on Yahoo’s TDD group
An Introduction to Test-Driven Development (TDD)

15. An Introduction to Test-Driven Development (TDD)
demo
Test-driven development
using Dunit in Delphi 6
using csUnit in C#Builder
An Introduction to Test-Driven Development (TDD)

16. An Introduction to Test-Driven Development (TDD)
Smells
Duplication
Once And Once Only (OAOO)
Setup / TearDown
Some duplicated code reveals itself as common ‘initialisation’ code
And / Or as ‘cleanup’ code
An Introduction to Test-Driven Development (TDD)

17. An Introduction to Test-Driven Development (TDD)
Agenda
Motivation
What is TDD?
TDD Stages
TDD in Delphi
Demonstration
Delphi
C#Builder using csUnit
Why TDD?
Summary
Notable Quotes
An Introduction to Test-Driven Development (TDD)

18. An Introduction to Test-Driven Development (TDD)
Why TDD?
Programmers dislike testing
They will test reasonably thoroughly the first time
The second time however, testing is usually less thorough
The third time, well..
Testing is considered a “boring” task
Testing might be the job of another department / person
TDD encourages programmers to maintain an exhaustive set of repeatable tests
Tests live alongside the Class/Code Under Test (CUT)
With tool support, tests can be run selectively
The tests can be run after every single change
An Introduction to Test-Driven Development (TDD)

19. An Introduction to Test-Driven Development (TDD)
Why TDD?
Bob Martin:
“The act of writing a unit test is more an act of design than of verification”
Confidence boost
By practicing TDD, developers will strive to improve their code – without the fear that is normally associated with code changes
Isn’t the green bar a feel good factor?
Remove / Reduce reliance on the debugger
No more “debug-later” attitudes
An Introduction to Test-Driven Development (TDD)

20. Who should write the tests?
The programmers should write the tests
The programmers can’t wait for somebody else to write tests
TDD promotes “small steps”, and lots of them
Small steps: the shortest distance between two points
Your destination is closer… B A
An Introduction to Test-Driven Development (TDD)

21. An Introduction to Test-Driven Development (TDD)
Agenda
Motivation
What is TDD?
TDD Stages
TDD in Delphi
Demonstration
Delphi
C#Builder using csUnit
Why TDD?
Summary
Notable Quotes
An Introduction to Test-Driven Development (TDD)

22. An Introduction to Test-Driven Development (TDD)
Summary
TDD does not replace traditional testing
It defines a proven way that ensures effective unit testing
Tests are working examples of how to invoke a piece of code
Essentially provides a working specification for the code
No code should go into production unless it has associated tests
Catch bugs before they are shipped to your customer
No code without tests
Tests determine, or dictate, the code
An Introduction to Test-Driven Development (TDD)

23. An Introduction to Test-Driven Development (TDD)
Summary
TDD isn’t new
To quote Kent Beck:
“…you type the expected output tape from a real input tape, then code until the actual results matched the expected result…”
TDD means less time spent in the debugger
TDD negates fear
Fear makes developers communicate less
Fear makes developers avoid repeatedly testing code
Afraid of negative feedback
An Introduction to Test-Driven Development (TDD)

24. An Introduction to Test-Driven Development (TDD)
Summary
TDD promotes the creation of a set of “programmer tests”
Automated tests that are written by the programmer
Exhaustive
Can be run over and over again
TDD allows us to refactor, or change the implementation of a class, without the fear of breaking it
TDD and refactoring go hand-in-hand
With care, [some] User Acceptance Tests can codified and run as part of the TDD process
An Introduction to Test-Driven Development (TDD)

25. An Introduction to Test-Driven Development (TDD)
Notable Quotes
Ron Jeffries, TDD and XP aficionado on the subject of TDD:
“clean code that works”
Martin Fowler: “The code is the design”
Alan Francis: “Legacy code is code without tests”
To learn more about Agile Methods, Extreme Programming & Test-Driven Development visit:
An Introduction to Test-Driven Development (TDD)

26. An Introduction to Test-Driven Development (TDD)
Resources (Books)
test-driven development: A Practical Guide
Dave Astels
Prentice-Hall/Pearson Education, 2003
ISBN
Reviewed BUG developers’ magazine, Nov/Dec 2003
______________________________________
Test-Driven Development: By Example
Kent Beck
Addison-Wesley, 2003
ISBN
An Introduction to Test-Driven Development (TDD)

27. An Introduction to Test-Driven Development (TDD)
Resources (Books)
Refactoring: Improving the Design of Existing Code
Martin Fowler
Addison-Wesley, 1999
ISBN
An Introduction to Test-Driven Development (TDD)

28. Resources (web-sites)
NUnit:
CSUnit:
Mock Objects:
testdrivendevelopment group (Yahoo):
Ron Jeffries, Dave Astels, Kent Beck, etc. are regular contributors
An Introduction to Test-Driven Development (TDD)

29. Resources (web-sites)
The DUnit group at SourceForge
Lutz Roeder’s .NET Reflector:
xUnit implementations:
An Introduction to Test-Driven Development (TDD)

30. An Introduction to Test-Driven Development (TDD)
Resources (Articles)
Test-Driven Development using csUnit in C#Builder
Craig Murphy
UK-BUG Magazine Issue Jan/Feb 2004
“To err is human: automated testing of Delphi code with DUnit”
Kris Golko
UK-BUG Magazine Issue Nov/Dec 2002
Testing: Quality Time with DUnit
Rob Bracken
The Delphi Magazine, Issue 76 (Dec01)
An Introduction to Endo-Testing Using Mock Objects
Sacha Frick
The Delphi Magazine, Issue 96 (Aug03)
An Introduction to Test-Driven Development (TDD)

31. Contact and Update Information
Craig Murphy
Updated slides, notes and source code:
An Introduction to Test-Driven Development (TDD)

32. An Introduction to Test-Driven Development (TDD)
Questions?
RED
GREEN
REFACTOR
An Introduction to Test-Driven Development (TDD)