未读代码 未读代码
首页
  • Java 18 新功能介绍
  • Java 17 新功能介绍
  • Java 16 新功能介绍
  • Java 15 新功能介绍
  • Java 14 新功能介绍
  • Java 8 新特性

    • Java 8 Lambda 表达式
    • Java 8 Stream 流式操作
    • Java 8 时间处理介绍
    • Java 8 Optional 介绍
  • Java 开发工具
Java 源码分析
Spring Boot 系列
  • Arthas 问题定位
  • JMH 基准测试
GitHub (opens new window)
首页
  • Java 18 新功能介绍
  • Java 17 新功能介绍
  • Java 16 新功能介绍
  • Java 15 新功能介绍
  • Java 14 新功能介绍
  • Java 8 新特性

    • Java 8 Lambda 表达式
    • Java 8 Stream 流式操作
    • Java 8 时间处理介绍
    • Java 8 Optional 介绍
  • Java 开发工具
Java 源码分析
Spring Boot 系列
  • Arthas 问题定位
  • JMH 基准测试
GitHub (opens new window)
  • Java 开发

    • 你好 ChatGPT, 帮我看下这段代码有什么问题?
    • 如何搭建一个自己的音乐服务器
    • JUnit 5 单元测试教程
      • JUnit 5 介绍
        • JUnit 5 和 JUnit
      • JUnit 5 基本组件
      • JUnit 5 依赖
      • JUnit 5 常用注解
        • @Test
        • @BeforeAll
        • @BeforeEach
        • @AfterAll
        • @AfterEach
        • @Disabled
        • @DisplayName
        • @ParameterizedTest
        • @Order
        • 其他注解
      • JUnit 5 常用断言
      • Maven JUnit 测试
    • 使用 StringUtils.split 的坑
    • 必应壁纸,我的第一个 400 Star 开源项目
    • Java 中的对象池实现
    • 5种限流算法,7种限流方式,挡住突发流量?
    • Java 中拼接 String 的 N 种方式
    • 字符作画,我用字符画个冰墩墩
    • 5 分钟复现 log4J 漏洞,手把手实现
    • 如何使用 Github Actions 自动抓取每日必应壁纸?
    • 撸了个多线程断点续传下载器,我从中学习到了这些知识
    • 三种骚操作绕过迭代器遍历时的数据修改异常
    • 一篇有趣的负载均衡算法实现
    • Java 中 RMI 的使用
    • Java 开发的编程噩梦,这些坑你没踩过算我输
  • Java 开发工具

  • 消息中间件

  • Java 开发
  • Java 开发
程序猿阿朗
2022-11-17

JUnit 5 单元测试教程

JUnit5

在软件开发过程中,我们通常都需要测试自己的代码运行是否正常,可能对一个函数进行简单测试,也可能是多个功能的组合测试。不管使用哪种方式,都是为了更好的测试我们的代码是否存在逻辑缺陷。测试对于软件开发是非常必要的。

# JUnit 5 介绍

在 Java 中比较有名的测试工具是 JUnit ,通常我们使用 JUnit 可以对一个逻辑单元进行测试,因此也叫单元测试。多个单元测试组合测试,可以确保我们的程序符合预期。JUnit 单元测试可以在开发阶段发现问题,让我们可以提前修复代码,因此十分重要。

# JUnit 5 和 JUnit

JUnit 是一个 Java 语言的开源测试框架,使用 JUnit 让我们使用注解就可以进行单元测试,很是方便。

JUnit 5 是 JUnit 的升级版本,JUnit 5 使用了 Java 8 及更高版本的 Java 语言特性,如函数编程,流式编码等,因此更加强大。JUnit 5 进行单元测试的可读性更强,编写更加容易,且可以轻松扩展。

# JUnit 5 基本组件

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

JUnit 5 jupiter 依赖

JUnit Platform

JUnit Platform 是 JUnit 的基础框架,使用 JUnit Platform 才能在 JVM 启动测试,JUnit Platform 还定义了 TestEngine 测试引擎,是JUnit 测试的基础。

JUnit Jupiter

