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();
}
}

}