Bug life cycle in software testing Bugs, like humans, go through stages in their lives, with the first stage being new and the last being being closed.
The actual goal of software testing is to detect flaws so that end users do not have any issues when they try to access the application, so when the developer develops the application or enhances the existing feature of an application, the code that is released is handed to the tester for testing When a tester discovers a bug, he reports it in one of the bug reporting tools and marks the bug’s status as new. The bug is then assigned to the development team, who change the bug’s status to open now from open.
The developer could reject the bug because it isn’t a bug in his opinion, so he changed the status to reject and then closed it. Alternatively, the bug could be marked as a duplicate because an existing bug already exists in the bug tracking tool and there’s no need to mention it again, so the developer will mark the bug as duplicate and ultimately the status will be marked as closed because there is already one bug that is either in open reopen or read test stages in the life cycle and there is no need to mark a similar duplicate bug just to increase the count of the bugs else the developer could mark the open bug as deferred because this feature is not being developed in in this particular release and whatever the issue that the tester is facing will be fixed in the subsequent releases
so the that bug will be marked as deferred and no action will be taken on that bug and finally if the bug that has been found by the tester is relevant bug and it is neither a duplicate bug and not a deferred one then it will be fixed by the developer once the developer fixes the bug he will change the status to fixed and again when the developer will be ready to reassign the bug to the tester he will mark the status as retest when the tester finds a bug with the retest status he again tests that bug and if the bug is properly fixed then the tester will mark the bug as closed but if the bug is not properly fixed then the tester will again reopen the bug and when the developer finds a bug in the open stage he will change he will start working on the bug and once the bug is fixed he will change the status to fix and once he is ready to assign the bug to the tester for retesting then the developer again changes the status to retest and finally the bug will be closed
so these are the most common stages that the bug goes through during its life in in the real world so this is all about bug life cycle and generally there are many bug tracking tools that better that gets used in most projects like cheetah, Bugzilla, quality center etc.