Test-driven development

TDD Global Lifecycle

Test-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: requirements are turned into very specific test cases, then the software is improved to pass the new tests, only. This is opposed to software development that allows software to be added that is not proven to meet requirements. American software engineer Kent Beck, who is credited with having developed or 'rediscovered' the technique, stated in 2003 that TDD encourages simple designs and inspires confidence.

History

The concept of test-driven development is derived from a more extensive practice known as Extreme Programming (XP), which was first introduced by Kent Beck in the late 1990s. TDD is one of the core practices of Extreme Programming, but it has been adopted by other agile methodologies and can be used outside the agile context as well.

Process

The test-driven development cycle can be broken down into the following steps:

1. Add a test: The developer writes a test that defines a function or improvements of a function, which should be very specific.
2. Run all tests and see if the new test fails: This validates that the test harness is working correctly, ensures that the new test does not mistakenly pass without requiring any new code, and provides a baseline to show that future code changes will actually implement the test.
3. Write the code: The developer writes the code that will make the test pass.
4. Run tests: If all test cases now pass, the developer can be confident that the code meets all the tested requirements.
5. Refactor code: This involves making changes to the code to improve its structure or readability without affecting its behavior. The tests are run after refactoring to ensure that no existing functionality has been broken.
6. Repeat: This cycle is repeated for each new piece of functionality.

Benefits

The benefits of test-driven development include:

• Reduction in bug rates.
• Improved code quality and maintainability.
• Simplification of the code.
• Documentation of the code through the tests.
• Faster feedback on changes.

Challenges

Despite its benefits, TDD can present challenges, including:

• Initial learning curve and potential increase in development time.
• Requirement for discipline and consistency in writing tests first.
• Possible overemphasis on unit testing at the expense of other types of testing.

Tools

Several tools and frameworks support TDD for various programming languages, including JUnit for Java, NUnit for .NET, and RSpec for Ruby.

See also

• Behavior-driven development
• Software testing
• Continuous integration