If I already have integration test for my program, and they all passed, then I have a good feel that it will work. Then what are the reasons to write/add unit tests? Since I already have to write integration tests anyway, I will like to only write unit test for parts that not covered by integration tests.

What I know the benefit of unit test over integration test are


Small and hence fast to run (but adding new unit to test something is already tested by integration test means my total test suit get larger and longer to run)
Locate bug easier because it only test one thing (but I can start write unit test to verify each individual part when my integration test failed)
Find bug that may not be caught in integration test. e.g. masking/offsetting bugs. (but if my integration tests all passes, which means my program will work even some hidden bug exists. So find/fix these bugs are not really high priority unless they start breaking future integration tests or cause performance problem )


And we always want to write less code, but write unit tests need lots more code (mainly setup mock objects). The difference between some of my unit tests and integration tests is that in unit tests, I use mock object, and in integration tests, I use real object. Which have lots of duplication and I don't like duplicated code, even in tests because this add overhead to change code behavior (refactor tool cannot do all work all the time).

You've laid out good arguments for and against unit testing.  So you have to ask yourself, "Do I see value in the positive arguments that outweigh the costs in the negative ones?"  I certainly do:  


Small-and-fast is a nice aspect of unit testing, although by no means the most important.
Locating-bug[s]-easier is extremely valuable.  Many studies of professional software development have shown that the cost of a bug rises steeply as it ages and moves down the software-delivery pipeline.
Finding-masked-bugs is valuable.  When you know that a particular component has all of its behaviors verified, you can use it in ways that it was not previously used, with confidence.  If the only verification is via integration testing, you only know that its current uses behave correctly.
Mocking is costly in real-world cases, and maintaining mocks is doubly so.  In fact, when mocking "interesting" objects or interfaces, you might even need tests that verify that your mock objects correctly model your real objects!


In my book, the pros outweigh the cons.