JUnit Jupiter 提供了单元测试常见的注解以及扩展接口,想要方便的进行 JUnit 单元测试,那么 Jupiter 模块就必不可少。

JUnit Vintage

JUnit Vintage 提供了对 JUnit 3 和 JUnit 4 的测试支持。

# JUnit 5 依赖

使用注解进行 JUnit 单元测试,直接引入 junit-jupiter即可。

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
  	<version>5.9.1</version>
    <scope>test</scope>
</dependency>
1
2
3
4
5
6

# JUnit 5 常用注解

# @Test

为一个 public void 方法添加 @Test 注释,允许我们对这个方法进行测试。

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/** 
 * @author:https://www.wdbyte.com  
 **/
class JUnitTestIsDog {

    @Test
    public void testIsDog() {
        String name = "cat";
        Assertions.assertEquals(name, "dog");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

上面的代码中使用了 Assertions.assertEquals(name, "dog") 来判断是否 name 变量是否是 dog,Assertions 是 JUnit 提供的断言工具,后面会详细介绍。

在 idea 中运行可以到的错误日志,提示预期是 dog,实际是 cat

org.opentest4j.AssertionFailedError: 
Expected :cat
Actual   :dog
<Click to see difference>
1
2
3
4

如果是符合预期的,那么运行会显示正确标志。

@Test
public void testIsDog2() {
    String name = "dog";
    Assertions.assertEquals(name, "dog");
}
1
2
3
4
5

testIsDog2 方法测试通过。

JUnit 测试通过

# @BeforeAll

使用 @BeforeAll 可以在单元测试前初始化部分信息,@BeforeAll 只能使用在静态方法上,被注解的方法会在测试开始前运行一次。

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/** 
 * @author:https://www.wdbyte.com  
 **/
class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @Test
    public void testIsDog() {
        String name = "dog";
        Assertions.assertEquals(name, "dog");
        System.out.println("is dog");
    }

    @Test
    public void testIsCat() {
        String name = "cat";
        Assertions.assertEquals(name, "cat");
        System.out.println("is cat");
    }
}

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

这会输出:

初始化,准备测试信息
is cat
is dog
1
2
3

# @BeforeEach

使用 @BeforeEach 注解的方法,会在每一个 @Test 注解的方法运行前运行一次。

class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @BeforeEach
    public void start(){
        System.out.println("开始测试...");
    }

    @Test
    public void testIsDog() {
        String name = "dog";
        Assertions.assertEquals(name, "dog");
        System.out.println("is dog");
    }

    @Test
    public void testIsCat() {
        String name = "cat";
        Assertions.assertEquals(name, "cat");
        System.out.println("is cat");
    }
}
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

这会输出:

初始化,准备测试信息
开始测试...
is cat
开始测试...
is dog
1
2
3
4
5

# @AfterAll

@AfterAll 注解只能使用在静态方法上,被注解的方法会在所有单元测试运行完毕后运行一次。

class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @BeforeEach
    public void start(){
        System.out.println("开始测试...");
    }

    @Test
    public void testIsDog() {
       //...
    }

    @Test
    public void testIsCat() {
        //...
    }

    @AfterAll
    public static void close() {
        System.out.println("结束,准备退出测试");
    }
}
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

这会输出:

初始化,准备测试信息
开始测试...
is cat
开始测试...
is dog
结束,准备退出测试
1
2
3
4
5
6

# @AfterEach

使用 @AfterEach 注解的方法,会在每一个 @Test 注解的方法运行结束前运行一次。

