Junit4_单元测试

不多说，直接练习学习。

1、将Junit4单元测试包引入项目：项目右键——“属性”,选择“Java Build Path”，然后到右上选择“Libraries”标签，之后在最右边点击“Add Library…”按钮,选择JUnit4并点击确定。

2.新建一个项目叫JUnit_Test，我们编写一个Calculator待测试类

 public class Calculator {

     public int add(int a, int b) {
         return a + b;
     }

     public int substract(int a, int b) {
         return a - b; // Bug:result=result-n
     }

     public int multiply(int a, int b) {
         return a * b;
     }

     public int divide(int a, int b) throws Exception {
         if(0 == b){
             throw new Exception("除数不能为0");
         }
         return a / b;
     }

     public int square(int n) {
         return n * n;
     }

     public void squareRoot(int n) {
         for (;;)
             ;
     }
 }

3.编写单元测试类

New>"Junit Test Case"，选择New Junit 4 test ,勾选which method stubs would you like to create?

选择Class under test，点击Next，选择方法，Finish。

 package com.test;

 import static org.junit.Assert.*;

 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;

 public class Test1 {

     private Calculator calculator = new Calculator();

     @BeforeClass// 注意,这里必须是static...因为方法将在类被装载的时候就被调用(那时候还没创建实例) 
     public static void setUpBeforeClass() throws Exception {
         System.out.println("global");
     }

     @AfterClass
     public static void tearDownAfterClass() throws Exception {
         System.out.println("global destory");
     }

     @Before
     public void setUp() throws Exception {
         System.out.println("一个测试开始..");
     }

     @After
     public void tearDown() throws Exception {
          System.out.println("一个测试结束..");
     }

     @Ignore
     @Test
     public void testAdd() {
         int result = calculator2.add(1, 2);
         assertEquals(3,result);
     }

     @Test
     public void testSubstract() {
         int result = calculator2.substract(5, 2);
         assertEquals(3, result);

     }

     @Test
     public void testMultiply() {
         int result = calculator2.multiply(4, 2);
         assertEquals(8, result);
     }

     @Test(expected = Exception.class)
     public void testDivide() throws Exception {
         System.out.println("teddd");
         calculator2.divide(4, 0);// 很简单的办法.......
     }

     @Test(timeout = 1000)// 单位为毫秒  
     public void testSquareRoot() {
         calculator2.squareRoot(4);
     }

 }

Run As->JUnit Test,显示如图

可以看到，CalculatorTest类中总共有5个测试用例，ignore了一个，3个测试用例通过，testSquareRoot测试不通过（因为超时），所以整个的测试结果飘红了。同时，控制台的输出结果为：

global
一个测试开始..
一个测试结束..
一个测试开始..
teddd
一个测试结束..
一个测试开始..
一个测试结束..
一个测试开始..
一个测试结束..
global destory

注解说明：

@Test：

表明该方法是一个测试方法

@BeforeClass 和 @AfterClass：

测试用例初始化时执行 @BeforeClass方法，当所有测试执行完毕之后，执行@AfterClass进行收尾工作。标注、@BeforeClass 和 @AfterClass的方法必须是static的，因为方法将在类被装载的时候就被调用，那时候还没创建测试对象实例。

@Before： 
使用了该元数据的方法在每个测试方法执行之前都要执行一次。

@After： 
使用了该元数据的方法在每个测试方法执行之后要执行一次。

@Test(expected=*.class) ：
通过@Test元数据中的expected属性验证是否抛出期望的异常，expected属性的值是一个异常的类型，如果抛出了期望的异常，则测试通过，否则不通过。

@Test(timeout=xxx)：
该元数据传入了一个时间（毫秒）给测试方法，如果测试方法在制定的时间之内没有运行完，则测试也失败。

@Ignore： 
该元数据标记的测试方法在测试中会被忽略。同时可以为该标签传递一个String的参数，来表明为什么会忽略这个测试方法。比如：@lgnore("该方法还没有实现")，在执行的时候，仅会报告该方法没有实现，而不会运行测试方法。

在test方法内除了使用Assert的assertEquals()方法外，还能使用assertFalse()、assertTrue()、assertNull()、assertNotNull()、assertSame()、assertNotSame()等断言函数。而且如果使用的是Junit4，结合Hamcrest，使用

assertThat([value], [matcher statement])方法可以实现更灵活的断言判断（前提是引入hamcrest的jar包）。

例如：

// is匹配符表明如果前面待测的object等于后面给出的object，则测试通过

assertThat( testedObj, is( object) );

