从JUnit3升级到JUnit4

我个人认为， JUnit4最大的特点是引入了Java5的注释Annotation。

1. @Test

    在JUnit3，所有的test case的方法名都要以"test"为前缀prefix；

    在JUnit4，在test case的方法前加上@Test，就明白了。

@Test
public void empty() {        
         /* test case 1*/         
        Collection collection = new ArrarList();        
        assertTrue(collection.isEmpty());        
}

 

2. @Before 和 @After
    @Before 和 @After 就是setUp()和tearDown（）的替代。

@Before    
public void runBeforeEveryTest() {        
        simpleMath = new SimpleMath();        
}        
    
@After    
public void runAfterEveryTest() {        
        simpleMath = null ;        
}

 

3. @BeforeClass 和 @AfterClass

    在JUnit3，如果想仅调用一次setUp()和tearDown()  for  all test cases， 使用TestSetup类；在JUnit4，就省事了：

@BeforeClass    
public static void runBeforeClass() {        
         // run for one time before all test cases        
}        
    
@AfterClass    
public static void runAfterClass() {        
         // run for one time after all test cases        
}

 

4. 测试异常处理

    在《 JUnit3的使用 》文章中，看到旧式的异常测试是在抛出异常的代码中放入 try 块，然后在 try 块的末尾加入一个 fail() 语句：

public void testCase2() {        
         /* test case 2*/         
        ArrayList emptyList = new ArrayList();    
         try {    
                Object o = emptyList.get(0);    
                fail( "Should raise an IndexOutOfBoundsException" );    
        } catch (IndexOutOfBoundsException expected) {    
                assertTrue( true );    
        }    
}

     在JUnit4，添加@Test，使用参数“expected”，并指明抛出异常的Exception类：

@Test(expected = IndexOutOfBoundsException. class )
public void testCase2() {        
         /* test case 2*/         
        ArrayList emptyList = new ArrayList();    
        Object o = emptyList.get(0);    
}

 

5. @Ignore

     对于你想暂时不进行的test cse, 在该方法前添加@Ignore

@Ignore( "Not Ready to Run" )        
@Test    
public void multiplication() {        
        assertEquals(15, simpleMath.multiply(3, 5));        
}

 

6. 设置超时

    在@Test，使用"timeout"参数。如果测试运行的时间超过指定的毫秒数，则测试失败。

@Test(timeout=3000)
public void remoteBaseRelativeResolutionWithDirectory()    
　 throws IOException, ParsingException {
　　readBuilder.parse( "config.xml" );    
}

 

7.添加了新的断言

      JUnit 4 为比较数组添加了两个 assert() 方法:

　　 public static void assertEquals(Object[] expected, Object[] actual)

      public static void assertEquals(String message, Object[] expected, Object[] actual)

　　这两个方法以最直接的方式比较数组:如果数组长度相同，且每个对应的元素相同，则两个数组相等，否则不相等。数组为空的情况也作了考虑。

@Test    
public void listEquality() {        
        List<Integer> expected = new ArrayList<Integer>();        
        expected.add(5);        
    
        List<Integer> actual = new ArrayList<Integer>();        
        actual.add(5);        
    
        assertEquals(expected, actual);        
}

 

8. JUnit4Adapter

     为了能够在JUnit3环境下run JUnit4  test, 所以提供了JUnit4Adapter

public static junit.framework.Test suite() {        
         return new JUnit4TestAdapter(SimpleMathTest. class );        
}

 

9.其他

失败(assert 方法检测到的预期的错误)与错误(异常指出的非预期的错误)之间不再有任何差别。尽管 JUnit 3 测试运行程序仍然可以区别这些情况，而 JUnit 4 运行程序将不再能够区分。

二、运行原理：

JUnit运行时都是由一个runner运行的。你可以根据需要选择不同的Runner来运行你的测试代码。指定一个Runner，需要使用@RunWith标注，并且把你所指定的Runner作为参数传递给它。系统自动使用默认Runner TestClassRunner 来运行你的代码。如下：

@RunWith (TestClassRunner.class)

public class JavaTest { …… }

 

JUnit4提出了"参数化测试 "的概念，只写一个测试函数，把这若干种情况作为参数传递进去，一次性的完成测试。代码如下：

 

@RunWith(Parameterized.class)
public class JavaTest {
private int param;
private int param2;
private int result;

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

 // 构造函数，对变量进行初始化
public JavaTest(int param, int param2, int result) {
this.param = param;
this.param2 = param2;
this.result = result;
}

@Test public void run() {
//do some thing use args, and assert it
int expected = param + param2;
assertEquals(expected, result);
}
@Ignore("lala") public void lala() {
assertEquals(3,3);
}
} 

首先，你要为这种测试专门生成一个新的类，为这个类指定一个Runner，特殊的功能要用特殊的Runner：@RunWith(Parameterized.class)
第二步，定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。这是一个二维数组，每组数据产生一个测试Instance.
第三步，构造函数，取得传过来的参数。
最后，用取得的参数做测试。@Test public void …

 

三、打包测试：

采取分而治之的方法，我们可以写多个类来降低测试难度。我们有时也希望一次把所有测试跑一遍，这时我们写一个打包类

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

 

@RunWith(Suite.class)
@Suite.SuiteClasses({
JavaTest.class,
JustDo.class
})
public class TestAll {
}

 

四、多线程测试

      JUnit4的Test写好以后，对于一些集成度比较高的测试用例，还希望完成并发访问情况下的测试，但是，JUnit4缺省情况没有提供，我希望通过自 己写一个main函数，然后创建几个线程，在几个线程中同时运行测试用例进行测试，来模拟并发访问的情况,下里为具体例子：

public class TestExample {

@Test
public void testMethod() {
System.out.println("test success!");
}
}

public class PerfomanceTest {

public static void main(String[] args) {
new Thread() {public void run() {
// JUnitCore.runClasses(new Class[] { TestExample .class });            (1)
// new JUnitCore().run(Request.method(TestExample .class, "testMethod "));        (2)
}}.start();
}
}
注：标志1或标志2中只要用一种就可以测试。

到这里，我们就可以使用JUnit4来开发我们自己的测试了。

编译和运行JUnit
在JUnit3中提供了三种运行界面：
TestUI：Provides text-based output to stdout
AwtUI: Provides GUI-based output using the AWT(Abstract Window Toolkit)from Java
SwingUI: Provides GUI-based output using the Swing graphical user interface component kit from Java.

设置好环境变量后，在命令行运行：
java junit.USERINTERFACE.TestRunner classfile

例如：
java junit.testui.TestRunner BaseClassTest

在JUnit4中，只有标准输出界面，使用org.junit.runner.JUnitCore类来运行：
java org.junit.runner.JUnieCore BaseClassTest