Author - StudySection Post Views - 72 views
Testing

Seven Principles of Software Testing

Introduction

Software Testing is a process to check whether the software matches expected requirements and to ensure that the software is bug or error-free, or we can also say that Software testing is the method in which the aim is to find the error. If testing is done carefully it will remove all the errors from the software.

There are seven principles in testing:

  1. Testing shows the presence of defects
  2. Exhaustive testing is not possible
  3. Early testing
  4. Defect clustering
  5. Pesticide paradox
  6. Testing is context-dependent
  7. Absence of errors fallacy
  • Testing shows the presence of defects:
    The purpose of testing is to find the errors or defects in software. Software testing just helps in reducing the presence of defects. In this testing, we talk about the presence of errors and don’t talk about the absence of errors. It can ensure that defects are there in the software but it can never prove that software is defects or error-free. Even multiple testers can’t ensure that software is 100% bug-free. Testing can reduce the number of errors or bugs but not remove all defects.
  • Exhaustive testing is not possible:
    Software testing is a process of checking the functionality of the software in all possible inputs (valid or invalid) and pre-conditions are known as exhaustive testing. Exhaustive testing is impossible, meaning the software can never test at every test case. Software testing 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 tester tests every test case then it will take more cost, effort, etc. and which is impractical.
  • Early Testing:
    The testing must be started from the early phase of SDLC so that we could plan in advance and lower the Time, defects, and expenses. For better performance of software, the test process must start at the requirement analysis phase.
  • Defect clustering:
    Generally, a small number of the modules in a project contains most of the defects. Pareto Principle to software testing states that 80% of software defects come from 20% of modules. If we do the same tests over and over again, eventually the same test cases will no longer find new bugs.
  • Pesticide paradox:
    When we use the same test cases, again and again, we will not find new bugs. So it is important to review the test cases time by time and add or update test cases to help find more defects.
  • Context-dependent:
    The testing approach depends on the different types the software developed. Different types of software or websites need to use different types of approaches. For example, The test process of the Marketing site is different from that of the Android application.
  • Absence of errors fallacy:
    If a software does not follow the user requirement then it is unusable even if the software is 99% bug-free. It is not only required that software is 99% bug-free but it is also mandatory that it will fulfill all the customer requirements.

If you have skills in PHP programming and you want to enhance your career in this field, a PHP certification from StudySection can help you reach your desired goals. Both beginner level and expert level PHP Certification Exams are offered by StudySection along with other programming certification exams.

Leave a Reply

Your email address will not be published.