class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @BeforeEach
    public void start(){
        System.out.println("开始测试...");
    }

    @Test
    public void testIsDog() { //... }

    @Test
    public void testIsCat() { //... }

    @AfterEach
    public void end(){
        System.out.println("测试完毕...");
    }

    @AfterAll
    public static void close() {
        System.out.println("结束,准备退出测试");
    }
}
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

这会输出:

初始化,准备测试信息
开始测试...
is cat
测试完毕...
开始测试...
is dog
测试完毕...
结束,准备退出测试
1
2
3
4
5
6
7
8

# @Disabled

被 @Disabled 注解的方法不在参与测试,下面对 testIsDog 方法添加了 @Disabled 注解。

class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @BeforeEach
    public void start(){
        System.out.println("开始测试...");
    }

    @Disabled("由于xx原因,关闭 testIsDog 测试")
    @Test
    public void testIsDog() {
        String name = "dog";
        Assertions.assertEquals(name, "dog");
        System.out.println("is dog");
    }

    @Test
    public void testIsCat() {
        String name = "cat";
        Assertions.assertEquals(name, "cat");
        System.out.println("is cat");
    }

    @AfterEach
    public void end(){
        System.out.println("测试完毕...");
    }

    @AfterAll
    public static void close() {
        System.out.println("结束,准备退出测试");
    }
}
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
34
35
36
37

这会输出:

初始化,准备测试信息
开始测试...
is cat
测试完毕...

由于xx原因,关闭 testIsDog 测试
结束,准备退出测试
1
2
3
4
5
6
7

# @DisplayName

使用 @DisplayName 注解可以自定义测试方法的显示名称,下面为两个测试方法自定义名称。

class JUnitBeforeAll {

    @BeforeAll
    public static void init() {
        System.out.println("初始化,准备测试信息");
    }

    @BeforeEach
    public void start() {
        System.out.println("开始测试...");
    }

    @DisplayName("是否是狗")
    @Disabled
    @Test
    public void testIsDog() {
        String name = "dog";
        Assertions.assertEquals(name, "dog");
        System.out.println("is dog");
    }

    @DisplayName("是否是猫")
    @Test
    public void testIsCat() {
        String name = "cat";
        Assertions.assertEquals(name, "cat");
        System.out.println("is cat");
    }

    @AfterEach
    public void end() {
        System.out.println("测试完毕...");
    }

    @AfterAll
    public static void close() {
        System.out.println("结束,准备退出测试");
    }
}
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
34
35
36
37
38
39

在 idea 中运行后,可以看到配置的中文名称。

DisplayName

# @ParameterizedTest

