7 principles in software testing

Tram Ho

Software testing is the process of performing a program test to find errors. There are 7 principles in software testing as follows:

7 principles of software testing

1. Testing show presence of defect – Testing to show errors

Testing indicates the presence of an error in the software but cannot prove that the software is error free.

Testing helps reduce the probability of potential bugs still in the software, but even if no more defects are found, it is not possible to confirm that the software is free from bugs. It is also not a proof of the software’s correctness. Instead, all tests confirm that the software meets all business requirements and it operates according to the needs of the end user.

2. Exhaustive testing is impossible- Complete test – Comprehensive testing is not possible

Comprehensive testing is not feasible.

Exhaustive testing is impossible

We simply understand that it is impossible to test all functions with all valid and invalid input data combinations during the actual test.

Why not comprehensive testing?

  • Testers need to complete many different testing activities within a strict time budget.
  • Programs may also have more states. That is, one input, valid at one particular point, may not be valid at another.
  • Testing all possible test execution environments is not feasible.
  • It is impossible to test all possible outputs or a sequence of operations with comprehensive testing.
  • Moreover, the design may be too complex to perform performance tests.

Exhaustive testing is impossible

Instead of testing everything, risk analysis and prioritization are used to focus on testing.

3. Early testing- Test as soon as possible

Early testing

Test activities should start as soon as possible in the software development process and should focus on the defined goal.

The sooner you implement the design and review the test, the sooner the error will be discovered, the less time and effort it will take to find and fix the error.

4. Defect clustering: defect density – The concentration of errors

Defect Clustering

Testing experts have pointed out that the bugs will be concentrated in certain modules rather than spread across all modules of the product, so when detecting a bug of a certain module, it is necessary to further test to make sure you find the most potential bugs.

To better understand this principle, we should consider the following 3:

  • The principle of cockroach nest: Where there are several cockroaches (bugs), it means that there will be very close to the cockroach nest, which means that there will be a lot of cockroaches. If there are a few bugs around, near there will be many bugs.
  • 80/20 rule: normally 20% of the important functions in a program can cause up to 80% of the total bugs detected in that program.
  • Exhaustive testing is impossible (second principle): therefore it is necessary to ananlysis (analysis) and priorities (to determine the priority) to decide where to focus on the test.

5. Pesticide paradox – Principles of pesticides

Pesticide paradox

If the tests are repeatedly performed, no new errors can be found. The effectiveness of test cases begins to decrease after a number of runs.

To overcome this pesticide principle, test cases need to be regularly reviewed and revised. Test new and different so you can find more potential errors.

6. Testing is context dependence – Testing is context dependent

Testing is context dependence

Tests are performed differently in different contexts.

The context here is the nature of the applications to which we will apply different methods, techniques, and types of testing. For example, software developed to serve industries that need high security such as banking, healthcare, education, the testing of errors needs to be checked more and more carefully to ensure absolute safety. reveal internal information.

We can use different approaches, techniques, and tests based on different types of applications

7. Absence of error fallacy- The mistake of not having an error

Absence of error fallacy

All specified requests and all errors found can still create a system that is difficult to use, does not meet user needs and expectations, or is inferior to systems. other competition.

Software is built not only software without 99% error but also to meet business needs or it will become an unusable software.

Conclude

Understanding the principles of software testing will make it easier for you to test and minimize the risks as well as be effective in the process of implementing any application.

Refer

https://www.geeksforgeeks.org/software-engineering-seven-principles-of-software-testing/ https://www.istqb.org/downloads/glossary.html

Share the news now

Source : Viblo