Table of Contents
  1. Quality Assurance balanced
  2. test automation
  3. TDD and ATDD
  4. Conclusion
  5. read on one side

With static code analysis tools like FindBugs often, FXCop or CheckStyle be used to check the code against application-independent fault. Uncovered exceptions obvious null pointer references and unused code fragments can thus find specific. In general, however, should not be limited to static code analysis, but complement the metrics by pair programming. This knowledge sharing is also long supported the team and Collective Code Ownership allows. If any programmer in the team is able to change any other code, creating a whole new way of working, because no longer Peters code no longer go at once, but it is the code of all team members.

As with all metrics, however, to keep in mind that it is not about to measure the individual performance of team members or to use, for example, coverage metrics as a target for the software development team. Cem Kaner and Walter P. Bond lead "Software Engineering Metrics - What do they measure and how do we know?" [3] that such behavior to tampering and outsmarting the metrics results. For example, unit testing can create a targeted manner so that the percentage coverage is achieved. They are then usually strongly bound to the application logic, so it is difficult in retrospect to change the code without breaking the test. Instead, the authors propose to invest in the training of developers and work with them directly to the code.

Enough is not enough

Once a network of automated tests is positioned along with the continuous integration, it is only a small step to test-driven (TDD) development. The development cycle starts with a small, failing test: Runs a test not just as much production code should be written so that it can be successfully complete. Subsequently, are redundancy in the code to reduce by refactoring (Fig. 3). Most teams do not realize is that this is also in test automation to software development where the test code is clean, as it is otherwise quickly face the problem of bad maintainable tests.

With test-driven development in the long term maintainable, tested code to be created (Fig. 3).With test-driven development in the long term maintainable, tested code to be created (Fig. 3).

This approach initially appears dogmatic, but to learn test-driven development, he has deliberately chosen this way. When security occurs after some time in certain areas can also try to implement in larger increments. However, it should be clear that too large a step entails the risk to get bogged down, and the test will not come quickly back up and running. If this occurs, the problem should be broken down into smaller units and be resolved that way.

Specification with examples

A new trend in the development of methods currently goes toward Acceptancetest-driven development (ATDD) and Behavior-driven development (BDD). At its core, BDD is the association of TDD, ATDD, domain-driven design, Outside-In Development and use of a ubiquitous language as specification workshops created by instruments. In practice ATDD unfortunately, is often confused with BDD.

ATDD is designed to help the right functions to develop (Fig. 4).ATDD is designed to help the right functions to develop (Fig. 4).

In ATDD (see [4].) It is a measure to implement requirements correctly as possible in the code (Fig. 4). The work starts here early, even while the actual requirements are defined. Representatives from the development and the test team will come together with the customer and identify acceptance criteria for future functions (Fig. 5). Here, testers and programmers ([5] see.) A common understanding of the customer's needs, with a sufficiently large room for different design decisions remains open. So programmers and testers can find a solution to the problem of the customer, with which it can be satisfied in the long term.

The entire team of customers, programmers and testers should be a common understanding of the functions resulting have (Fig. 5).The entire team of customers, programmers and testers should be a common understanding of the functions resulting have (Fig. 5).

Based on the above acceptance criteria, the development team initially working on descriptive examples they before moving the function, however, continue to refine. Examples push it succinctly and accurately what is to be achieved through the functions. They move on a level with the business requirements and should have nothing to do with implementation details such as the position of GUI elements.

In parallel with the implementation of the functions of the team then works to automate the examples. Some developers groups are even able to integrate the business logic of the business cases based on their domain code. The literature speaks of Outside-In Development: The development is driven from outside to inside. In this case only as much domain code and application logic is designed and written as is absolutely necessary. Practically, there are a few teams that have reached such a level of maturity. The advantages of this approach, however, are not to be dismissed out of hand: Can be before the development show that the proposed application will execute what they want, then the flexibility to changes in the requirements the long term.

Total TDD and ATDD form a symbiosis with which a high degree can be achieved on test automation. Thus, is possible by ATDD a request cover close to 100 percent, while with TDD 100 percent code coverage is possible. Combined TDD thus ensures that the code was correct, while ATDD ensures that it is the correct code.