Test-driven development

Automated tests

The ability to maintain software succeeds or fails on good test coverage.
Without automated tests – particularly for growing projects – there is a risk that changes in one place will cause errors in another that upon first look seem to have nothing to do with the change. Without code maintenance using refactoring, internal code quality will increasingly degrade over time, which means the danger of new errors creeping in continually grows. It gets to the point that implementing new features or eliminating known errors is no longer possible with reasonable effort because there is no one who fully understands the complex code that has mushroomed over time.

In contrast, a “security network” of automated tests enables developers to maintain high internal code quality through refactoring. Tests that run successfully after a change provide developers with positive feedback and encourage them to maintain high quality: the developer is proud of the results. If a change introduces an error, it is generally discovered quickly by the automated tests. This means it can be eliminated in a timely manner without the need for costly searches.

Particularly in conjunction with agile development methods, easy, automated execution of even comprehensive test suites simplifies regular, fast release cycles for customers without negatively impacting the quality delivered.

Test-driven software development (TDD)

The methods behind test-driven development turn the conventional development process upside down. Extremely short cycles are used here – usually just a few minutes:

• First, a test is written for the functionality to be developed. Naturally, it initially fails because there is no implementation yet.
• In the second step, programming continues until the test runs successfully.
• The quality of the code that has just been written is raised to the level required through refactoring, without changing the functionality.

This iterative procedure results in extremely high test coverage (no code is written that will not be tested) and constant refactoring means high code quality and easy maintenance.

And all in practical use

Software development at consistec relies on high test coverage throughout all levels of its test-centered development process.
It begins at the unit test level for the various programming languages (JUnit for Java, Google Test for C / C++, DbUnit for database applications, etc.), continues to automated tools for monitoring code quality (Sonar, cppcheck, Valgrind, etc.), and finds use in end-to-end tests (Selenium for web applications, Dogtail or LDTP for C++ GUI applications, etc.).
After each source code change, the test suites are run automatically on a continuous integration server.
This ensures that the test cases and the requirements in terms of code quality are always fully met.
Testing applies across all supported platforms, not just on the computer of the respective developer.