Quality is delighting customers
simple way to understand bug life cycle..
Bug Tracking involves two main stages: reporting and tracking.
Once you execute the manual and automated tests in a cycle, you report the bugs (or defects) that you detected. The bugs are stored in a database so that you can manage them and analyze the status of your application.
When you report a bug, you record all the information necessary to reproduce and fix it. You also make sure that the QA and development personnel involved in fixing the bug are notified.
Track and Analyze Bugs
The lifecycle of a bug begins when it is reported and ends when it is fixed, verified, and closed.
- First you report New bugs to the database, and provide all necessary information to reproduce, fix, and follow up the bug.
- The Quality Assurance manager or Project manager periodically reviews all New bugs and decides which should be fixed. These bugs are given the status Open and are assigned to a member of the development team.
- Software developers fix the Open bugs and assign them the status Fixed.
- QA personnel test a new build of the application. If a bug does not reoccur, it is Closed. If a bug is detected again, it is reopened.
Communication is an essential part of bug tracking; all members of the development and quality assurance team must be well informed in order to insure that bugs information is up to date and that the most important problems are addressed.
The number of open or fixed bugs is a good indicator of the quality status of your application. You can use data analysis tools such as re-ports and graphs in interpret bug data.
Its good practice to represent bug life cycle with Flow chart.
You didn't mentioned here about rejected scenario.
1.New ----------------------------------- Initial status by tester
2.Open,Reject& Duplicate------------ PM <------ Enhance,Clarification
3.Differed----- pm/tl. Fixed----------- developer <----Unable to reproduce,Work for me
4.Retest------i) Closed ii)Reopen ---- tester
Core phases are NEW---> OPEN---> FIXED---> CLOSED. but Interviewer expects you to explain it in depth:-
Have a serious look at the Below described Bug Life Cycle.
1) New --->2) Opened ----> 3) Rejected . ( May be Reopened in future )
2) New ---> 2) Opened----> 4) Deferred. ( May be Reopened in future )
3) New----> 2) Opened----->5) Assigned. ( Fixing Starts )
4) New-->2)Opened-->5) Assigned--> [ After fixes] 6)Fixed--> [ Retest fails ]-->( 7) Reopened--> 5) Assigned.
5) New----> 2) Opened----> 5) Assigned-----> 6) Fixed--->[ Retest passes] ---> 8) Closed.
Note:- If Problem returns then even the Closed bugs can be Reopened and further Assigned ..
Hope It will surely help You..
Please refer the links below.
There are many steps in bug life cycle :-
1) Reported : First bug is reported by the testers.
2) Opened : Then it is to judge whether that bug is a genuine bug or not. It is done by the test leader.
3) Assigned : That bug is now assigned to a debugger for debugging.
4) Fixed : Debugger fixes the bug.
5) Closed : Tester retests to check whether that bug has debugged or not. If debugged correctly and resolve the bug then the bug is closed.
6) Reopened : If not resolved then reopen it.
7) Deferred : If test leader finds that the bug reported is not a genuine bug the he defers it.
8) Rejected : If at the reporting stage it seems to be like bad report then the bug is rejected.
Thanks and regards
In bug life cycle there are few stages:
4. Awaiting retest
As per best software testing services, defect life Cycle has the following statuses:
New: This state will be assigned when a new defect is encountered.
Assigned: Once the defect is reported, it is reviewed by the QA Lead and it is assigned to the respective developer if it is valid.
Open: State is changed to Open by the developer when the developer analyzed the bug.
Fixed: When the developer makes the code fix for the bug. He/She can change the status of the bug to fixed.
Verified: When the Developer gives the build to the tester, then the tester checks whether the fix is working or not. If the fix is working then tester mark the bug as Verified.
Reopen: When the Developer gives the build to the tester, then the tester checks whether the fix is working or not. If the fix is not working then tester mark the bug as reopened.
Closed: Once the defect is fixed and the tester feels that is is no longer an issue in application/software then tester can mark the status as closed.
Duplicate: If a bug is logged more than once then QA lead/Developer can mark the bug as Duplicate. Also mention the existing reporting Bug ID.
Can not reproduce: When a Developer starts working on a bug, after doing the initial analysis if he finds the bug is not reproducible as per steps mentioned in the description of the bug. Then he can mark the bug as cannot reproduce.
Invalid: When the Developer finds the bug is not reported as per the latest requirements. He/She can mark the bug as Invalid.
Deferred: When the Developer finds that the bug can not be fixed this release. Requirements will be addressed in next release. The Status can be changed to Deferred.
Most software testing services companies use the below Bug Life Cycle:
The number of states that a defect goes through varies from project to project.
Please find the image below: