Unit Testing and Test-Driven

DevelopmentWhat is Unit Testing? How TDD Works?

Tsvyatko KonovTelerik

Corporationwww.telerik.com

So what’s a unit test?

A Unit Test is a testof a small functional piece of

code

Public bool IsLoginOK(string user, string password)

{

//…………………………

}

Public bool IsLoginOK(string user, string password)

{

//…………………………

}

Should return true when… Should return false when…

Possible tests

Unit Testing makes your developer lives easier

Easier to find bugs

Easier to maintain

Easier to understand

Easier to Develop

source flickr.com

You have already done Unit testing

Not structured Not Repeatable Not on all your code Not easy to do as it should be

A framework is missing

The xUnit Frameworks

Original was for SmallTalk Kent Beck and Erich Gamma

Ported to Various languages and platforms

JUnit, CppUnit, DUnit, VBUnit, RUnit, PyUnit, Sunit, HtmlUnit, …

Good list at www.xprogramming.com

Standard test architecture

How we use the framework

Write Tests Make it easy to create and organize tests Reference an assembly, spread some attributes, you’re

done

Run Tests Allow running all of our tests, a group or just one. From command line or GUI

Review Results Immediate Pass/Fail feedback Details on each failure

.NET unit Test Frameworks

NUnit XUnit MbUnit Team System Unit Testing

NUnit

Team System Unit Testing

The 3A Pattern

Arrange all necessary preconditions and inputs.

Act on the object or method under test.

Assert that the expected results have occurred.[TestClass]

public class BankAccountTests() {

[TestMethod] public void WhenDeposit125And25_ThenTheBalance_ShouldBe150() {

BanckAccount account = new BanckAccount();

account.Deposit(125.0); account.Deposit(25.0);

Assert.AreEqual(150.0, account.Balance, "Balance is wrong.");

} }

Attributes

TestClass TestMethod

TestInitialize TestCleanup

ExpectedException

Ignore Description

What is Test Driven Development?

TDD = Test First Development + Refactoring

Make it Fail No code without a failing test

Make it Work As simply as possible

Make it Better Refactor

Development Cycle

make a little change (refactor)

add a test

run the tests

run the tests

[Pass]

[Fail]

[Fail]

[Development continues]

[Development stops]

DemoTDD + Code Coverage

Test Driven Development

TDD = Test First Development + Refactoring

But what are the advantages?

What are the advantages of TDD?

TDD shortens the programming feedback loop

TDD provides detailed specification (tests)

TDD promotes the development of high-quality code

TDD provides concrete evidence that your software works

What are the advantages of TDD?

(a) Traditional waterfall development process

(b) Evolutionary development process (EVO).

TDD “speaks” to programmers TDD provides very finely grained concrete feedback on the order of minutes

TDD helps to ensure that your design is clean by focusing on creation of operations that are callable and testable

TDD supports evolutionary development.

What are the advantages of TDD?

Case Study: TDD Concerns

Defect Rate Long term and short term affect

Productivity Lines of code per month impact

Test Frequency Ratio of interactive to automated

Design Design robustness

Integration Smoothness of code integration

Case Study: TDD Results

Defect Rate 50% improvement

Productivity Below initial estimates (<400 LOC)

Test Frequency 86% of tests were automated

Design Aided in late changes

Integration Testing made problems surface early

Case Study: TDD Results(2)

Results from Microsoft Study Tested 4 products

Pre-release defect density reduces - 40% to 90%

Increase in initial development time - 15 – 35%

Why write the test before the code?

Think through the requirement Think about the design and

usability of the API There’s never time to write it

afterwards

You write much less tests (if at all) otherwise

Why make it fail first? Make sure the test does not have

a bug Make sure you’re testing the

right thing

Define a small problem to solve When the test passes, you are

done

If you can’t write that test, you may Not understand the requirement Have over designed things (not

testable) Not have a small enough problem

to solve

Why Refactor?

Constantly improve the design of the code

Unit tests act as safety net Remove duplication, improve

readability and maintainability

You’ll need to when things change (requirements, your understanding of them, other factors..)

Real World

It’s not easy to learn Dealing with legacy code Requires a lot of discipline You have to want to do it But once you do…

It gets easier and easier It’s a hard habit to let go

Pillars of good unit tests

Making your tests trustworthy Creating maintainable tests Readable tests – last but not

least!

Questions?