Junit

1.Junit是干嘛的？

首先Junit是一个单元测试框架，它能让我们快速的完成单元测试。通常我们写完代码想要测试这段代码的正确性，那么我们必须新建一个类，写一个main方法，然后编写测试代码。如果要测试的代码很多，这会增加测试的复杂性。而Junit能很好的解决这个问题，简化单元测试，写一点，测一点。

2.怎么用Junitne？

如果你用的是Eclipse（自带Junit包），如果其他的需要自己下载jar包导入。

先写一个简单测试类

public class Test {

    public int sum(int a, int b){
        
        return a+b;
        
    }
    
    public int sub(int a, int b){
        
        return a-b;
        
    }
    
}

如果按照我们平常的方法去检查类里面的方法是否正确，我们会这样写

public class TestDemo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test t = new Test();
        
        int result = t.sum(1, 2);
        if(result == 3){
            System.out.println("sum方法正确");
        }
        
        int result2 = t.sub(3, 1);
        if(result2 == 2){
            System.out.println("sub方法正确");
        }
    }

哪我们现在用Junit来测试方法

public class TestDemo2 {
    
    @Test
    public void testSum(){
        Demo d = new Demo();
        int result = d.sum(1, 2);
        if(result == 3){
            System.out.println("sun方法正确");
        }
    }
    
    @Test
    public void testSub(){
        Demo d = new Demo();
        int result = d.sum(3, 1);
        if(result == 2){
            System.out.println("sub方法正确");
        }
    }
    
}

如何运行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

关于注释的使用用一个例子

public class JunitTest {
    public JunitTest() {
        System.out.println("构造函数");
    }
 
    @BeforeClass
    public static void beforeClass(){
        System.out.println("@BeforeClass");
    }
     
    @Before
    public void befor(){
        System.out.println("@Before");
    }
     
    @Test
    public void test(){
        System.out.println("@Test");
    }
     
    @Ignore
    public void ignore(){
        System.out.println("@Ignore");
    }
     
    @After
    public void after(){
        System.out.println("@After");
    }
     
    @AfterClass
    public static void afterClass(){
        System.out.println("@AfterClass");
    }
}

结果为

@BeforeClass
构造函数
@Before
@Test
@After
@AfterClass

关于Junit的优势举一个小例子，在上面的例子中每个方法都有Demo d = new Demo();这样会很麻烦，所以在Junit中我们可以把类的实例化放入@Before中

public class TestDemo3 {
    
    Demo d = null;
    
    @Before
    public void testBefore(){
        d = new Demo();
    }    
    
    @Test
    public void testSum(){
        int result = d.sum(1, 2);
        if(result == 3){
            System.out.println("sun方法正确");
        }
    }
    
    @Test
    public void testSub(){
        int result = d.sum(3, 1);
        if(result == 2){
            System.out.println("sub方法正确");
        }
    }
}

这样要测试的东西越多，我们的Junit的优势越明显。而且当我们需要在检测前打开什么时，结束测试后，要关掉相应的东西，可以把东西分别写在@Before和@After中，这样代码量会大量减少。

如果我们需要运行所有的测试方法，可以在测试类上点Run As JUnit Test