StudyMoose App
24/7 writing help on your phone
Save to my list
Remove from my list
Testing is a critical stage and complex activity in software development life cycle (SDLC) and to make sure it is done successfully there are many principles to follow. These principles are considered as the general rules or the main guidelines for the testing team. These principles have been established over the years.
The conclusion of these principles is admitting that no system is 100% error free and you cannot execute all the test cases. A main principle also is starting testing stage early to easily correct the defects.
There is also a main point we should take it into account while testing, techniques of testing depends on the nature of application. Applying and considering these principles leads to the maximum benefit of testing.
Software testing is an important stage in software development life cycle and it is the process of identifying the correctness, completeness and the quality of the software by analyzing it. It also means executing set of activities in a systematic way to detect any errors or defects in the system and to find differences between the existing and the required so finally we satisfy the specified requirements.
5 (204)
“ She followed all my directions. It was really easy to contact her and respond very fast as well. ”
The following figure shows the (SDLC).
The testing objective is first to test the code, in which there is high probability to find errors. The objective also shows and makes sure that the system works directly according to the software requirements specifications (SRS). Basically the successful test is the one that detects all the undiscovered errors yet.
Testing is a complex process and it is important to achieve the optimal results without deviating from the main objective. We had to establish some principles which considered as guidelines for the testing team to help them utilizing their time and effort to make this process effective as much as possible. These principles were suggested over 40 years ago to make sure the testing team is going in the right way and following the right methodology.
To maximize the effectiveness of the testing stage, first, use good test design techniques which are all based on certain testing principles and there are seven main principles will be discussed in this chapter
Testing shows presence of defects:
The main objective of testing is to find one or more defects so, the process of testing is designed in a way to find as much as possible defects. Testing reduces the probability of defects as we stated before, but if it did not find defects it does not mean that there is no defects at all or the system is 100% bug free because the main idea in this principle is the presence of defects not absence.
Exhaustive testing is impossible:
Exhaustive testing is an approach of testing in which we test all possible values for all inputs combined with valid and invalid preconditions. This principle means we cannot test all the test cases because this takes much effort, cost and time and the project timelines may not allow testing many number of combinations. We consider each test is a sample and the test effort must be controlled, considering risks and priorities.
For example suppose there is an input field which accepts alphabets, special characters, and numbers from 0 to 1000. Imagine how many combinations would appear for testing, it is not possible to test all combinations for each input. For that we say that exhaustive testing is not possible.
Early testing:
testing activities must start early as much as possible in the software developing life cycle(SDLC) to focus on specific objectives which means finding defects early. For example, the requirements document is the base of acceptance test, so we can start testing whenever this requirement document is available and ready.
The techniques and methods of early testing shows that defects in the system specifications surely effects on the requirement document if they are not found and corrected and so on for the other next stages in SDLC. The other benefit of early testing is it is cheaper to correct a defect in the early stages than later stages and the following figure and table shows how delaying testing causes much loss of money.
The stage in which error is found
| Requirements | Coding | Program Testing | System Testing | User Acceptance Test | Live Running |
|---|---|---|---|---|---|
| $1 | $10 | $100 | $1,000 | $10,000 | $100,000 |
Table 2.1
The following figure shows how testing is done parallel with other stages of (SDLC) as in V-model.
Finally we have to admit that nothing is better than starting testing early.
Defect clustering:
The defects in the system most probably are not distributed, they are clustered. In most projects and systems small modules can have the large percentage of defects. According to Pareto principle which is applied to optimization problems and efforts, 80% of defects come from only 20% of modules. This high percentage comes from many reasons like code complexity which is related to module complexity, system complexity and inexperienced developers.
Developers mustn’t only focus on that 80% of modules of course they have the most number of bugs but the other 20% also may have defects. Finally if the same test is repeated over and over again there will be no defects.
The following figure shows some modules being tested for banking applications, most defects are in the “overdraft” module.
Pesticide paradox:
Using the same pesticide to eradicate insects during farming with time going by leads the insects to develop resistance to the pesticide so it will not be effective on insects. The same happens in software testing, if there is module needs to be tested to find out defects, with testing team efforts and iterations the system will be improved and the number of defects increases. But at some point and with repeating the same test cases over and over again these test cases are not able enough to find some defects.
To help solving this problem there are two methods which testing team can follow:
Testing is context dependent:
Software is used in many domains for example banking, medical, travelling, shopping and son on and each domain has its applications. Due to the difference of domains and its usage environment there must be difference in requirements, functionalities techniques and also testing purpose.
For example a website where information can be simply viewed will be tested in a different way to an E-commerce site, where people can by things using credit cards. We should focus on security tests so the password and the data of the user will be safe and not easily hacked.
Absence of errors:
If the test is done and there is no defects then we say it is 99% defect free system, but if this test was done according to wrong requirements that means however defects are found and however fixing them is not enough and that will not help improving the performance of the system because you are working on requirements different from user’s requirements.
The system must fit the business needs or it will be useless so it is very important to clearly understand the user’s requirements to execute the right test because different test means different techniques, methods and approaches. For example testing the system of any shop is different from testing the system of ATM.
So finally we can say that understanding the right requirements leads to execute the right test which makes the performance the best.
Finally and after discussing the above principles we find out that testing is not an easy or flexible stage at all. It requires specific methodology and guidelines to get the maximum profit and to provide all users requirements. Tests should be planned long before testing begins. After the requirements stage is completed, test planning should begin so testing can be started early as soon as possible. Also Testing should begin “in the small” and progress toward testing “in the large.”
At first tests should generally focus on individual components and while testing progresses, the focus is shifted to find errors in integrated clusters of components and finally in the entire system. The most important point which has high impact on the effectiveness of testing is the software engineer who has created the system is not the best person to conduct all tests for the software because the independent tester will drive the system into quality.
Guiding Principles for Effective Software Testing. (2024, Feb 19). Retrieved from https://studymoose.com/document/guiding-principles-for-effective-software-testing
👋 Hi! I’m your smart assistant Amy!
Don’t know where to start? Type your requirements and I’ll connect you to an academic expert within 3 minutes.
get help with your assignment
