The question is not very clear itself.Though I am trying to 
answer this.

When developer receives one bug from tester and if he/she 
starts working on that bug changing the STATUS of the bug 
as IN PROGRESS.After that the bug is sent back to the 
tester and if tester doesn't find any bug then the bug is 
CLOSED.And is developer gets one bug and while executing 
the bug he/she does not find any bug then developer changes 
the STATUS of the bug as REJECTED and sent back to the 
tester,tester again check,and if there is no bug then the 
STATUS will be changed to CLOSED.

Hi Rudraneel i am very happy to your response,but i am not 
asking about bug life cycle,you can go thru question again 
and reply me once.Once again i will repeat the question 
again...........

Whenever developer will recieved the defect from the 
tester,then he will go thru the defect whether it is 
acceptable or not?for that he will execute that application 
again,while executing if he did not found any such type of 
defect(what we are rise the defect above),then he will send 
that defect to the corresponding tester with status 
of 'reject',as a tester what we can do?(here  writing the 
reproduce steps and attached  screen shots has been done by 
tester while sending the defect to the developer)

1)Tester verifies the bug and marked the bug reproducible 
or closed 
2)Tester assign the bug to TL (if reproducible) 

I request member to comment sincerely on this as this is a 
live situation and no body gives proper solution to it.

Here in the above situation if the developer Rejects the bug
then when we have to send them the steps, describing how we
got the bugs and also attach the screen shots of the bug we got.

IF bug is reproducible then as a tester u suppose to call 
that developer and execute that bug. U can refer retest 
concept for this  problem In front of developer.

Tell developer to fix the bug as It works for me and you 
should close the bug. it is not your headache it is for 
developers. ok .

excuse if i am wrong

If developer i not getting any error its the mistake of
tester.he should do retesting for the particular bug and
make the bug is resolved.if again it is not  resolved u will
be reported to the test lead.

c in this Situation, after u get reject from the developer,
1.Open the SRS and take the requirements from the developer
of that particular module, re-test again.
2.Reproduce the bug with Step by Step clearly attached with
the screen shot step by step.
3.Even though if the developer reject, u can inform to u r TL.
4. He will make interact with the PM and the Developer TL.

I Think this Answer is Enough

Hi, 

Well there are situations in which the bug may not be 
reproducible in the development machine (due to envirnoment 
issues,etc) and so the Developer rejects the Bug. In such a 
case a tester can share his testing envirnoment details 
with the developer where the developer can repro the issue. 

Once the developer sees himself the issue he can further 
debug to find the reason why bug is coming on Testing 
envirnoment.And i am sure he will work on this and get it 
fixed. 

Thanks
Smaranika

Ya i agree with smaranika. some bugs we cant produce on 
developer envirnoment whatever we got on testing 
envirnoment.In this case we have to call that perticular 
developer and showed him on tester machine and then also he 
is not accepting then inform to ur TL or PM and prove that 
it is a valid bug

Hi there are some chanses that the bug can not produce at 
Developer place. These may be due to the wrong steps 
followed by the developer as the Tester described or may be 
due to the Environment change bw dev and tester or May b 
the Developer intentionally makes it CNR or so...

In this case, the Tester need to take the Step by step 
Screen shots or atleast the screen shot of the Bug and can 
send it to the developer with involving Higher Management 
(TL, PM, QM) to prove ur bug is a BUG.

It is sure that u'll prove ur bug still if developer not 
intended to fix, you can recomment dev to make the status 
of the bug to NIF (No Intension to Fix).