看了一些Junit4的視頻，簡單了解了Junit4的一些基本用法，整理記錄一下。

環境搭建

這裏使用的開發工具是MyEclipse，首先新建一個Java工程，將Junit4的jar包引入，eclipse和MyEclipse都集成了Junit的jar包，詳細操作如下圖。

1、新增一個Junit的jar包，版本選擇Junit4

Junit使用

1、Junit最簡單的用法

新建一個類被測試類，裏面包含一些測試方法，新建一個測試類

 1 package junit.util;
 2 /**
 3  * 被測試類，通過Junit對此類的方法進行單元測試
 4  */
 5 public class Claculate {
 6
 
     public int add(int a, int b) {
 7     return a + b;
 8     }
 9 
10     public int subtract(int a, int b) {
11     return a - b;
12     }
13 
14     public int multiply(int a, int b) {
15     return a * b;
16     }
17
 18     public int divide(int a, int b) {
19     return a / b;
20     }
21 
22 }

新建一個Junit的測試類用來測試上面的測試方法，新增Junit的測試類方法如下：

 1 package junit.util;
 2 
 3 import static org.junit.Assert.*;
 4 import junit.util.Claculate;
 5 
 6 import org.junit.Test;
 7 
 8 /**
 9  * junit的測試方法必須使用@Test註解
10  * 測試方法必須以public void修飾，並且不包含參數
11  */
12 public class ClaculateTest {
13 
14     @Test
15     public void testAdd() {
16     /**
17      * assertEquals這個方法是一個斷言方法
 
18      * 第一個參數表示預期的結果
19      * 第二個參數表示程序的執行結果
20      * 當預期結果與執行結果是一致的時候，則表示單元測試成功
21      */
22     assertEquals(4, new Claculate().add(1, 3));
23     }
24 
25    
26     @Test
27     public void testSubtract() {
28     assertEquals(4, new Claculate().subtract(9, 5));
29     }
30     
31     @Test
32     public void testMultiply() {
33     assertEquals(6, new Claculate().multiply(2, 3));
34     }
35     
36     @Test(expected=ArithmeticException.class)
37     public void testDivide() {
38     assertEquals(3, new Claculate().divide(9, 0));
39     }
40 }

上面的這個測試類，分別對被測試類Claculate的四個方法進行了測試，測試是選擇使用Junit方式進行執行，如果想要執行單個測試方法，可以選擇單個方法進行執行，可以通過左側代碼欄展開類選擇下面的方法或者直接在代碼中選中方法名進行執行。具體操作如下圖：

對於一個類包含的多個測試方法，可以選中這個類，鼠標右鍵選擇new一個JUnitTest Case，可以選擇類中的所有要測試的方法，eclipse會自動幫你生成測試方法體

只需要在每個要測試的方法中添加測試代碼即可，如下圖;

JUnit的流程

在實際項目中，進行JUnit測試時，通常會涉及到一些初始化的東西，可能有些配置項需要在測試前進行加載的，JUnit提供了一些初始化的方法用於初始化

 1 package junit.util;
 2 
 3 import org.junit.After;
 4 import org.junit.AfterClass;
 5 import org.junit.Before;
 6 import org.junit.BeforeClass;
 7 import org.junit.Test;
 8 
 9 public class JunitFlowTest {
10     /**
11      * @BeforeClass:這個註解表示這個方法會在所有測試方法執行之前執行
12      * 因為是static修飾的靜態方法，所有只會執行一次。通常用來進行一些
13      * 資源的加載，如通過JUnit測試Spring相關的東西時，可以在這個方法
14      * 中加載Spring的配置文件
15      */
16     @BeforeClass
17     public static void setUpBeforeClass() throws Exception {
18     System.out.println("this is before class");
19     }
20     
21     /**
22      * @AfterClass:這個註解表示這個方法會在所有方法執行完畢之後執行，通常用來釋放資源
23      */
24     @AfterClass
25     public static void tearDownAfterClass() throws Exception {
26     System.out.println("this is after class");
27     }
28 
29     /**
30      * @Before:這個註解表示這個方法會在每個測試方法執行之前執行一次
31      * 有多少個測試方法就會執行多少次
32      */
33     @Before
34     public void setUp() throws Exception {
35     System.out.println("this is before");
36     }
37 
38     /**
39      * @After:這個註解表示這個方法會在每個測試方法執行之後執行一次
40      * 有多少個測試方法就會執行多少次
41      */
42     @After
43     public void tearDown() throws Exception {
44     System.out.println("this is Down");
45     }
46 
47     @Test
48     public void test1() {
49     System.out.println("this is test1");
50     }
51     
52     @Test
53     public void test2() {
54     System.out.println("this is test2");
55     }
56 
57 }
58 59 /* outPut:
60 this is before class
61 this is before
62 this is test1
63 this is Down
64 this is before
65 this is test2
66 this is Down
67 this is after class
68 */

測試套件

