JUnit API

提示

只打印的单测是没有意义的,正确使用单测工具, 提高单测质量。

​​#​​ 一、常用注解

​​#​​ 1.1 @Before & @After

单测类中每个单测方法执行都会触发这两个方法

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

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

1 2 3 4 5 6 7 8 9

​​#​​ 1.2 @BeforeClass & @AfterClass

区别与上一个,不管单测类中有几个单测方法,都只会执行一次

要用静态修饰

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

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

1 2 3 4 5 6 7 8 9

代码实例

针对上面说的两个注解演示一下

• beforeClass
• before
• testOne
• after
• before
• testTwo
• after
• afterClass

---

public class JUnitTest {

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

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

    @Test
    public void testOne() {
        System.out.println("testOne");
    }

    @Test
    public void testTwo() {
        System.out.println("testTwo");
    }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

​​#​​ 1.3 @Timed

被修饰的方法会加上一个时间限制,如果超过了指定的时间范围,就算单侧代码执行成功 了也被认为是失败。(注意该方法依赖于SpringBoot容器)

@Timed

@Test
    @Timed(millis = 2000)
    public void testTimeout() {
        System.out.println("testOne");
    }

1 2 3 4 5

​​#​​ 1.4 @Repeat

指定当前单测方法被执行的次数,如果被该注解修饰 将会被重复执行。(注意该方法依赖于SpringBoot容器)

@Repeat

@Test
    @Repeat(3)
    public void testOne() {
        System.out.println("testOne");
    }

1 2 3 4 5

​​#​​ 二、断言API

断言的好处在于程序帮忙判断单测结果。不需要人工在接入验证数据。JUnit的口号就是

​​keep the bar green to keep the code clean。​​

一个不用观察输出就知道代码有没有问题的高效单元测试工具。

import org.hamcrest.Matchers;
import org.hamcrest.core.AllOf;
import org.hamcrest.core.AnyOf;

1 2 3

​​#​​ 2.1 Matchers

Matchers

// 是否相等
        Assert.assertThat(2, (2));
        // 2 小于等于2
        Assert.assertThat(2,Matchers.lessThanOrEqualTo(2));
        Map<String,String> map = new HashMap<>();
        map.put("name","jay");
        // map 中是否包含key为name的元素
        Assert.assertThat(map,Matchers.hasKey("name"));
        // map 中是否包含value为jay的元素
        Assert.assertThat(map,Matchers.hasValue("jay"));
        // map 中是否包含name等于jay的元素
        Assert.assertThat(map,Matchers.hasEntry("name","jay"));

1 2 3 4 5 6 7 8 9 10 11 12

​​#​​ 2.2 AllOf

全部满足

// 2 小于4同时也小于3
   Assert.assertThat(2, AllOf.allOf(Matchers.lessThan(4), Matchers.lessThan(3)));

1 2

​​#​​ 2.3 AnyOf

任意满足

// 2 大于1小于3
   Assert.assertThat(2, AnyOf.anyOf(Matchers.greaterThan(1), Matchers.lessThan(3)));

1 2

​​#​​ 三、结果验证

​​#​​ 3.1 空值验证

@Test
    public void test() {
        Object o = new Object();
        // 非空验证
        Assert.assertNotNull(o);
        // 空值验证
        Assert.assertNull(null);
    }

1 2 3 4 5 6 7 8

​​#​​ 3.2 逻辑验证

import static org.hamcrest.MatcherAssert.*;
    import static org.hamcrest.CoreMatchers.*;
    public calss Test{
        @Test
        public void test() {
            //测试变量是否大于指定值
            ArrivalNoticeOrderDO ao = new ArrivalNoticeOrderDO();
            ao.setId(12L);
            //测试所有条件必须成立
            assertThat(ao.getId(), allOf(is(12L)));
            //测试只要有一个条件成立
            assertThat(ao.getId(), anyOf(is(50), is(12L)));
            //测试变量值等于指定值
            assertThat(ao.getId(), is(12L));
        }
    }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

​​#​​ 3.3 异常验证

/**
     * 预期异常
     */
    @Test(expected = NullPointerException.class)
    public void testError(){
        Object o = null;
        System.out.println(o.toString());
    }

1 2 3 4 5 6 7 8

​​#​​ 四、快速创建

建议使用 ​​Idea​​ 自动创建, 不要手动创建。