Test-Driven Development in Java

Course Description

The Test-Driven Development in Java course presents a number of modern practices for developing code based on an iterative and incremental development lifecycle. Agility and predictability are two qualities often missing from software development. A test-driven approach, in which design is grown and code delivered incrementally according to functionality or risk, forms the basis of the construction phase of an iterative abd incremental development. The use of unit testing provides confidence in existing code and supports the ability to refactor code as development unfolds.
2 days
Contact us for pricing
 

Prerequisites

The course is suitable for software developers experienced in Java and familiar with object-oriented principles and practices. Any previous exposure of JUnit or agile development concepts is beneficial but not essential.

Objectives

- Appreciate the benefits of a continuous and interative approach to design and delivery
- Recognise the purpose and practice of refactoring in keeping a system supple and adaptable
- Know how to build up a set of unit tests in JUnit
- Understand the consequences of dependency management on testing and code quality

Audience

The course is intended as a practical course: the best way to appreciate how test-driven developments works and what it feels like is to do it in practice, making sense of the principles it embodies. In this form the course is based on lecture materials, demonstration, discussion and hands-on labs. However, the course can also be run as a seminar without hands-on labs, which puts more emphasis on understanding the principals through the demonstrations.

Agile Development Microprocess

Traditional versus agile development processes
Iterative and incremental development
Informal and continuous design
The role of refactoring
Refactoring versus other code changes
Extreme exposure
Test-Driven Development

Testing in Principle

Traditional view and reality testing
Driving development through testing
Testing early, often and automatically
Testing versus debugging
White-box versus black-box testing
Functional versus operational testing

Basic Unit Testing in Practice

Test plan versus test code
Use of assert
Testing at the interface
Testing the simplest things first
Testing incrementally
Testing correctness of failure

Overview of JUnit

JUnit and the xUnit family
Test cases, test suites and test runners
Essential structure of the framework
Assertion methods
Testing correctness of exceptions
Defining common fixture code
JUnit pattern usage
Extensions of JUnit

Test-Writing Techniques

Red, green, refactor
None to one to many
Faking it
Telling the truth
Isolate the short tests
Refactor common fixture code
Declare, prepare, assert
Test by method, state or scenario
Custom assertions
Compile-time constraints
Running all tests

Common Refactorings

Renaming variables, methods, classes and packages
Restructuring class hierarchies by extracting interfaces, superclasses and Subclasses
Partitioning classes by extracting classes and methods
Changing private representation

Decoupling Techniques

Unmanaged dependencies
Test-driven decoupling
Layering
Reorganising packges
Eliminating cyclic dependencies
Mock Objects
Eliminating Singletons, statics and other globals
Testing I/O
Java