如果要同時測試多個類，可以新增一個測試套件，將多個所有測試類包含進去，每次執行測試套件類的時候，就會把包含的測試類全都執行一遍，測試代碼如下：

 1 package junit.util;
 2 
 3 import org.junit.Test;
 4 
 5 public class TaskTest1 {
 6 
 7     @Test
 8     public void test() {
 9     System.out.println("this is TaskTest1");
10     }
11 }
12 
13 
14 
15 package junit.util;
16 
17 import org.junit.Test;
18 
19 public class TaskTest2 {
20 
21     @Test
22     public void test() {
23     System.out.println("this is TaskTest2");
24     }
25 }
26 
27 
28 
29 package junit.util;
30 
31 import org.junit.Test;
32 
33 public class TaskTest3 {
34 
35     @Test
36     public void test() {
37     System.out.println("this is TaskTest3");
38     }
39 }
40 
41 
42 
43 package junit.util;
44 
45 import org.junit.runner.RunWith;
46 import org.junit.runners.Suite;
47 
48 /**
49  * 測試套件類
50  * 測試套件是用來組織多個測試類一起運行的，使用 @RunWith註解
51  * 更改測試運行器為Suite.class，將要測試的類作為數組傳入
52  * 到Suite.SuiteClasses({})中，測試套件類不能包含其他測試方法
53  * 
54  * 樣例如下：
55  */
56 @RunWith(Suite.class)
57 @Suite.SuiteClasses({ TaskTest1.class, TaskTest2.class, TaskTest3.class })
58 public class SuiteTest {}
59 
60 //outPut：
61 //this is TaskTest1
62 //this is TaskTest2
63 //this is TaskTest3

測試套件也可以包含其他的測試套件，具體用法和包含多個測試類是一樣的，代碼如下：

 1 package junit.util;
 2 
 3 import org.junit.Test;
 4 
 5 public class TaskTest4 {
 6 
 7     @Test
 8     public void test() {
 9     System.out.println("this is TaskTest4");
10     }
11 }
12 
13 
14 
15 package junit.util;
16 
17 import org.junit.runner.RunWith;
18 import org.junit.runners.Suite;
19 
20 @RunWith(Suite.class)21 @Suite.SuiteClasses({SuiteTest.class,TaskTest4.class})
22 public class SuiteTest1 {}
23 
24 //outPut
25 //this is TaskTest1
26 //this is TaskTest2
27 //this is TaskTest3
28 //this is TaskTest4

參數化測試

對於一個方法需要進行多種場景進行測試時，可以通過參數化測試減少測試的工作量。用法如下：

 1 package junit.util;
 2 
 3 import static org.junit.Assert.assertEquals;
 4 
 5 import java.util.Arrays;
 6 import java.util.Collection;
 7 
 8 import org.junit.Test;
 9 import org.junit.runner.RunWith;
10 import org.junit.runners.Parameterized;
11 import org.junit.runners.Parameterized.Parameters;
12 
13 @RunWith(Parameterized.class)
14 public class ParameterTest {
15 
16     /**
17      * 1、更改測試運行器為RunWith(Parameterized.class)
18      * 2、聲明變量用來存放預期值與結果值
19      * 3、聲明一個返回值為Collection的公共靜態方法，並使用@Parameters進行修飾
20      * 4、位測試類聲明一個帶有參數的公共構造方法，並在其中為聲明變量賦值
21      */
22     
23     int except;  //用來存儲預期結果
24     int input1;  //用來存儲第一個輸入參數
25     int input2;  //用來存儲第二個輸入參數
26     
27     @Parameters
28     public static Collection<Object[]> initTestData(){
29     return Arrays.asList(
30         new Object[][]{
31         {3,1,2},
32         {10,5,5},
33         {6,4,2},
34         {7,3,4}}
35         );
36     }
37     
38     public ParameterTest(int except,int input1,int input2){
39     this.except = except;
40     this.input1 = input1;
41     this.input2 = input2;
42     }
43     
44     
45     
46     
47     
48     @Test49     public void testAdd() {
50     assertEquals(except, new Claculate().add(input1, input2));
51     }
52 
53 }

總結及補充：

JUnit的一些註意事項：

• 測試方法必須使用@Test修飾
• 測試方法必須使用public void進行修飾，不能帶參數
• 一般使用單元測試會新建一個test目錄存放測試代碼，在生產部署的時候只需要將test目錄下代碼刪除即可
• 測試代碼的包應該和被測試代碼包結構保持一致
• 測試單元中的每個方法必須可以獨立測試，方法間不能有任何依賴
• 測試類一般使用Test作為類名的後綴
• 測試方法使一般用test作為方法名的前綴

測試失敗說明：

• Failure：一般是由於測試結果和預期結果不一致引發的，表示測試的這個點發現了問題
• error：是由代碼異常引起的，它可以產生於測試代碼本身的錯誤，也可以是被測試代碼中隱藏的bug

一些常用註解：

• @Test:將一個普通方法修飾成一個測試方法
  • @Test(excepted=xx.class): xx.class表示異常類，表示測試的方法拋出此異常時，認為是正常的測試通過的
  • @Test(timeout=毫秒數) :測試方法執行時間是否符合預期
• @BeforeClass： 會在所有的方法執行前被執行，static方法
• @AfterClass：會在所有的方法執行之後進行執行，static方法
• @Before：會在每一個測試方法被運行前執行一次
• @After：會在每一個測試方法運行後被執行一次
• @Ignore：所修飾的測試方法會被測試運行器忽略
• @RunWith：可以更改測試運行器org.junit.runner.Runner
• Parameters：參數化註解

本人也是剛開始學習使用單元測試，就把剛學到的東西簡單記錄一下，有錯誤和不足的地方請見諒！

Ecplise中Junit4單元測試的基本用法