Developers testing their own code – what will be the testing output? All happy endings! Yes, the person who develops the code generally sees only happy paths of the product and don’t want to go in much details.
The main concern of developer testing is – misunderstanding of requirements. If requirements are misunderstood by developer then no matter at what depth developer test the application, he will never find the error. The first place where the bug gets introduced will remain till end, as developer will see it as functionality.
Confident developers – Developers wrote the code and they are assured it’s working properly. No need to test this path, no need to test that path, as they know it’s working properly. And right here developers skip the bugs.
Developer vs Tester: Developer always wants to see their code working properly. So they will test it to check if it’s working correctly. But you know why tester will test the application? To make it fail in any way, and tester surely will test how application is not working correctly. This is the main difference in testing done by developers and testers.
Should developers test their own Code?
I personally don’t mind developers testing their own code. After all it’s there baby .They know their code very well. They know what the traps in their codes are. Where it can fail, where to concentrate more, which is important path of the application. Developer can do unit testing very well and can effectively identify boundary cases.
This is all applicable to a developer who is a good tester! But most of the developers consider testing as painful job, even they know the system well, due to their sloppiness they tend to skip many testing paths, as it’s a very painful experience for them. If developers find any errors in their code in unit testing then it’s comparatively easier to fix, as the code is fresh to them, rather than getting the bug from testers after two-three days. But this only possible if the developer is interested in doing that much testing.
Its tester’s responsibility to make sure each and every path is tested or not. Testers should ideally give importance to all small possible details to verify application is not breaking anywhere.
Developers should not review their own code. Generally they will overlook the issues in their code. So give it to testers for review.
Everyone is having specialization in particular subject. Developers generally think how to develop the application on the other hand testers think how the end user is going to use the application.Conclusion
Finally i like to say that there is no problem if developers are doing the basic unit testing and basic verification testing. Developers can test few exceptional conditions they know are critical and should not be missed. But there are some great testers out there. Through the build to test team. For victory of any project there should be independent testing team validating developer’s applications.