Software Testing - 7 Principles

The software testing process is one of the most important phases towards a successful software development. The testing is quite a difficult, cumbersome and time-taking activity. In order to increase its effectiveness, it is necessary to be guided by some principles to reap the maximum benefits from software testing.

The 7 principles of testing are listed below −

Testing Exposes Presence of Defects

Once a software comes from the development to the testing team’s bucket, it is thoroughly tested using the various layers, types, methodologies of testing. As a result, all probable bugs in the software get uncovered, and finally resolved. Also, a software goes through multiple cycles to detect as many bugs as possible.

In spite of all the testing efforts, there is no guarantee that the delivered software is entirely defect free. There may exist some scenarios which might not be tested. Thus testing only reduces the possibility of encountering bugs in the software, but it does not assure it to be 100 percent defect free.

Exhaustive Testing is Impossible

While a software is being tested, it is impossible to cover all possible combinations of prerequisites, data, scenarios, use cases etc. Besides, exhaustive testing requires a lot of time, effort, and cost. Instead of doing so, an attempt should be made to choose the best, optimal, and most effective set of test cases, rather than testing all combinations. The best choice of test cases can be done only through experiences, knowledge of software, and analyzing all the possible risks and their mitigations.

Defect Clustering

It is observed that a maximum number of defects are identified from a small count of modules of the software. This comes from the Pareto principle in testing. It states that eighty percent of the defects originated from twenty percent components of the software.

Thus it helps to detect the bug prone modules. If a defect is seen from a module, there are high chances of more defects from the same area. But it must be noted that if a similar set of test cases are executed on the same modules repeatedly, the chances of getting newer errors reduce.

Pesticide Paradox

This is based on the fact that if the same pesticide is used over and over again on the vegetation, then ultimately the insects get accustomed, and after a while it becomes ineffective to the insects.

Similarly, if the identical group of test cases are executed over and over again, they become useless as they fail to detect new bugs in the software. To overcome this, it is mandatory to review test cases frequently, add, modify, or delete them based on the new requirements, modules, and functionalities. Also, the test cases should be run against newer combinations or sets of data, and scenarios to identify more bugs.

Early Testing

The testing should begin from the initial stages of the software development life cycle (SDLC), starting with detecting errors in the requirements, design or development stages. It is always better to identify defects at the early stages rather than that right at the end. The cost of fixing the defects are more at the later stages of SDLC. Also, the project deadlines get hampered to fix defects which require recording a critical feature at the later stages.

Testing is Context Dependent

Each software is unique in its own way. For example, a ticket booking application is not the same as an e-commerce application. Hence the testing approaches, strategy, methodologies to verify a ticket booking application is always different from an e-commerce application. Thus a common framework of test strategies does not work for all software, and varies from context to context.

Absence of Error Fallacy

There may be situations where a complete software has been tested thoroughly and there is a ninety-percent chance of no defect being encountered. However, it may be found later that the entire testing was on the basis of incorrect requirements. Thus the software turns out to be without any defects but unusable and unacceptable to the customer. This points to the fact that testing is always not only about detecting defects, it also means verifying if the software is in accordance with the user's needs.

This concludes our comprehensive take on the tutorial on Software Testing 7 Principles. We’ve started with describing what are 7 principles of software testing. This equips you with in-depth knowledge of Software Testing 7 Principles. It is wise to keep practicing what you’ve learned and exploring others relevant to Software Testing to deepen your understanding and expand your horizons.