// containsString匹配符表明如果测试的字符串包含指定的子字符串则测试通过

assertThat( testedString, containsString( "developerWorks" ) );

// greaterThan匹配符表明如果所测试的数值testedNumber大于16.0则测试通过

assertThat( testedNumber, greaterThan(16.0) );

// closeTo匹配符表明如果所测试的浮点型数testedDouble在20.0±0.5范围之内则测试通过

assertThat( testedDouble, closeTo( 20.0, 0.5 ) );

//hasItem匹配符表明被测的迭代对象含有元素element项则测试通过assertThat(iterableObject, hasItem (element));

4、参数化测试

上面的Caculator待测试类里，现在我如果想给square方法多弄几个测试用例，按照上面的方法，我应该写好几个@Test方法来测试，或者每次测完再改一下输入的值和期望得到的值，好麻烦。JUnit提供如下的测试：

 package com.test;

 import static org.junit.Assert.assertEquals;

 import java.util.Arrays;
 import java.util.Collection;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;

 @RunWith(Parameterized.class)
 public class Test2 {

     private Calculator2 calculator2 = new Calculator2();
     private int param;
     private int result;

     public Test2(int param, int result) {
         this.param = param;
         this.result = result;
     }

     @Parameters
     public static Collection data(){
         return Arrays.asList(new Object[][]{
             {2,4},
             {0,0},
             {-3,9}
         });
     }

     @Test
     public void squareTest(){
         int temp = calculator2.square(param);
         assertEquals(result, temp);
     }
 }

运行结果显示：

测试通过了，Test2类里的parameter是每次的测试输入，result就是测试的结果。所有的测试输入和期望结果都在@Parameters标注的data函数的返回的Collection集合里，2的期望得到的平方结果值是4，0期望得到0，-3期望得到9。

下面我们对上述代码进行分析。首先，你要为这 种测试专门生成一个新的类，而不能与其他测试共用同一个类，此例中我们定义了一个Test2类。然后，你要为这个类指定一个Runner，而不 能使用默认的Runner了，因为特殊的功能要用特殊的Runner嘛。@RunWith(Parameterized.class)这条语句就是为这个 类指定了一个ParameterizedRunner。第二步，定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。接下 来，定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。这个方法的框架就不予解 释了，大家只需要注意其中的数据，是一个二维数组，数据两两一组，每组中的这两个数据，一个是参数，一个是你预期的结果。比如我们的第一组{2, 4}，2就是参数，4就是预期的结果。这两个数据的顺序无所谓，谁前谁后都可以。之后是构造函数，其功能就是对先前定义的两个参数进行初始化。在这里你可 要注意一下参数的顺序了，要和上面的数据集合的顺序保持一致。如果前面的顺序是{参数，期待的结果}，那么你构造函数的顺序也要是“构造函数(参数，期待的结果)”，反之亦然。最后就是写一个简单的测试例了，和前面介绍过的写法完全一样，在此就不多说。

五、Runner（运行器）

把测试代码提交给JUnit框架后，框架如何来运行代码呢?答案就是——Runner。在JUnit中有很多个 Runner，他们负责调用测试代码，每一个Runner都有各自的特殊功能，要根据需要选择不同的Runner来运行测试代码。JUnit中有一个默认Runner，如果没有指定，那么系统自动使用默认 Runner来运行你的代码。这里参数化测试就没有再用默认的Runner了。

 import org.junit.internal.runners.TestClassRunner;
 import org.junit.runner.RunWith;
 //使用了系统默认的TestClassRunner，与下面代码完全一样
 public class CalculatorTest …{…}
 @RunWith(TestClassRunner.class)
 public class CalculatorTest …{…}

六、打包测试

 package com.test;

 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;

 /**
  * 大家可以看到，这个功能也需要使用一个特殊的Runner，
  * 因此我们需要向@RunWith标注传递一个参数Suite.class。
  * 同时，我们还需要另外一个标注@Suite.SuiteClasses，
  * 来表明这个类是一个打包测试类。我们把需要打包的类作为参数传递给该标注就可以了。
  * 有了这两个标注之后，就已经完整的表达了所有的含义，因此下面的类已经无关紧要，
  * 随便起一个类名，内容全部为空既可
  *
  */
 @RunWith(Suite.class)
 @Suite.SuiteClasses({Test1.class,Test2.class})
 public class AllTest {

 }

这个测试类包含了上面的Test1.class和Test2.class里面所有的测试函数，它的目的就是进行打包所有的测试。

参考：

http://tonl.iteye.com/blog/1948869

http://tips1000.com/archives/189.html