In the last few decades, software development methods and techniques have advanced rapidly. In this scenario, it has become all the more important to achieve optimum test results when software testing is conducted. This has led to the emergence of some basic principles of software testing. The principles can be treated as basic guidelines that will help you to follow the correct testing strategy for best possible results.
There are seven basic principles of software testing.
- Testing is Context Dependent
- Exhaustive Testing is not Possible
- Early Testing
- Defect Clustering
- Pesticide Paradox
- Absence of Error is a Fallacy
- Testing Shows Presence of Defects
Testing is Context Dependent
All software products and applications are different. Each application has varying requirements and functionalities. Hence the testing of each of These diverse types of applications needs to be based on the context for which it has been developed. For instance, testing a gaming software will be very different from testing an ATM machine.
Therefore the type of application will determine the type of testing to be carried out. This in turn, will establish the testing approach, testing methodologies and the testing techniques to be followed.
Exhaustive Testing is not Possible
Testing every possible test scenario with different combinations of test data and preconditions is next to impossible. Therefore, testing efforts are focused on primarily managing the risks of the application.
For instance, suppose you need to test an application screen with 30 input fields. Around 20 input fields can take any of five possible values. Now imagine the time that would be required to test all possible combinations of data. Would the project timelines allow time for such exhaustive testing that would, in turn, add to the testing costs? Obviously, this is unlikely. Therefore managing the risks of the software application should be the primary focus of testing a software application.
Early Testing
Testing should always begin early in the Software Development Life Cycle (SDLC). This helps in capturing defects in the early stages of software development itself. Defects can be identified early by creating test cases for each phase in the development cycle.
Identifying defects in the early phases, such as the requirements or design phases of the SDLC respectively, makes it easier and cheaper to fix the faults. Remember it is always easier and at the same time cheaper to correct a faulty requirement that to modify the functionality in a large and complex system
Defect Clustering
This principle is based on Pareto’s principle to software testing:
80% of the errors are found in approximately 20% of the software modules.
Most of the defects in an application are usually clustered or concentrated in a small number of modules. These modules become risky modules and therefore need to be tested thoroughly. So the important task for the tester is to identify and focus on these small clusters, of course, while working concurrently in the not so sensitive areas.
Pesticide Paradox
In farming, you may have noticed that if you keep on using the same pesticide again and again to get rid of insects, then after a period of time the insects will become immune to the pesticide.
Similarly, if the same set of tests is carried out repeatedly, eventually the test cases and methodologies will not be able to detect new defects. Therefore, it is imperative that test are reviewed regularly and existing techniques are updated continuously to overcome the ‘Pesticide Paradox’.
Absence of Error is a Fallacy
If the software application developed does not meet business need and requirements, then it may be rendered unusable, and finding bugs in the system will not be of any help. Alternately, it may be possible that if the system is found to be error-free, then it may be because the system was tested entirely for wrong requirements.
Therefore, catering to user needs and the overall business requirements is an important criteria in software development and testing.
Testing Shows Presence of Defects
The software testing principle always indicates that there are bugs in the application. Also, testing an application thoroughly will not guarantee a hundred percent defect free product. But, it is important to note that testing definitely minimizes errors in the product.
Therefore, the goal should be to design relevant and appropriate test cases that can detect as many faults as possible in the software system.
