UsingEclEmmatoWriteBetterUnitTests-梓潼大橙子建站

新闻中心

这里有您想知道的互联网营销解决方案

UsingEclEmmatoWriteBetterUnitTests

转载：http://ericanderson.us/2008/05/08/using-eclemma-to-write-better-unit-tests/

成都创新互联公司云计算的互联网服务提供商,拥有超过13年的服务器租用、遂宁服务器托管、云服务器、网站空间、网站系统开发经验，已先后获得国家工业和信息化部颁发的互联网数据中心业务许可证。专业提供云主机、网站空间、申请域名、VPS主机、云服务器、香港云服务器、免备案服务器等。

If you don’t already write unit tests you should be. (Hey, why aren’t you writing unit tests?) Unit testing has so many benefits and the upfront developer cost to write some unit tests can pay huge dividends later when you aren’t spending time debugging broken code nor attempting to save face due to clueless mistakes. You can also use them as a contract to the expectations of your implementations.

[@more@]

So, assuming you have some unit tests, how useful are they if they don’t test everything? At some level you will want to have a good idea that you’re testing everything. (NOTE: I mean everything really important. Writing perfect 100% coverage like this would likely be too expensive for the entire codebase.) This is where Emma comes in (and more importantly for us, EclEmma, an Eclipse plugin for Emma). Emma is a code coverage tool which lets you visual which parts of your code get executed during some execution (regular or JUnit).

Lets walk through using EclEmma to ensure that we have adequate testing being done. Lets test the following two classes.

GuessTheNumber.java:

view sourceprint?
import java.util.Random; 

public class GuessTheNumber { 

   private final Integer value; 
   private final int min; 
   private final int max; 
   private int guesses = 0; 
   private boolean solved = false; 

   public GuessTheNumber(int min, int max, int value) { 
       this.min = min; 
       this.max = max; 
       this.value = value; 
   } 

   public GuessTheNumber(int min, int max) { 
       this(min, max, getRandomNumber(min, max)); 

   } 

   public int guess(int i) { 
       if (solved) 
           throw new IllegalStateException(); 

       guesses++; 

       int ret = value.compareTo(i); 

       if (ret == 0) 
           solved = true; 

       return ret; 
   } 

   public void resetCount() { 
       guesses = 0; 
       solved = false; 
   } 

   public int getValue() { 
       if (solved == false) 
           throw new IllegalStateException(); 

       return value; 
   } 

   public int getMin() { return min; } 
   public int getMax() { return max; } 

   private static int getRandomNumber(int min, int max) { 
       return new Random().nextInt(max - min + 1) + min; 
   } 
}

And SequentialStrategy.java:

view sourceprint?
public class SequentialStrategy { 

   private final GuessTheNumber guesser; 

   public SequentialStrategy(GuessTheNumber guesser) { 
       this.guesser = guesser; 
   } 

   public int solve() { 
       for (int i=guesser.getMin(); i< =guesser.getMax(); i++) { 
           if (guesser.guess(i) == 0) 
               return i; 
       } 

       throw new IllegalStateException(); 
   } 
}

Finally, we’ll write up a basic StrategyTest.java:

view sourceprint?
import junit.framework.TestCase; 

public class StrategyTest extends TestCase { 

   public void testSequentialStrategy() { 
       GuessTheNumber guesser = new GuessTheNumber(5, 100); 
       SequentialStrategy strategy = new SequentialStrategy(guesser); 

       int value = strategy.solve(); 
       assertEquals(guesser.getValue(), value); 
   } 
}

So the question is, how good is our test? If you installed EclEmma, you can right click on your Unit Test in Eclipse, head to “Coverage As” -> “JUnit Test”

Using EclEmma to Write Better Unit Tests

This will run your unit test against your code and when complete, highlight the code green, yellow, or red for covered, partially-covered, and not-covered respectively.

According to EclEmma, our code coverage when running StrategyTest is:
Using EclEmma to Write Better Unit Tests

Thats not too bad, lets take a look at the output for SequentialStrategy:
Using EclEmma to Write Better Unit Tests

We may want to test the IllegalStateException since we currently don’t and we are expecting it to happen if we’ve guessed everything between min and max and haven’t solved the problem. This would ensure if someone else comes in behind us and changes this code, the unit test will fail if they take that out and change it to return, say, Integer.MIN_VALUE.

Lets also take a look at some of GuessTheNumber:
Using EclEmma to Write Better Unit Tests

It appears we also want the contract to include an IllegalStateException being thrown if you have already solved the guessing game. It also looks like we don’t ever call resetCount() and possibly retest after doing that. We also never check if getValue() fails prior to having a solution.

If we modify the test slightly to:

view sourceprint?
import junit.framework.TestCase; 

public class StrategyTest extends TestCase { 

   public void testSequentialStrategy() { 
       GuessTheNumber guesser = new GuessTheNumber(5, 100); 
       SequentialStrategy strategy = new SequentialStrategy(guesser); 

       for (int i=0; i<3; i++) { 
           try { 
               guesser.getValue(); 
               fail("An exception should have been thrown"); 
           } 
           catch (IllegalStateException ex) { /**/ } 

           int value = strategy.solve(); 
           assertEquals(guesser.getValue(), value); 

           try { 
               guesser.guess(guesser.getMax() + 1); 
               fail("Shouldn't reach this point"); 
           } 
           catch (IllegalStateException ex) {/**/} 

           guesser.resetCount(); 
       } 
   } 

   public void testBadGuessGame() { 
       GuessTheNumber guesser = new GuessTheNumber(1, 10, 3000); 
       SequentialStrategy strategy = new SequentialStrategy(guesser); 

       try { 
           strategy.solve(); 
           fail("Should not reach this point"); 
       } 
       catch (IllegalStateException ex) { /**/ } 
   } 
}

And now our code coverage is:
Using EclEmma to Write Better Unit Tests

I know this was a very basic example that really didn’t test any complex logic or conditions, but I hope it gives you a good idea of how you can use code coverage to improve your unit tests.

Rant: Using Error Codes in User Messages »

« Consistent Hashing

-->
分享题目：UsingEclEmmatoWriteBetterUnitTests
标题链接：http://sczitong.cn/article/gdohis.html

新闻中心

其他资讯