On my current project, some developers discovered that they could test private methods using reflection. I asserted my opinion(which of course rarely happens) that we shouldn't be testing private methods. My point was that my public methods are my interface to let others know how to use my class. My tests are a verification of that contract. If something changes to break that contract it will let me know. Its sort of a contract on a contract. So after a lively discussion about it, I did some research (I googled) and found that there is indeed some debate on the matter.
Instead of rehashing that debate, I would like to add another view, that once developers can test private methods, they do it without thinking of alternatives. I never say never, so I'm not totally against the idea of testing these private methods, but it just feels wrong. I think once developers have a test around a complex method they stop. My mantra is if its hard to test, then something is wrong with your design.
The methods I have seen with private methods tested usually have some side effects. They are changing class level variables or the arguments of the method without any return values. Sometime they are just encapsulating some complex behavior that should moved into another class.
Test Driven Development (TDD) is not so much about testability but about designing for testability. A application that is redesigned to be easily testable is an application with less coupling, more focused objects and less side effects of the methods.
I realize that with the pressures of deadlines and legacy code, its not always possible to refactor and testing private methods could be a solution to get more test coverage. I just think we should first try to refactor and only if that isn't feasible should we test private methods.
If you do find that you must test private methods, Bill Venners has a good article on testing private methods, I particularly like his translating the reflection exceptions into assert exceptions. He also has a good example of the kind of private methods that are hard to test.