Junit

1.Junit是幹嗎的？

首先Junit是一個單元測試框架，它能讓咱們快速的完成單元測試。一般咱們寫完代碼想要測試這段代碼的正確性，那麼咱們必須新建一個類，寫一個main方法，而後編寫測試代碼。若是要測試的代碼不少，這會增長測試的複雜性。而Junit能很好的解決這個問題，簡化單元測試，寫一點，測一點。

2.怎麼用Junitne？

若是你用的是Eclipse（自帶Junit包），若是其餘的須要本身下載jar包導入。

先寫一個簡單測試類

 1 public class Test {
 2 
 3     public int sum(int a, int b){
 4         
 5         return a+b;
 6         
 7     }
 8     
 9     public int sub(int a, int b){
10         
11         return a-b;
12         
13     }
14     
15 }

若是按照咱們日常的方法去檢查類裏面的方法是否正確，咱們會這樣寫

 1 public class TestDemo1 {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Test t = new Test();
 6         
 7         int result = t.sum(1, 2);
 8         if(result == 3){
 9             System.out.println("sum方法正確");
10         }
11         
12         int result2 = t.sub(3, 1);
13         if(result2 == 2){
14             System.out.println("sub方法正確");
15         }
16     }

哪咱們如今用Junit來測試方法

 1 public class TestDemo2 {
 2     
 3     @Test
 4     public void testSum(){
 5         Demo d = new Demo();
 6         int result = d.sum(1, 2);
 7         if(result == 3){
 8             System.out.println("sun方法正確");
 9         }
10     }
11     
12     @Test
13     public void testSub(){
14         Demo d = new Demo();
15         int result = d.sum(3, 1);
16         if(result == 2){
17             System.out.println("sub方法正確");
18         }
19     }
20     
21 }

如何運行Junit呢，要測那個方法就在那個方法上點右鍵Run As JUnit Test

若是結果出現以下的綠色橫條，則測試經過，紅色橫條，則測試失敗

這時候確定會大罵一句，這個有什麼用，代碼差很少，效果也差很少。

接下來先介紹幾種相似@Test的註解

　　1.@Test: 測試方法

　　　　a)(expected=XXException.class)若是程序的異常和XXException.class同樣，則測試經過
　　　　b)(timeout=100)若是程序的執行能在100毫秒以內完成，則測試經過

　　2.@Ignore: 被忽略的測試方法：加上以後，暫時不運行此段代碼

　　3.@Before: 每個測試方法以前運行

　　4.@After: 每個測試方法以後運行

　　5.@BeforeClass: 方法必須必需要是靜態方法（static 聲明），全部測試開始以前運行，注意區分before，是全部測試方法

　　6.@AfterClass: 方法必需要是靜態方法（static 聲明），全部測試結束以後運行，注意區@After

關於註釋的使用用一個例子

 1 public class JunitTest {
 2     public JunitTest() {
 3         System.out.println("構造函數");
 4     }
 5  
 6     @BeforeClass
 7     public static void beforeClass(){
 8         System.out.println("@BeforeClass");
 9     }
10      
11     @Before
12     public void befor(){
13         System.out.println("@Before");
14     }
15      
16     @Test
17     public void test(){
18         System.out.println("@Test");
19     }
20      
21     @Ignore
22     public void ignore(){
23         System.out.println("@Ignore");
24     }
25      
26     @After
27     public void after(){
28         System.out.println("@After");
29     }
30      
31     @AfterClass
32     public static void afterClass(){
33         System.out.println("@AfterClass");
34     }
35 }

結果爲

1 @BeforeClass
2 構造函數
3 @Before
4 @Test
5 @After
6 @AfterClass

關於Junit的優點舉一個小例子，在上面的例子中每一個方法都有Demo d = new Demo();這樣會很麻煩，因此在Junit中咱們能夠把類的實例化放入@Before中

 1 public class TestDemo3 {
 2     
 3     Demo d = null;
 4     
 5     @Before
 6     public void testBefore(){
 7         d = new Demo();
 8     }    
 9     
10     @Test
11     public void testSum(){
12         int result = d.sum(1, 2);
13         if(result == 3){
14             System.out.println("sun方法正確");
15         }
16     }
17     
18     @Test
19     public void testSub(){
20         int result = d.sum(3, 1);
21         if(result == 2){
22             System.out.println("sub方法正確");
23         }
24     }
25 }

這樣要測試的東西越多，咱們的Junit的優點越明顯。並且當咱們須要在檢測前打開什麼時，結束測試後，要關掉相應的東西，能夠把東西分別寫在@Before和@After中，這樣代碼量會大量減小。

若是咱們須要運行全部的測試方法，能夠在測試類上點Run As JUnit Test