使用注解 @ParameterizedTest 结合 @ValueSource ,可以对不用的入参进行测试。下面的示例使用 @ParameterizedTest 来开始参数化单元测试,name 属性用来定义测试名称,@ValueSource 则定义了两个测试值。

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class JUnitParam {

    //@Test
    @DisplayName("是否是狗")
    @ValueSource(strings = {"dog", "cat"})
    @ParameterizedTest(name = "开始测试入参 {0} ")
    public void testIsDog(String name) {
        Assertions.assertEquals(name, "dog");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这会输出:

JUnit 参数测试

# @Order

在类上增加注解 @TestMethodOrder ,然后在方法上使用 @Order 指定顺序,数字越小优先级越高,可以保证测试方法运行顺序。

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.condition.EnabledOnJre;

import static org.junit.jupiter.api.condition.JRE.JAVA_19;

@TestMethodOrder(OrderAnnotation.class)
public class JUnitOrder{

    @Test
    @DisplayName("测试是否是狗")
    @Order(2)
    public void testIsDog() {
        String name = "dog";
        Assertions.assertEquals(name, "dog");
        System.out.println("is dog");
    }

    @DisplayName("是否是猫")
    @Test
    @Order(1)
    public void testIsCat() {
        String name = "cat";
        Assertions.assertEquals(name, "cat");
        System.out.println("is cat");
    }
}
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

这会输出:

is cat
is dog
1
2

# 其他注解

@EnabledOnJre(JAVA_19)

只在 JRE 19 环境运行,否则运行会输出:Disabled on JRE version: xxx.

@RepeatedTest(10)

重复测试,参数 10 可以让单元测试重复运行 10 次。

# JUnit 5 常用断言

在上面的例子中,已经用到了 assertEquals 来判断结果是否符合预期,assertEquals是类 org.junit.jupiter.api.Assertions 中的一个方法;除此之外,还几乎包括了所有我们日常测试想要用到的判断方法。

下面是一些演示:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

public class JunitAssert {

    @DisplayName("是否是狗")
    @Test
    public void testIsDog() {
        String name = "dog";
        Assertions.assertNotNull(name);
        Assertions.assertEquals(name, "dog");
        Assertions.assertNotEquals(name, "cat");
        Assertions.assertTrue("dog".equals(name));
        Assertions.assertFalse("cat".equals(name));
    }

    @DisplayName("是否是猫")
    @Test
    public void testIsCat() {
        String name = "cat";
        Assertions.assertNull(name, "name is not null");
    }

}
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

在 testIsDog 中演示了一些常用的判断方法,且都可以通过验证。在 testIsCat 方法中进行了 null 值判断,显然这里无法通过测试,会抛出自定义异常 name is not null。

这会输出:

org.opentest4j.AssertionFailedError: name is not null ==> 
Expected :null
Actual   :cat
<Click to see difference>
1
2
3
4

预期是一个 null 值,实际上是一个 cat 字符串。

# Maven JUnit 测试

在 Maven 中进行 JUnit 测试,可以通过命令 mvn test 开始测试,默认情况下会测试所有依赖了当前源码的 JUnit 测试用例。

准备被测 Preson类放在 src.main.java.com.wdbyte.test.junit5.

package com.wdbyte.test.junit5;

public class Person {
    public int getLuckyNumber() {
        return 7;
    }
}
1
2
3
4
5
6
7

编写测试类 PersonTest 放在 src.test.java.com.wdbyte.test.junit5. 这里判断获取到的幸运数字是否是 8 ,明显方法返回的是 7 ,所以这里是测试会报错。

package com.wdbyte.test.junit5;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("测试 Presion")
class PersonTest {

    @DisplayName("测试幸运数字")
    @Test
    void getLuckyNumber() {
        Person person = new Person();
        Assertions.assertEquals(8, person.getLuckyNumber());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在 pom.xml 中引入 maven junit 测试依赖插件。

<build>
     <plugins>
         <plugin>
             <artifactId>maven-surefire-plugin</artifactId>
             <version>2.22.2</version>
         </plugin>
         <plugin>
             <artifactId>maven-failsafe-plugin</artifactId>
             <version>2.22.2</version>
         </plugin>
     </plugins>
</build>
1
2
3
4
5
6
7
8
9
10
11
12

执行测试命令:mvn test

➜  junit5-jupiter-starter git:(master) ✗ mvn test
[INFO] Scanning for projects...
[INFO] ....
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.wdbyte.test.junit5.PersonTest
[ERROR] Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.031 s <<< FAILURE! - in com.wdbyte.test.junit5.PersonTest
[ERROR] getLuckyNumber  Time elapsed: 0.026 s  <<< FAILURE!
org.opentest4j.AssertionFailedError: expected: <8> but was: <7>
	at com.wdbyte.test.junit5.PersonTest.getLuckyNumber(PersonTest.java:18)

[INFO]
[INFO] Results:
[INFO]
[ERROR] Failures:
[ERROR]   PersonTest.getLuckyNumber:18 expected: <8> but was: <7>
[INFO]
[ERROR] Tests run: 1, Failures: 1, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  1.777 s
[INFO] Finished at: 2022-11-17T23:01:09+08:00
[INFO] ------------------------------------------------------------------------
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

也可以指定类进行测试:mvn -Dtest=PersonTest test

一如既往,文章中代码存放在 Github.com/niumoo/javaNotes (opens new window).

订阅

文章持续更新,订阅可以关注「 程序猿阿朗 」公众号或者未读代码博客。

文章作者: 程序猿阿朗
文章链接:https://www.wdbyte.com/java/junit5.html
版权声明:本网站当前文章采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 未读代码!
#单元测试
上次更新: 2023/03/15, 09:22:31
如何搭建一个自己的音乐服务器
使用 StringUtils.split 的坑

← 如何搭建一个自己的音乐服务器 使用 StringUtils.split 的坑→

最近更新
01
JFR 使用教程
03-15
02
JMC 使用教程
03-15
03
你好 ChatGPT, 帮我看下这段代码有什么问题?
02-14
更多文章>

提示:评论前请刷新页面,否则评论的可能不是当前文章。

Theme by Vdoing | Copyright © 2018-2023 程序猿阿朗 | MIT License | 皖ICP备20000567号-1
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式