Home »
Software Engineering
7 Principles of Software Testing
In this tutorial, we will learn about the seven basic software testing principles that are very important for every software tester and QA professional.
By Monika Sharma Last updated : April 07, 2023
Software testing means to check the software for its correctness, to check whether it is producing the expected results or not. The main aim of the testing is to find and detect the faults and errors produced by the software. Software testing is performed in different ways at different phases of software development. However, there are some stated principles for the testing process of any software. There are seven principles of software testing which are as follows:
The seven basic software testing principles are:
- Testing shows the presence of defects
- Exhaustive testing is not possible
- Early testing
- Defect clustering
- Pesticide paradox
- Testing is context-dependent
- Absence of errors fallacy
Now, let us try to elaborate and understand each of these principles...
1) Testing shows the presence of defects
The main aim of the software testing is to detect the presence of defects in it. Therefore, the test suite on which the software is tested is chosen in such a way that it covers all the possible input ranges. The test cases are chosen in such a way that the behavior of the software in the most complex conditions is also analyzed, and this makes sure that the errors in the software up to every extent are detected.
However, it should be noted that even if the software passes all the test cases successfully, it cannot be said that the software is 100 percent error-free. Some errors may still be there which may occur in the future with the use. However, testing ensures that the errors in the software are detected to its maximum extent.
2) Exhaustive testing is not possible
Exhaustive testing means to check the software for every possible input case. However, this is not possible, because the inputs and conditions that the software will be facing in the future when made available to the user cannot be predicted. Yes they can be estimated up to some extent and the worst-case scenarios can also be analyzed, but still, there is scope for many such inputs for which the software might not produce correct results. Therefore, it is impossible to perform exhaustive testing for any software.
3) Early Testing
This principle states that to minimize the complexity of occurring errors and to make the software cost and time effective, it is better to start testing in the early phases of software development itself. The early the error in the software gets detected, the easier it becomes to correct it and also problems like piling up of errors for the final testing gets reduced by this practice.
4) Defect clustering
It is seen that if there is an error in the module, then I may cause a lot more errors to other modules also. Apart from this, it is also observed that most of the errors come from a single module. This principle is based on the Pareto Principle to software testing which states that 80% of software defect comes from 20% of modules.
5) Pesticide paradox
Pests are usually seen in the fields. It is a common practice that the pesticides used to treat the pests if repeated for a very long time turns out to be ineffective to the pests. In software testing also, if you check the software again and again for the same test case, then no new bug can be detected. Hence it is important to keep changing the test suite while testing the software.
6) Testing is context-dependent
The testing of any software is dependent on the context of the software because the test cases and the run time environment for every software are decided according to the software's context.
7) Absence of errors fallacy
According to this principle, it is not much important to produce a 100 percent error-free software, rather the software must fulfill the user's needs. The errors occurred can still be handled later, but all the user's requirements must be met by the software.