When we are testing something we are checking whether it is OK’. Testing is necessary because we all make mistakes. Some of those mistakes are unimportant, but some of them are expensive or dangerous. We need to check everything and anything we produce because things can always go wrong — humans make mistakes all the time — it is what we do best!
Software testing is a process to ensure that the software application is error-free. Testing in software is a fundamental process for creating reliable and usable products. By detecting errors and mistakes that affect the quality of software, these testers can ensure that software products are worthy of being sold in the market.
Thus, they guarantee a software’s usefulness and help turn software applications into end-products that perform the way their designers intended them to.
There are seven principles in software testing:
- 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
1) Testing shows the presence of defects:
Software testing reduces the defects, but no one assures that the software is 100% bug-free even after multiple testing. Testing can reduce defects but not remove all defects.
2) Exhaustive testing is not possible:
It is the process of testing the functionality of the software in all possible inputs and pre-conditions is known as exhaustive testing. Exhaustive testing is impossible means the software can never test at every test case. It can test only some test cases and assume that the software is correct and it will produce the correct output in every test case. If the software will test every test case then it will take more cost, effort, etc., which is impractical.
3) Early testing:
For better performance of software, we should start testing at the initial phase i.e., the requirement analysis phase.
Start testing as soon as possible. Finding defects early on saves a lot of money rather than finding them later.
4) Defect clustering:
In a project, a small number of modules can contain most of the defects. Pareto Principle to software testing state that 80% of software defect comes from 20% of modules.
5) Pesticide paradox:
Repeating the same test cases, again and again, will not find new bugs. So it is necessary to review the test cases and add or update test cases to find new bugs.
6) Testing is context-dependent:
The testing approach depends on the context of the software developed. Different types of software need to perform different types of testing. For example, The testing of the e-commerce site is different from the testing of the Android application.
7) Absence of errors fallacy:
If a built software is 99% bug-free but does not follow the user requirement then it is unusable. It is not only necessary that software is 99% bug-free but it is also mandatory to fulfill all the customer requirements.
Conclusion
Above 7 priniciples helps us to understand testing in depth, and how testing should be done. But, personally, I believe testing is an art of finding error, and it can vary from person to person (some say even gender-wise, pun intended :D).
Oh, great! Now that you are here, time to motivate me. Click claps, and share this blog.
Be the bugs with you. Hail Testers \m/
