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