With little nervous when the first time writing .NET application, I tended to apply unit test using NUnit as I did the similar with Java before. Automatic unit test is the highest priority due to the following reasons:

• It improves the quality.
• It improves the framework design quality because unit test code use functions as the client.

Test Driven Development is a methodology requires developer write test code before implementation. Wow, why we need write the test code before. I have read some articles about this methodology and many people said that it improves the quality and design. I transfer these messages to my friends and my colleagues, and the respond from us is negative. But why many people have bad view about TDD, the reason they give me is 'We do not know the detail implementation of function so how can I write unit test code first'. Ah, the behind of scenes that they do not have detail functionalities of what they want first. And this is a big problem not only for junior developer but developer has many years experienced.

I think TDD is the benefit but it is the first time to apply it to my work (from the Project Manager role, I move to Technical Architect role by promote myself). The first problem I must solve is developing a directory-like cache. As a common cache, in almost case we stores data in a map and access them by key. But it is a "flat" cache, we can not categorize the same meanings of cache data in one place. For example, we store information of member are name and age in cache, we should save:

map.Add("hpnguyen_name", "Nguyen, Hai Phuc");
map.Add("hpnguyen_age", "28");

By using "flat" cache, we can not get all information of related items, so we need a directory cache that helps us get data more efficiently.

map.Add("hpnguyen/Name", "Nguyen, Hai Phuc");
map.Add("hpnguyen/Age", "28");
//newMap is a map with 2 pairs "Name/Nguyen, Hai Phuc"
//and "Age/28"
newMap = map.Get("hpnguyen");

I think it is a medium program for me to start new methodology. First, I write down all functionalities of the cache first. After that, I list the detail cases for each function. For example: Method Get(string key) of cache will do in the following cases:

• Return null if key is null or key is not found in cache.
• Return a sub directory cache if key is not a "leaf".
• Return object if key is a leaf.First, I write down the interface of Cache and its methods. After that, create an implementation for directory cache with empty methods.

Second, write the unit test code with the first very simple test code. With above Get method, I just add simple test code as Assert.IsNull(cache.Get(null)) and I run unit test by using Test Driven Development .NET tool. And it is green. It is not bad at all. Continue write test code and implement. After 4 hours, I have finished implementation of cache directory. And I run NCover to make sure all source codes are passed by test code and the result is nearly 100%, only getter/setter method is not tested. Wow, it is really good and I am sure I do not have any defect of cache directory due to I have passed all unit tests.

After the first project, I continue apply TDD to complete the framework and it is really nice. The engine so great and I have no complains on its quality. No defect at all and it is very flexible to extend for various purposes.

During developing framework, I always keep the unit test code coverage high, nearly only getter/setter or trivial code is not tested. No critical defect is raised and after finish it, it is time to revise all to improve my knowledge.

Question: the test code written first has a good sound. But whether it is more effective than implementation first and writes unit test code after.

Answer: If we finish develop a package, source code and test code of two methodologies are the same. You do not know whether member applying TDD. But applying TDD methodology has the following benefits:

• Detail what you should do first. As I stated before, almost developers do not know exactly what they want when they start implementation.
• Code a little and test a little and continue like that. Some developers wait implementation is finished and they have many pieces of code need to be tested, that makes they throw way, and choose manual test. The consequence is they do not cover all cases needed for testing.
• Improve design architect regularly. All gurus know that unit test help us improve the design and let implementation and unit test go at the same time make you improve your design immediately.

Note: This is written for a while since May 2006. I wrote it in Yahoo 360 and now I move it to here.