JUnit测试详解

注解测试

import org.junit.*;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

/**
 * JUnit注解
 */
public class JUnitAnnotationTest {

    /**
     * 注解：@BeforeClass
     * 描述：
     * 1 修饰的方法为静态方法;
     * 2 类级别首先执行
     * 3 只执行一次
     */
    @BeforeClass
    public static void getConnection(){
        //TODO
        System.out.println("connecting to MYQL DataBase...");
    }

    /**
     * 注解：@Before
     * 描述：
     * 1 每个测试方法执行前均会执行该注解修饰的方法
     * 2
     */
    @Before
    public void preTest(){
        //TODO
        System.out.println("is preparing to begin the test...");
    }
    @Before
    public void _preTest(){
        //TODO
        System.out.println("is preparing to begin the test_...");
    }

    /**
     * 注解：@Test
     * 描述：测试方法
     * 注解@Test有两个参数：
     * - expected
     *   期待抛出的异常，值为异常类的class
     * - timeout
     *   测试超时时间，默认0s;
     */
    @Test(expected =java.lang.NullPointerException.class,timeout =15000 )
    public void test_1(){
        //TODO
        System.out.println("tesing one");
    }
    @Test
    public void test_2(){
        //TODO
        System.out.println("tesing two");
    }
    @Test
    public void test_3(){
        //TODO
        System.out.println("tesing three");
    }

    /**
     * 注解：@After
     * 描述：每个测试方法执行之后均会执行一次该注解修饰的方法
     *
     */
    @After
    public void aftTest(){
        //TODO
        System.out.println("tesing is completed");
    }

    /**
     * 注解：@AfterClass
     * 描述：
     * 1 修饰的方法为静态方法
     * 2 类级别最后执行
     * 3 只执行一次
     */
    @AfterClass
    public static void closeConnection(){
        //TODO
        System.out.println("closing MYQL connection....");
    }
}

忽略测试

import org.junit.Ignore;
import org.junit.Test;

/**
 * 忽略测试
 * 注解：@Ignore
 * 描述：
 *     - 作用在测试方法上，则不执行该方法，可用于想跳过执行失败,或抛出异常的方法；
 *     - 作用在测试类上，则对整个测试类的所有测试方法均不执行；
 */

public class JUnitIgnoreTest {
    @Test
    public void test_1(){
        System.out.println("test one");
    }
    @Ignore
    @Test
    public void test_2(){
        System.out.println("test two");
    }
}

超时测试

**
 * 超时测试
 * 注解：Timeout @Rule
 * 描述：
 * - Timeout可作用在测试方法的@Test注解上，作为参数，指定单个测试方法的超时时间；
 * - @Rule作用在测试类的Timeout类型的属性上，作为测试类的全部测试方法的统一超时规则，只要有一个测试方法超时，便抛出异常，测试便失败；
 */
@FixMethodOrder(MethodSorters.DEFAULT)
public class JUnitTimeoutTest {

    /**
     * 设定统一超时规则
     */
    @Rule
    public Timeout timeout=new Timeout(5000);

    @Test(timeout = 1)
    public void testTimeout_0(){
        //TODO
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }

    @Test(timeout = 1)
    public void testTimeout_1(){
        //TODO
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }
}

套件测试

测试类一：A_ModelTest

public class A_ModelTest {
    @Test
    public void _test(){
        System.out.println("testing A model...");
    }
}

测试类二：B_ModelTest

public class B_ModelTest {
    @Test
    public void _test(){
        System.out.println("testing B model...");
    }
}

测试套件类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

/**
 * 测试套件类
 * 注解：
 * - @RunWith：指定单元测试执行类，默认使用Suit
 * - @SuiteClasses：“{}”括起来的测试类的所有测试方法被包装到一个测试套件中，都会被执行；
 */
@RunWith(Suite.class)
@SuiteClasses({A_ModelTest.class,B_ModelTest.class})
public class JUnitSuitTest {

}

参数化测试
@RunWith, 当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器。

要进行参数化测试，需要在类上面指定如下的运行器：
@RunWith (Parameterized.class)
然后，在提供数据的方法上加上一个@Parameters注解，这个方法必须是静态static的，并且返回一个集合Collection。

在测试类的构造方法中为各个参数赋值，（构造方法是由JUnit调用的），最后编写测试类，它会根据参数的组数来运行测试多次。

注意：必须要为类的所有字段赋值，不管你是不是都用到！否则，Junit会出错。

JUnit4中参数化测试要点：
1. 测试类必须由Parameterized测试运行器修饰
2. 准备数据。数据的准备需要在一个方法中进行，该方法需要满足一定的要求：
1）该方法必须由Parameters注解修饰
2）该方法必须为public static的
3）该方法必须返回Collection类型
4）该方法的名字不做要求
5）该方法没有参数
如：

public class Add {
　　public int add(int input1, int input2) {
　　　　return input1 + input2;
　　}
}

package org.test;  

import java.util.Arrays;  
import java.util.Collection;  

import org.junit.Assert;  
import org.junit.Test;  
import org.junit.runner.RunWith;  
import org.junit.runners.Parameterized;  
import org.junit.runners.Parameterized.Parameters;  
/** 
 * 参数化测试的类必须有Parameterized测试运行器修饰 
 * 
 */  
@RunWith(Parameterized.class)  
public class AddTest3 {  

    private int input1;  
    private int input2;  
    private int expected;  

    /** 
     * 准备数据。数据的准备需要在一个方法中进行，该方法需要满足一定的要求： 

         1）该方法必须由Parameters注解修饰 
         2）该方法必须为public static的 
         3）该方法必须返回Collection类型 
         4）该方法的名字不做要求 
         5）该方法没有参数 
     * @return 
     */  
    @Parameters  
    @SuppressWarnings("unchecked")  
    public static Collection prepareData(){  
        Object [][] bject = {{-1,-2,-3},{0,2,2},{-1,1,0},{1,2,3}};  
        return Arrays.asList(object);  
    }  

    public AddTest3(int input1,int input2,int expected){  
        this.input1 = input1;  
        this.input2 = input2;  
        this.expected = expected;  
    }  
    @Test  
    public void testAdd(){  
        Add add = new Add();  
        int result = add.add(input1, input2);  
        Assert.assertEquals(expected,result);  
    }  

}

注：在测试的时候，例如我，在测试函数的时候，单独测试一个方法，而不是将一个类中的所有的方法进行测试，而在参数化测试过程中，使用上面的测试方法，一直不能通过，到后来没有办法了，运行了整个测试类，代码通过了，回头一想也也确实这么回事，这个参数化方法测试函数需要上面的参数，而单独运行一个函数的话就无法获取上面的变量。所有在测试参数化测试用例的时候，要运行整个测试类。