JUnit3.8与JUnit4

相对JUnit3.8，JUnit4采用了大量Annotation来实现的。

一 基本使用方法



包命名从junit.framework.xxx变更到org.junit.xxx.
在JUnit3.8中测试类必须继承TestCase父类，JUnit4中测试类不用继承TestCase
在JUnit3.8中 测试方法满足如下原则1)public 2)void 3)无方法参数4）方法名称必须以test开头，JUnit测试方法不用满足4）即命名不用test +methodName ,用Annotation来标注是测试方法@Test
@Before相当于setUp会在每个测试方法调用前执行一次。
@After相当于tearDown会在每个测试方法调用前执行一次。
@BeforeClass,JUnit3.8没有对应功能，在每个类加载只被执行一次，必须定义static方法一般用于初始化一些代价昂贵的计算，如数据库连接获得。
@AfterClass,JUnit3.8没有对应功能，在所有测试结束后只被执行一次，必须定义static方法一般用于回收一些代价昂贵的计算，如数据库连接释放。
@Test 可以有timeout参数
@Test 可以有expected参数, public abstract java.lang.Class<? extends java.lang.Throwable> expected   Default:org.junit.Test.None.class 
二  组合测试

JUnit3.8中的TestSuite功能在JUnit4中通过新曾的测试运行器来实现JUni4所有的测试都是有测试运行器运行的。JUnit为单元测试提供了默认的运行器。用户可以定制自己的运行器(继承于org.junit.runner.Runner)，并且可以为每一个测试类指定具体的运行器。@RunWith(Suite.class)来实现。
1）创建一个空类，用注解org.junit.runner.RunWitch和org.junit.runners.Suite.SuiteClass修饰该空类。2）将org.junit.runners.Suite作为参数传入注解RunWitch以提示JUnit为此类使用套件运行器运行。  3)将需要放入该测试套件的测试类组成数组作为注解SuiteClasses的参数。4）这个空类必须是public修饰，而且存在无参公开的够造函数。
@RunWith(Suite.class)@Suite.SuiteClasses({CalculatorTest2.class,LargestTest2.class})
public class TestAll2 {

}
三 参数化测试





     

********************************************************************************

//被测试类

package com.test.junit;


/**
* 数学计算
* @author Administrator
*
*/
public class Calculator {

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

public int minus(int a, int b) {
  return a - b;
}

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("除数不能为零!");
  }
  return a / b;
}

}
********************************************************************************

//Junit3.8

package com.test.junit;

import com.test.junit.Calculator;

import junit.framework.Assert;
import junit.framework.TestCase;
/**
* 在junit3.8中测试类必须继承TestCase父类
* @author Administrator
* keep the bar green to keep the code clean
* 单元测试不是证明您是对的，而是证明您没有错误
*/

public class CalculatorTest extends TestCase
{

/**
  * 在junit3.8中 测试方法满足如下原则
  * 1)public
  * 2)void
  * 3)无方法参数
  * 4）方法名称必须以test开头
  *
  * Dont't Repeat yourself//不要重复你自己
  */

private Calculator cal;

public void testAdd()
{
  int result = cal.add(1, 2);
  //断言:assert
  Assert.assertEquals(3,result);
}

public void testMinus()
{
 
  int result = cal.minus(1, 2);
  //断言
  Assert.assertEquals(-1, result);
}

public void testMultiply()
{
  int result =cal.multiply(2, 3);
  //断言
  Assert.assertEquals(6, result);
}


public void testDivide()
{
  int result = 0;
  try {
   result = cal.divide(6, 4);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  //断言
  Assert.assertEquals(1, result);
}

public void testDivide2()
{
  Throwable tx =null;
  try
  {
   cal.divide(4, 0);
   Assert.fail();
  
  }catch(Exception ex)
  {
   tx = ex;
  }
 
  Assert.assertNotNull(tx);
  Assert.assertEquals(Exception.class, tx.getClass());
  Assert.assertEquals("除数不能为零!",tx.getMessage());
}

@Override
protected void setUp() throws Exception {
  cal = new Calculator();
   
}

@Override
protected void tearDown() throws Exception {
 
}
}
********************************************************************************

//Junit4

package com.test.junit;

import static org.junit.Assert.assertEquals;

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

public class CalculatorTest2 {
private Calculator cal;
/**
  * @Before相当于setUp会在每个测试方法调用前执行一次
  */
@Before
public void init(){
  cal = new Calculator();
  System.out.println("init invoked!");
}
/**
  * @After相当于tearDown会在每个测试方法调用前执行一次
  */
@After
public void destory(){
  System.out.println("destory invoked！");
}
/**
  *@BeforeClass,Junit3.8没有对应功能，在每个类加载只被执行一次，必须定义static方法
  *一般用于初始化一些代价昂贵的计算，如数据库连接获得
  */
@BeforeClass
public static void globalInit(){
  System.out.println("globalInit Invoked!");
}

/**
  *@AfterClass,Junit3.8没有对应功能，在所有测试结束后只被执行一次，必须定义static方法
  *一般用于回收一些代价昂贵的计算，如数据库连接释放
  */
@AfterClass
public static void globalDestory(){
  System.out.println("globalDestory Invoked!");
}
/**
  * 测试方法命名不用test +methodName
  * 用Annotation来标注是测试方法@Test
  */
@Test
public void myAdd() {
  int result = cal.add(1, 2);
  assertEquals(3,result);
}

@Test
public void myMinus(){
  int result =cal.minus(1, 2);
  assertEquals(-1,result);
}

@Test
public void myMultiply(){
  int result = cal.multiply(2, 3);
  assertEquals(6,result);
}

@Test
public void myDivide(){
  int result=0;
  try {
    result = cal.divide(6, 4);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  assertEquals(1,result);
}
/**
  * @Test 可以有expected参数
  * public abstract java.lang.Class<? extends java.lang.Throwable> expected
  * Default:org.junit.Test.None.class
  * @throws Exception
  */
@Test (expected = Exception.class)
public void myDivide2() throws Exception{
  cal.divide(6, 0);
  }

/**
  * @Test 可以有timeout参数
  */
@Test (timeout =100)
public void myDivide3(){
  try {
     cal.divide(6, 4);
     Thread.sleep(100);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
}

}