Junit4

JUnit 4

• JUnit 4：https://junit.org/junit4/
• JUnit 5：https://junit.org/junit5/

注解

注解	描述
@Test	修饰测试方法
@Before	修饰的方法在类中的每个测试之前执行
@BeforeClass	修饰静态方法，在类中的每个测试之前执行
@After	修饰的方法在类中的每个测试之后执行
@AfterClass	修饰静态方法，在类中的每个测试之后前执行
@Ignore	修饰的方法暂时禁用测试
@SuiteClasses	套件测试
@Runwith	修饰测试类
@Parameters	参数化测试

import org.junit.*;

public class JunitTest {
    @BeforeClass
    public static void beforeClass() {
        System.out.println("in before class");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("in after class");
    }

    @Before
    public void before() {
        System.out.println("in before");
    }

    @After
    public void after() {
        System.out.println("in after");
    }

    @Test
    public void testCase1() {
        System.out.println("in test case 1");
    }

    @Test
    public void testCase2() {
        System.out.println("in test case 2");
    }
    
    @Ignore
    @Test
    public void testCase3() {
        System.out.println("in test case 3");
    }
}

in before class
in before
in test case 1
in after
in before
in test case 2
in after

Test ignored.
in after class

断言

Assert类方法	描述
assertEquals	判断对象的内容是否相等
assertArrayEquals	判断数组的内容是否相等
assertNotSame/assertSame	判断是否引用同个对象
assertNotNull/assertNull	判断对象是否为null
assertTrue/assertFalse	判断真假

import org.junit.Assert;
import org.junit.Test;

public class AssertionTest {

    @Test
    public void test() {
        String obj1 = "junit";
        String obj2 = "junit";
        String obj3 = "test";
        String obj4 = "test";
        String obj5 = null;
        
        int var1 = 1;
        int var2 = 2;

        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};

        Assert.assertEquals(obj1, obj2);

        Assert.assertSame(obj3, obj4);
        Assert.assertNotSame(obj2, obj4);
        
        Assert.assertNotNull(obj1);
        Assert.assertNull(obj5);

        Assert.assertTrue(var1 < var2);
        Assert.assertFalse(var1 > var2);

        Assert.assertArrayEquals(array1, array2);

    }
}

套件测试

import org.junit.Test;

public class JunitTest1 {
    @Test
    public void printMessage(){
        System.out.println("in JunitTest1");
    }
}

import org.junit.Test;

public class JunitTest2 {
    @Test
    public void printMessage(){
        System.out.println("in JunitTest2");
    }
}

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

@RunWith(Suite.class)
@Suite.SuiteClasses({
        /**
         * 此处类的配置顺序会影响执行顺序
         */
        JunitTest1.class,
        JunitTest2.class
})
public class JunitSuite {
	// 保持空即可
}

in JunitTest1
in JunitTest2

参数化测试

• 使用不同的值反复运行同一个测试

public class PrimeNumberChecker {
    public Boolean validate(final Integer parimeNumber) {
        for (int i = 2; i < (parimeNumber / 2); i++) {
            if (parimeNumber % i == 0) {
                return false;
            }
        }
        return true;
    }
}

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

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

/**
 * 步骤一: 指定定参数运行器（默认运行器是JUnit4.class）
 */
@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
    /**
     * 步骤二：声明变量
     */
    private Integer inputNumber;
    private Boolean expectedResult;
    private PrimeNumberChecker primeNumberChecker;

    /**
     * 步骤三：为测试类声明一个带有参数的公共构造函数，为变量赋值
     */
    public PrimeNumberCheckerTest(Integer inputNumber,
                                  Boolean expectedResult) {
        this.inputNumber = inputNumber;
        this.expectedResult = expectedResult;
    }

    /**
     * 步骤四：为测试类声明一个使用注解 org.junit.runners.Parameterized.Parameters 修饰的，返回值为
     * java.util.Collection 的公共静态方法，并在此方法中初始化所有需要测试的参数对
     *   1）该方法必须由Parameters注解修饰 
          2）该方法必须为public static的 
          3）该方法必须返回Collection类型 
          4）该方法的名字不做要求 
          5）该方法没有参数 
     */
    @Parameterized.Parameters
    public static Collection primeNumbers() {
        return Arrays.asList(new Object[][]{
                {2, true},
                {6, false},
                {19, true},
                {22, false},
                {23, true}
        });
    }

    @Before
    public void initialize() {
        primeNumberChecker = new PrimeNumberChecker();
    }

    /**
     * 步骤五：编写测试方法，使用自定义变量进行测试
     */
    @Test
    public void testPrimeNumberChecker() {
        System.out.println("Parameterized Number is : " + inputNumber);
        Assert.assertEquals(expectedResult,
                primeNumberChecker.validate(inputNumber));
    }
}

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23

时间测试

@Test(timeout = 1000)
public void testCase1() throws InterruptedException {
    TimeUnit.SECONDS.sleep(5000);
    System.out.println("in test case 1");
}

org.junit.runners.model.TestTimedOutException: test timed out after 1000 milliseconds…

异常测试

@Test(expected = ArithmeticException.class)
public void testCase3() {
    System.out.println("in test case 3");
    // int a = 0;	// 得到预期异常才能通过测试
    int a = 1;
    int b = 1 / a;
}

java.lang.AssertionError: Expected exception: java.lang.ArithmeticException

Junit 4 与 JUnit 5的比较

描述	JUNIT 4	JUNIT 5
声明一种测试方法	@Test	@Test
在当前类中的所有测试方法之前执行	@BeforeClass	@BeforeAll
在当前类中的所有测试方法之后执行	@AfterClass	@AfterAll
在每个测试方法之前执行	@Before	@BeforeEach
每种测试方法后执行	@After	@AfterEach
禁用测试方法/类	@Ignore	@Disabled
测试工厂进行动态测试	NA	@TestFactory
嵌套测试	NA	@Nested
标记和过滤	@Category	@Tag
注册自定义扩展	NA	@ExtendWith
断言	org.junit.Assert	org.junit.jupiter.Assertions
假设	org.junit.Assume	org.junit.jupiter.api.Assumptions

Junit5 套件测试

import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.SelectPackages;
import org.junit.runner.RunWith;

@RunWith(JUnitPlatform.class)
@SelectPackages("com.howtodoinjava.junit5.examples")
// @SelectClasses
public class JUnit5Example{
    // do nothing
}

参考博客：

https://juejin.im/post/5c7fbfdd6fb9a049ef275a60

https://blog.csdn.net/u010675669/article/details/86574956