Test-driven development (TDD), also called test-driven design, is a method
of software development in which unit testing is repeatedly done on source
code. The concept is to “get something working now and perfect it later.”
After each test, refactoring is done and then the same or a similar test is
performed again. The process is iterated as many times as necessary until
each unit is functioning according to the desired specifications. Test-driven
development is part of a larger software design paradigm known as Extreme Programming (XP).
Test-driven-development can produce applications of high quality in less time
than is possible with older methods. Proper implementation of TDD requires the
developers and testers to accurately anticipate how the application and its
features will be used in the real world. Problems are approached in an incremental
fashion and tests intended for the same unit of code must often be done many times over.
The methodical nature of TDD ensures that all the units in an application have been
tested for optimum functionality, both individually and in synergy with one another.
Because tests are conducted from the very beginning of the design cycle, time and money
spent in debugging at later stages is minimized.
One of the chief limitations of TDD is the fact that tests can sometimes be incorrectly
conceived or applied. This may result in units that do not perform as expected in the
real world. Even if all the units work perfectly in isolation and in all anticipated scenarios,
end users may encounter situations not imagined by the developers and testers.
The final results of TDD are only as good as the tests that have been used, the thoroughness
with which they have been done and the extent to which they mimic conditions encountered by
users of the final product.