Bug Life Cycle - An Overview
Do you even wonder that bug has a life cycle? Sounds interesting! Well, lets see what is Bug Life Cycle all about. Before that, what is a bug or defect in software testing terminology?
Let us take a banking application to understand what is bug.
Let us assume you want to use the Internet Banking facility available for you. So now you go the bank's website and try to log in with the valid credentials, say your user name and password. Now you have entered the credentials and press the Enter Button. It does not get redirected to any page but you stay in the same page where you are and the credentials you entered disappear. Now you again enter the details and now you happen to see the same behavior, which is not the expected outcome. We can call it as a bug.
A bug is anything, which causes the application or the software to behave in a manner that it is not supposed to. It can also be referred as any deviation in the software program, which causes the program to behave in an unpredictable manner. It can be referred as a defect/mistake/flaw.
Now you might also quiz your brain why do software have defects?
Simple, because its been developed by humans like us and mistakes are inevitable. There are lots of other factors that boost the chances of having bugs in software.
Secondly, in many projects the requirements are not stable and it keeps changing where the designers have to modify the code till the end, which in turn leads to buggy software.
Programming errors, difficulty in understanding the technology, time constraints all together pave way for defects in the software.
So with such an introduction let us go deep into the bug/defect life cycle.
Defect Life Cycle: The time the bug is reported (i.e. when it enters the NEW state) till the time the bug is tracked to closure can be considered as life span of the bug.
1.When the test engineer finds a bug it takes the "NEW" State.
2.The bug is then assigned to the developer for fixing the bug and it enters the "ASSIGNED" State.
3.These are some of the possible resolutions that a bug can take.
Fixed -The developer has fixed the bug
Wont Fix -The developer will not fix the bug due to time, requirement constraints etc.
Deferred -The bug will not be fixed in this iteration but it will be fixed at a later releases.
Invalid -The developer deems the bug to be a not valid bug
Duplicate-The bug is already reported (i.e.) the bug exists already.
4.From here the bug takes different flows based on the resolution.
If the bug is fixed it is sent to the test engineer for verifying the bug. If it is verified it enters the "VERIFIED" state and finally the bug is closed. If the fix is not working, then the bug is reopened and it enters the "REOPENED" state and assigned to the developer. The developer has to fix the bug and the same process gets repeated.
The simple pictorial representation of the bug life cycle is given for reference. Just have a look at the attachment