测试课堂JUnit 4 / JUnit 5
软件测试 · JUnit 专题 · 第三部分

JUnit 4 与 JUnit 5
有什么不同?

从架构、注解、断言到新特性,
用同一组测试,一次讲清楚。

27 页7 个部分约 51 分钟
本课固定对比 4.13.2 / 5.14.4

课堂使用,先看这里

全部本地 · 可离线

点「开始讲课」,按 ← → 或 空格 翻页;也支持 PageUp / PageDown、Home / End。顶部可切换阅读、全屏与讲稿。

第 16 页有 1 项故意失败。fail-demo 在 mvn test 中被排除,IDEA 单跑会显示红色。

课前在 source/junit-demo/ 提前执行 mvn test 下载依赖,并确认测试数量不为 0。

网站互动在浏览器中模拟测试;真实 Java 测试可在随附 Maven 项目中运行。

讲稿第 1 页 · 教师提示
  • 承接前两部分的安装与基础语法:这节课比较 JUnit 4 和 5。教材与老项目常见 4,新项目常见 5。
  • 今天用同一组真实测试,对比架构、写法、组织能力,再讲迁移与 JUnit 6。
  • 课前确认 Maven 依赖已下载。五个主演示共享同一个项目,时间紧时保留第 5、15、16 页。
01 开场与背景

今天讲这七件事

先理解架构,再比较写法,最后回到真实项目。

讲稿第 2 页 · 教师提示
  • 七部分按“为什么改变 → 架构 → 写法 → 表达能力 → 迁移”展开。
  • 架构是最本质的区别,代码变化要联系这个基础来理解。
  • 五个主演示位于第 10、13、16、17、19 页,可以点页码直接跳转。
01 开场与背景

四代演进:从 JUnit 3 到 JUnit 6

每一代都在改变“怎样发现、编写与运行测试”。

2000 年代初

JUnit 3

继承 TestCase
方法名以 test 开头

靠继承与命名约定
2006

JUnit 4

引入 @Test 注解
不再强制继承父类

Java 5
2017

JUnit 5

重新设计,模块化
支持 Lambda 表达

Java 8
2025

JUnit 6

延续 Jupiter 写法
提高运行环境要求

Java 17
今天的主角JUnit 4.13.2vsJUnit 5.14.4
讲稿第 3 页 · 教师提示
  • JUnit 3 靠继承 TestCase 和 test 前缀识别测试;JUnit 4 借助 Java 5 的注解摆脱父类约束。
  • JUnit 5 于 2017 年重做架构、要求 Java 8;JUnit 6 于 2025 年发布、要求 Java 17,常用 Jupiter 写法延续。
  • 比较固定版本 4.13.2 与 5.14.4:后期 JUnit 4 也补了一些能力,不能把它们说成 5 独有。
01 开场与背景

为什么需要重新设计?

功能能够实现,组合与表达却越来越费力。

01

平台接口边界不清

IDE、构建工具依赖内部结构,框架一改,周边工具就可能受到影响。

02

Runner 难以组合

一个测试类只能有一个 @RunWith,Spring 与参数化 Runner 不能直接叠加。

03

早期模型的约束

核心模型来自 Java 5 时代,后来不断补功能,整体扩展仍受原设计限制。

04

复杂测试表达成本高

分组检查、参数化等能够实现,但常要借助额外 Rule 或 Runner。

2015 · JUnit Lambda 众筹成为 JUnit 5 重新设计的起点。
讲稿第 4 页 · 教师提示
  • API 与内部实现边界不清,IDE 和构建工具依赖内部结构,框架演进会牵动周边工具。
  • 一个类只能有一个 @RunWith;Spring Runner 和参数化 Runner 不能直接叠加。Rule 可以多个。
  • JUnit 4 能做参数化与汇总检查,只是额外 Runner / Rule 增加表达成本。2015 年 JUnit Lambda 众筹启动重设计。
02 模块化架构 全场重点

JUnit 5 = Platform + Jupiter + Vintage

从上往下看:入口启动平台,平台调用测试引擎。

JUnit 4
一个核心依赖junit:junit
测试 APIRunnerRule

编写与运行能力
集中在同一个核心依赖

JUnit 5把启动、编写与执行分开
01 · 测试执行入口
IntelliJ IDEAEclipseMavenGradle
↓ Launcher API
02 · 启动与发现

JUnit Platform

Launcher API + TestEngine SPI

发现并调用已注册的测试引擎
↓ TestEngine SPI
03 · 执行引擎

Jupiter Engine

运行 JUnit 5 测试

03 · 执行引擎

Vintage Engine

运行 JUnit 3 / 4 测试

Platform 定义接口,引擎提供实现。新旧测试可以共存;全部使用 Jupiter 的新项目不必安装 Vintage。
讲稿第 5 页 · 教师提示
  • 这一页是全场重点。先看 JUnit 4:一个 junit:junit 核心依赖提供测试 API、Runner、Rule。
  • 按箭头往下讲:IDE / 构建工具调用 Launcher API;Platform 发现测试,并通过 TestEngine SPI 调用注册的引擎。
  • Jupiter 跑 JUnit 5 测试,Vintage 跑 JUnit 3 / 4 老测试,所以两代测试能共存。
  • 我们说的“JUnit 5 写法”通常指 Jupiter。全新的 Jupiter 项目不必安装 Vintage。
02 模块化架构

三个模块,各管什么?

Java 包名用于 import,Maven Artifact ID 用于依赖声明。

P

Platform

启动与引擎接口
Launcher / TestEngine

J

Jupiter

编写新测试的 API
及运行新测试的引擎

V

Vintage

兼容旧测试
让 JUnit 3 / 4 在新平台运行

模块Java 包名 · 写在 importMaven Artifact ID · 写在 pom
Platformorg.junit.platform.*junit-platform-launcher
Jupiter APIorg.junit.jupiter.apijunit-jupiter-api
Jupiter Engineorg.junit.jupiter.enginejunit-jupiter-engine
Vintageorg.junit.vintage.enginejunit-vintage-engine
Platform 是插座,引擎是插头。插上哪个引擎,就能运行对应的测试。
讲稿第 6 页 · 教师提示
  • Platform 定义启动与引擎接口;Jupiter 提供编写测试的 API 和执行引擎;Vintage 负责旧测试兼容。
  • 务必区分表里的 Java 包名(import)和 Maven Artifact ID(pom.xml),它们不是同一件事。
  • 用插座与插头的比喻帮助记忆:Platform 是插座,Jupiter、Vintage 是可插入的引擎。
02 模块化架构

架构如何体现在 Maven 里?

对比固定版本;演示项目另外带上 Vintage 兼容旧测试。

JUnit 4junit:junit:4.13.2
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.13.2</version>
  <scope>test</scope>
</dependency>
JUnit 5org.junit.jupiter:junit-jupiter:5.14.4
<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>5.14.4</version>
  <scope>test</scope>
</dependency>
junit-jupiterapiparamsengine
Surefire ≥ 2.22.0 原生支持 Platform,建议 3.x;演示项目固定 3.2.5。
演示项目的实际配置:BOM + Jupiter + Vintage

上方是独立依赖的标准写法。真实 pom.xml 用 org.junit:junit-bom:5.14.4 管理版本,Jupiter / Vintage 依赖继承它,所以没有单独写 version。

讲稿第 7 页 · 教师提示
  • JUnit 4 坐标的 groupId 和 artifactId 都是 junit;JUnit 5 使用 org.junit.jupiter:junit-jupiter。
  • junit-jupiter 是聚合包,包含 api、params、engine。演示项目用 BOM 统一版本,因此子依赖不再逐个写 version。
  • Surefire 从 2.22.0 起原生支持 Platform;演示项目固定 3.2.5,新项目建议使用 3.x。
03 包名、注解与生命周期

先看几个“表面”变化

版本变了,导入、修饰符与参数规则也要一起核对。

对比项JUnit 4JUnit 5
包名org.junitorg.junit.jupiter.api
断言类org.junit.Assertorg.junit.jupiter.api.Assertions
最低 JavaJava 5Java 8
类与方法修饰符标准测试类、方法必须 public可省略 public,不能 private
测试方法参数标准方法不支持参数注入ParameterResolver 注入;内置 TestInfo / TestReporter
@Test 属性expected / timeout属性消失;改用 assertThrows / @Timeout
先确认 import,别混用两套 API。自定义参数需要对应的 ParameterResolver。
讲稿第 8 页 · 教师提示
  • 先核对 import:org.junit 与 org.junit.jupiter.api 是不同的 API;Assert 变成 Assertions。
  • JUnit 5 可省略 public,但测试类和方法不能是 private。
  • TestInfo / TestReporter 可由内置 ParameterResolver 注入;任意自定义参数仍要对应的解析器。
  • @Test 的 expected / timeout 不再放在注解属性里,后面用 assertThrows 与 @Timeout 单独讲。
03 包名、注解与生命周期

生命周期与注解对照

Each / All 更直白;扩展那一行是真正的模型变化。

对比项JUnit 4JUnit 5
标记测试方法@Test@Test(换包)
每个测试之前@Before@BeforeEach
每个测试之后@After@AfterEach
所有测试之前一次@BeforeClass@BeforeAll
所有测试之后一次@AfterClass@AfterAll
跳过测试@Ignore@Disabled
分组 / 分类@Category@Tag
扩展@RunWith / @Rule@ExtendWith · 模型改变
@BeforeAll / @AfterAll 默认必须 static。扩展机制需要按行为迁移,见 第 21 页。
讲稿第 9 页 · 教师提示
  • Each 是每个测试之前 / 之后,All 是全部测试之前 / 之后,名字更直白。
  • @BeforeAll / @AfterAll 默认仍必须 static;PER_CLASS 生命周期是例外。
  • @RunWith / @Rule 到 @ExtendWith 是模型变化,不能简单换名字,留到第 21 页展开。
03 包名、注解与生命周期 现场演示

同一个测试,两种写法

都是验证 1 + 2 = 3。看三处差异,再分别运行。

01 import 换包02 public 可省略03 Before → BeforeEach
JUnit 4Calc4Test.java · 源码节选
import demo.Calculator;
import org.junit.*;
import static org.junit.Assert.*;
public class Calc4Test {
    Calculator calc;
    @Before public void init() {
        calc = new Calculator();
    }
    @Test public void add() {
        assertEquals(3, calc.add(1, 2));
    }
}
尚未运行 · Tests run: 0
JUnit 5Calc5Test.java · 源码节选
import demo.Calculator;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
class Calc5Test {
    Calculator calc;
    @BeforeEach void init() {
        calc = new Calculator();
    }
    @Test void add() {
        assertEquals(3, calc.add(1, 2));
    }
}
尚未运行 · Tests run: 0
分别运行两版测试,观察相同的加法结果。
同一项目如何共存?Platform → Jupiter 跑 Calc5Test / Vintage 跑 Calc4Test。真实调用都是 new Calculator() 的实例方法。
讲稿第 10 页 · 教师提示
  • 对比相同加法测试,只看三处:import、public、@Before → @BeforeEach。断言这一行外观相同,来自不同 API。
  • 分别点运行 Calc4Test 与 Calc5Test,看两边都通过。真实类使用 calc = new Calculator(),加法是实例方法。
  • 共存的路径是 Platform 调用 Jupiter Engine / Vintage Engine。类名不同只是为了在同一项目中并存。
03 包名、注解与生命周期

六个新注解,先认个脸

六个名字,对应后面几个可实际操作的例子。

讲稿第 11 页 · 教师提示
  • 这一页是后续路线图,先认名字,不展开细节。@Timeout 在第 14 页,其余在第 17–20 页。
  • @ParameterizedTest 属于单独的 params 模块,而不是 org.junit.jupiter.api;junit-jupiter 聚合包已带上它。
  • 时间紧时可以快速带过这一页。
04 断言与异常

提示信息:从第一个到最后一个

名字看起来没变,三个参数的含义却可能已经变了。

JUnit 4第 1 个参数
JUnit 5最后 1 个参数
JUnit 4Assert · 消息在前
assertEquals("加法结果错误", 3, calc.add(1, 2));
assertTrue("应该是正数", result > 0);
JUnit 5Assertions · 消息在后
assertEquals(3, calc.add(1, 2), "加法结果错误");
// 失败时才拼接消息
assertTrue(result > 0, () -> "结果是 " + result);
三字符串迁移坑:assertEquals("提示", "A", actual) 只改 import 仍能编译,但在 JUnit 5 中“提示”成为 expected,“A”成为 actual,原 actual 成为消息。正确改成 assertEquals("A", actual, "提示")。

本页是讲稿中的断言片段,calc 为 Calculator 实例;完整加法测试见第 10 页。

讲稿第 12 页 · 教师提示
  • JUnit 4 把失败提示放在第一个参数,JUnit 5 放在最后一个参数。
  • JUnit 5 可以传消息 Supplier:只有失败时才计算字符串,避免通过时白白拼接。
  • 重点看三字符串迁移:assertEquals("提示", "A", actual) 只改 import 仍能编译,但“提示”被当作 expected。
04 断言与异常 现场演示

assertAll:一次看到所有失败

改错两项期望,比较“遇错即停”和“统一报告”。

实际对象:new Person("张", "三")

浏览器模拟

普通断言 · 遇错即停

JUnit 5plainAsserts · 源码节选
assertEquals(EXPECTED_FIRST, p.getFirst());
assertEquals(EXPECTED_LAST, p.getLast());
等待运行 plainAsserts。

assertAll · 全部检查

JUnit 5groupedAsserts · 源码节选
assertAll("姓名",
    () -> assertEquals(EXPECTED_FIRST, p.getFirst()),
    () -> assertEquals(EXPECTED_LAST, p.getLast())
);
等待运行 groupedAsserts。
两个失败检查仍属于 一个测试方法:报告会显示 Failures: 1,同时单独列出 Failed checks: 2。
JUnit 4 也能汇总:ErrorCollector Rule(4.7 起)

先声明 @Rule ErrorCollector,再使用 checkThat。两项都错时,同样收集两个失败。

JUnit 4PersonErrorCollector4Test.java · 源码节选
    @Rule
    public ErrorCollector collector = new ErrorCollector();
    @Test
    public void person() {
        Person p = new Person("张", "三");
        collector.checkThat(p.getFirst(), equalTo(EXPECTED_FIRST));
        collector.checkThat(p.getLast(), equalTo(EXPECTED_LAST));
    }
}
讲稿第 13 页 · 教师提示
  • 先问:连续两个普通断言,第一个失败后第二个还会执行吗?不会,失败抛出错误,方法随即中断。
  • 先用默认“张 / 三”运行通过,再把两项改成“李 / 四”,分别运行普通断言和 assertAll,看一个失败检查与两个失败检查。
  • assertAll 执行独立检查,最后统一报告 MultipleFailuresError;失败检查虽有 2 个,失败的测试方法仍是 1 个。
  • JUnit 4 从 4.7 起可用 ErrorCollector Rule 汇总错误。演示后点重置,恢复正确期望值。
04 断言与异常

超时与假设:两个容易踩的细节

迁移数字要换算;前提不满足,也不代表测试失败。

01 · 超时单位换算

可编辑
毫秒 ms秒 s(默认)
输入毫秒,点击换算。1000 毫秒 = 1 秒。
@Timeout(1000) 默认是 1000 秒。若毫秒值不能整除 1000,用显式毫秒单位保留精度。

02 · 前提条件不成立

浏览器模拟
assumeTrue 不成立:整项测试 aborted / 跳过。
条件只控制 Lambda;后面的代码照常执行。
查看真实 TimeoutAssumptionTest 与两种假设写法
JUnit 5TimeoutAssumptionTest.java · 源码节选
    @Test
    @Timeout(1)   // 1 秒
    void finishesWithinOneSecond() throws InterruptedException {
        Thread.sleep(100);
    }
    @Test
    @Timeout(value = 1000, unit = TimeUnit.MILLISECONDS)   // 想写毫秒就显式指定单位
    void finishesWithinOneThousandMillis() throws InterruptedException {
        Thread.sleep(100);
    }
    @Test
    void onlyOnCi() {
        assumeTrue("CI".equals(System.getenv("ENV")));
        assertTrue(true);
    }
    @Test
    void partly() {
        assumingThat(isWindows(), () -> {
            System.out.println("只在 Windows 上执行这一段");
        });
        System.out.println("无论条件是否成立,这里都会继续执行");
    }
    private static boolean isWindows() {
        return System.getProperty("os.name").startsWith("Windows");
    }
}
JUnit 4 有 Assume.assumeTrue(),没有 assumingThat()。跳过一个代码块,不等于跳过整个测试。
讲稿第 14 页 · 教师提示
  • 先强调单位:JUnit 4 的 1000 是毫秒,JUnit 5 @Timeout 默认是秒,直接搬数字会扩大 1000 倍。
  • 正确写 @Timeout(1),或显式 TimeUnit.MILLISECONDS;不能整除 1000 的值用显式毫秒单位保留精度。
  • 本机 ENV 不是 CI:onlyOnCi 会 aborted / 跳过,不是失败。assumingThat 只跳过一段 Lambda,后面的代码继续。
  • JUnit 4 有 Assume.assumeTrue,但没有 assumingThat。
04 断言与异常

JUnit 4 的传统异常测试

expected 覆盖整方法;Rule 要先声明预期。

JUnit 4expected · 源码节选
@Test(expected = ArithmeticException.class)
public void divideWithExpected() {
    calc.divide(1, 0);
}

覆盖整个方法

任何一行抛出指定异常都满足要求;无法精确锁定一行,也拿不到异常对象。

JUnit 4ExpectedException Rule · 源码节选
@SuppressWarnings("deprecation")
@Rule
public ExpectedException thrown = ExpectedException.none();
@Test
public void divideWithRule() {
    thrown.expect(ArithmeticException.class);
    thrown.expectMessage("/ by zero");
    calc.divide(1, 0);
}

先声明预期,再抛错

能查类型、消息和原因;要额外声明 Rule,expect 必须放在抛错代码之前。

ExpectedException.none() 自 JUnit 4.13 起弃用,推荐 assertThrows()。下一页看更精确的写法 →

真实 Exception4Test 的两个测试都应通过;除以 0 的消息是 "/ by zero"。

讲稿第 15 页 · 教师提示
  • expected 属性覆盖整个方法,任何一行抛出指定异常都能满足要求;拿不到异常对象去检查消息。
  • ExpectedException Rule 可检查类型、消息、原因;expect 必须写在抛错代码之前。
  • 演示项目中两个传统测试都通过。ExpectedException.none() 自 4.13 起弃用,官方推荐 assertThrows,引出下一页。
04 断言与异常 现场演示

异常类型:允许子类,还是完全一致?

先猜两个父类断言,再运行真实项目所对应的四个测试。

先知道实际异常Integer.parseInt("abc")
IllegalArgumentExceptionNumberFormatException
5.8 起提供 assertThrowsExactly
JUnit 5A · assertThrows
assertThrows(IllegalArgumentException.class,
    () -> Integer.parseInt("abc"));
A:期望父类,会通过还是失败?
JUnit 5B · assertThrowsExactly
assertThrowsExactly(IllegalArgumentException.class,
    () -> Integer.parseInt("abc"));
B:期望父类,会通过还是失败?
先为两个断言各选一个答案,再运行揭晓。
准备运行 · 整个类有 4 个测试。
先纠错:JUnit 4.13 已有 assertThrows,查看两版真实代码

assertThrows 只检查 Lambda,并返回异常对象继续检查;核心用法相同,主要差异在 import。

JUnit 4AssertThrows4Test.java · 源码节选
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;

NumberFormatException e = assertThrows(
    NumberFormatException.class,
    () -> Integer.parseInt("abc"));

assertEquals("For input string: \"abc\"", e.getMessage());
JUnit 5AssertThrows5Test.java · 源码节选
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

NumberFormatException e = assertThrows(
    NumberFormatException.class,
    () -> Integer.parseInt("abc"));

assertEquals("For input string: \"abc\"", e.getMessage());
本页有 1 项故意失败。@Tag("fail-demo") 在 mvn test 中被排除;IDEA 单跑整个类可看到它的红色报告。
讲稿第 16 页 · 教师提示
  • 先纠错:JUnit 4.13 就有 assertThrows,核心用法几乎相同,只差 import。它只检查 Lambda 并返回异常对象。
  • 让学生分别预测父类版本的两个断言。parseInt("abc") 抛出 NumberFormatException,是 IllegalArgumentException 子类。
  • 运行 AssertThrows5Test 整个类:3 个通过、1 个故意失败。assertThrows 允许子类,assertThrowsExactly 要求完全一致。
  • assertThrowsExactly 从 5.8 起提供。exactlyParentType_fails 带 fail-demo 标签,mvn test 排除它,IDEA 单跑仍红。
05 JUnit 5 新特性 现场演示

测试报告,也可以像目录一样

@DisplayName 决定名字,@Nested 决定层次。

JUnit 5CalculatorNestedTest.java · 源码节选
@DisplayName("计算器测试")
class CalculatorNestedTest {
    Calculator calc;
    @BeforeEach
    void init() {
        calc = new Calculator();   // 外部类的 @BeforeEach 对嵌套类里的测试同样生效
    }
    @Nested
    @DisplayName("加法")
    class Add {
        @Test
        @DisplayName("1 + 2 = 3")
        void simple() {
            assertEquals(3, calc.add(1, 2));   // 非静态内部类,可以直接用外部类的字段
        }
    }
    @Nested
    @DisplayName("除法")
    class Divide {
        @Test
        @DisplayName("除以 0 抛异常")
        void byZero() {
            assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
        }
    }
}

测试结果树

浏览器模拟

运行后展开测试树。
节点名称来自 @DisplayName。

等待运行 · Tests run: 0

非静态内部类直接使用外层 calc。

外层 @BeforeEach 对嵌套测试生效。

JUnit 4 可用 @RunWith(Enclosed.class) 组织静态内部类,但占用唯一 Runner;JUnit 5 原生支持 @Nested + @DisplayName。
讲稿第 17 页 · 教师提示
  • 名字来自 @DisplayName,层次来自 @Nested。运行后展开“计算器测试 → 加法 / 除法 → 具体测试”。
  • 非静态内部类可以直接访问外层 calc;外层 @BeforeEach 对嵌套测试也生效。
  • JUnit 4 也能用 Enclosed Runner 组织静态内部类,但会占用唯一 Runner,且没有原生 DisplayName。
05 JUnit 5 新特性

JUnit 4 完全支持参数化

三组数据都能跑,成本在类级 Runner、数据方法和构造函数。

JUnit 417 行 · 真实源码仅重排空白
@RunWith(Parameterized.class)
public class AddParameterized4Test {
    @Parameters(name = "{0} + {1} = {2}")
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            {1, 1, 2}, {2, 3, 5}, {-1, 1, 0}
        });
    }
    private final int a, b, expected;

    public AddParameterized4Test(int a, int b, int expected) {
        this.a = a; this.b = b; this.expected = expected;
    }
    @Test public void add() {
        assertEquals(expected, new Calculator().add(a, b));
    }
}
3 组数据,3 条结果

JUnit 4 完全支持参数化,代价在写法。

01

类级别 Runner

@RunWith(Parameterized.class) 占用唯一 Runner。

02

静态数据方法

@Parameters 返回每一组数据。

03

字段 + 构造函数

通过构造函数把 a、b、expected 传进实例。

04

整类绑定同一套数据

类里的每个测试方法使用同一套参数。

教学排版:17 行,不计 import。真实测试调用 new Calculator().add(a, b)。看看 JUnit 5 的 5 行写法 →
讲稿第 18 页 · 教师提示
  • 先明确:JUnit 4 完全支持参数化。三组数据各创建实例、各跑一遍。
  • 成本来自类级 Parameterized Runner、静态数据方法、字段与构造函数,以及全类共用一套数据。
  • 17 行是讲稿的教学排版口径,不计 import;这里重排空白展示真实项目代码,Calculator 调用保持实例方法。
05 JUnit 5 新特性 现场演示

JUnit 5 参数化:17 行 → 5 行

更关键的变化:不同方法可以使用各自的数据。

175

行代码 · 不计 import
从类级数据,到方法级数据

JUnit 4AddParameterized4Test · 17 行
@RunWith(Parameterized.class)
public class AddParameterized4Test {
    @Parameters(name = "{0} + {1} = {2}")
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            {1, 1, 2}, {2, 3, 5}, {-1, 1, 0}
        });
    }
    private final int a, b, expected;

    public AddParameterized4Test(int a, int b, int expected) {
        this.a = a; this.b = b; this.expected = expected;
    }
    @Test public void add() {
        assertEquals(expected, new Calculator().add(a, b));
    }
}
JUnit 5add · 5 行
@ParameterizedTest(name = "{0} + {1} = {2}")
@CsvSource({"1, 1, 2", "2, 3, 5", "-1, 1, 0"})
void add(int a, int b, int expected) {
    assertEquals(expected, new Calculator().add(a, b));
}

@CsvSource · 逐组运行 add

#abexpectedactual结果
现场加一组期望 = 10
3 组源文件数据,等待运行。
@ValueSource 单参数@CsvSource 多参数@CsvFileSource CSV 文件@MethodSource 方法数据@EnumSource 枚举
同一类,不同方法各用各的数据:真实文件还包含平方测试

squareIsNonNegative 使用 @ValueSource(ints = {-3, 0, 4}),与 add 的 CsvSource 独立。IDEA 运行 AddParameterized5Test 整类会得到 6 条结果;本互动只演示 add。输入按 Java int 处理,溢出时期望值也按 32 位整数计算。

讲稿第 19 页 · 教师提示
  • JUnit 5 把参数化放到方法:@ParameterizedTest + @CsvSource + 参数列表,教学示例缩成 5 行。
  • 逐条运行三组 add 数据,再让学生提供 a、b,追加一组并自动计算期望。不要把 Calculator 写成静态调用。
  • 同类不同方法各用各的数据;原文件还有 @ValueSource 的三组平方检查,整类运行共 6 条。
  • 单参数 ValueSource,多参数 CsvSource,文件 CsvFileSource,复杂对象 MethodSource,枚举 EnumSource。
05 JUnit 5 新特性

重复、动态、标签与禁用

四种组织能力,点一下看看测试报告有什么不同。

@RepeatedTest(5)

依次重复 5 次,不会自动并发。

JUnit 5repeat · 真实源码节选
@RepeatedTest(5)
    void randomId() {
        assertNotNull(UUID.randomUUID().toString());
    }
等待运行。

@TestFactory

运行时生成平方 1、2、3 三个测试。

JUnit 5factory · 真实源码节选
@TestFactory
    Stream<DynamicTest> squares() {
        return Stream.of(1, 2, 3)
            .map(n -> dynamicTest("平方 " + n,
                () -> assertEquals(n * n, calc.square(n))));
    }
等待运行。

@Tag("fast")

分类筛选:mvn test -Dgroups=fast。

JUnit 5fast · 真实源码节选
@Test
    @Tag("fast")
    void quick() {
        assertEquals(4, calc.add(2, 2));
    }
等待运行。

@Disabled

写明禁用原因,不执行测试主体。

JUnit 5disabled · 真实源码节选
@Test
    @Disabled("等待修复 #12")
    void broken() {
        assertEquals(5, calc.add(2, 2));
    }
等待运行。
讲稿第 20 页 · 教师提示
  • RepeatedTest(5) 是依次重复,不会自动成为并发;观察报告按 1 到 5 依次出现。
  • TestFactory 在运行时生成测试,平方例子对 1、2、3 生成 3 个动态节点。
  • Tag("fast") 可用 mvn test -Dgroups=fast 筛选;对应 JUnit 4 Category。
  • Disabled 应写清原因。本例等待修复 #12,所以跳过,不执行会失败的断言。
06 扩展、迁移与 JUnit 6

扩展模型:从 Runner + Rule 到 Extension

Runner 只能一个,Rule 可以多个;Extension 可以叠加。

JUnit 4讲稿中的扩展示意
// JUnit 4:一个 Runner,可有多个 Rule
@RunWith(SpringRunner.class)
public class UserServiceTest {
    @Rule
    public TemporaryFolder tmp = new TemporaryFolder();
}
JUnit 5讲稿中的扩展示意
// JUnit 5:扩展可以叠加
@ExtendWith(SpringExtension.class)
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @TempDir
    Path tmp;
}
JUnit 41 个 Runner + 多个 Rule
JUnit 5一个 Extension 模型,可叠加
@TempDir 可替代 TemporaryFolder 的常见用途。自定义 Runner / Rule 需按行为重写,不是逐个改名。

Spring / Mockito 片段来自 PPT 讲解示意,不属于演示项目;实际使用时需要对应依赖与 import。

讲稿第 21 页 · 教师提示
  • JUnit 4 有 Runner 与 Rule 两套机制,Runner 只能一个,Rule 可以多个。
  • JUnit 5 用 @ExtendWith 注册 Extension,可以叠加 SpringExtension、MockitoExtension。@TempDir 是临时目录的现成替代。
  • 不能把 Rule 与 Extension 看作一一对应。自定义 Runner / Rule 要按它实际的行为重写,迁移工具也需复查。
06 扩展、迁移与 JUnit 6

老项目,分六步渐进迁移

让测试先共存,再逐类迁移,最后移除兼容引擎。

01

引入 Jupiter + Vintage

先让新旧测试在 Platform 上共存。

02

新测试全部用 Jupiter

从现在起,新增测试用 JUnit 5 写法。

03

逐类替换 import

org.junit → org.junit.jupiter.api。

04

改注解,核对超时单位

Before → BeforeEach;毫秒要换算为秒。

05

改断言与异常测试

提示挪到最后;expected / ExpectedException 改 assertThrows。

06

重写扩展,移除 Vintage

Runner / Rule 按行为改成 Extension;全迁完才移除兼容引擎。

IDEA / OpenRewrite 可以辅助。每轮迁移后都审查改动、重跑全部测试,并核对 Tests run 数量。
讲稿第 22 页 · 教师提示
  • 先引入 Jupiter + Vintage 让新旧共存;随后新测试用 Jupiter,逐类迁移 import。
  • 再改生命周期与禁用注解,核对 timeout 单位;改断言提示顺序,expected / ExpectedException 改 assertThrows。
  • 最后重写 Runner / Rule 为 Extension,全迁完才移除 Vintage。
  • IDEA / OpenRewrite 可辅助,每轮都要审查差异、重新运行全部测试,并核对测试数量有没有减少。
06 扩展、迁移与 JUnit 6

构建成功,也可能漏跑测试

每次迁移,除了结果,还要核对 Tests run 数量。

!

import 混用,测试没被发现

导入了 org.junit.Test,但项目只有 Jupiter、没有 Vintage:测试可能漏跑,构建依然成功。检查 Tests run 数量。

!

Surefire 太旧

< 2.22.0 不原生支持 Platform,可能漏跑或显示 Tests run: 0。建议 3.x。

!

提示信息没有移位

三字符串断言仍能编译,但消息被当成 expected。迁移 import 后也要复查参数顺序。

!

@BeforeAll 忘了 static

默认必须静态;或显式使用 @TestInstance(PER_CLASS) 生命周期。

BUILD SUCCESS测试全部被执行
讲稿第 23 页 · 教师提示
  • 最隐蔽的是混用 import:只有 Jupiter,没有 Vintage,却导入 org.junit.Test;旧测试不被发现,构建仍可能成功。
  • 不能只看 BUILD SUCCESS,要看 Tests run 数量,特别是 0 或比以前少。Surefire < 2.22.0 也可能漏跑。
  • 三字符串提示信息位置没改仍会编译;@BeforeAll 默认必须 static,或改用 @TestInstance(PER_CLASS)。
06 扩展、迁移与 JUnit 6

彩蛋:JUnit 6 已经来了

提高 Java 要求,统一模块版本,继续使用 Jupiter 写法。

版本快照 · 按 2026 年 11 月素材
6.0.0 发布2025-09-30
最新正式版6.1.3 · 2026-08-07
最低 JavaJava 17(JUnit 5 是 Java 8)
模块版本号Platform、Jupiter、Vintage 统一版本号
Vintage已弃用;仅在迁移期间临时使用
弃用 ≠ 删除
常用 Jupiter 写法延续。今天的知识可以继续用于 JUnit 6;升级项目需核对 Java 要求与已移除 API。

来源:JUnit 官方 Release Notes · docs.junit.org ↗。本课演示依赖仍固定 4.13.2 / 5.14.4。

讲稿第 24 页 · 教师提示
  • 按素材的版本快照:6.0.0 在 2025-09-30 发布,6.1.3 在 2026-08-07 发布;本课程比较仍固定在 4.13.2 / 5.14.4。
  • JUnit 6 最低 Java 17,Platform / Jupiter / Vintage 统一版本号,常见 Jupiter 写法延续。
  • Vintage 已弃用,定位为迁移期间临时使用;弃用不等于删除。升级仍应核对 Java 与已移除的 API。
07 总结与课堂问答

一张表,记住所有区别

区分局部调整与模型改变,避免记成“只改了名字”。

对比项JUnit 4JUnit 5
架构单个核心依赖 junit:junitPlatform + Jupiter + Vintage
Java 版本Java 5 及以上Java 8 及以上
生命周期注解@Before / @BeforeClass@BeforeEach / @BeforeAll
断言提示信息第一个参数最后一个参数,可用 Lambda
分组断言ErrorCollector Rule内置 assertAll
超时@Test(timeout = …),毫秒@Timeout,默认秒
异常测试expected / ExpectedException;
4.13 起有 assertThrows
assertThrows,另有 assertThrowsExactly
参数化测试Parameterized Runner(占用类的 Runner)@ParameterizedTest(作用在方法上)
嵌套测试Enclosed Runner原生 @Nested + @DisplayName
扩展机制Runner + Rule(只能一个 Runner)Extension(可叠加)
局部调整

注解改名 · 提示信息移位

模型改变

模块化架构 · 类级 → 方法级参数化 · Extension

再记三句:4.13 也有 assertThrows;JUnit 4 完全支持参数化;Vintage 新项目不必装。
讲稿第 25 页 · 教师提示
  • 回到第一行:模块化架构是其他变化的基础。十行总结不要只背注解名字。
  • 问学生:哪些只是改名?生命周期与消息位置是局部调整;参数化从类级到方法级、扩展模型统一是真正模型变化。
  • 再纠正三句话:4.13 已有 assertThrows;JUnit 4 完全支持参数化;Vintage 用于迁移,新项目不必装。
07 总结与课堂问答

四道题,检查一下理解

四个问题,回到最容易混淆的细节。

先选答案,再点击「揭晓」。也可以直接揭晓,计入已答题数。

得分 0 / 4已揭晓 0 / 4
Q1

JUnit 5 用什么注解替代 @Before?

第 1 题选项
Q2

assertEquals(3, add(1, 2), "错误") 是哪个版本?

第 2 题选项
Q3

@Test(timeout = 1000) 迁成 @Timeout(1000),对吗?

第 3 题选项
Q4

要求异常类型完全一致,不接受子类,用哪个断言?

第 4 题选项
Questions answered: 0, Correct: 0, Remaining: 4

题干中的 add(1, 2) 是概念简写;演示项目实际使用 Calculator 实例调用。

讲稿第 26 页 · 教师提示
  • 按题逐个让同学抢答,再选择答案并点击揭晓,不要一开始公开答案。
  • Q1 BeforeEach;Q2 提示在最后所以是 5;Q3 1000 毫秒对应 Timeout(1);Q4 完全一致用 assertThrowsExactly。
  • 计分按每题第一次揭晓时的选择计算,重复揭晓不会重复加分;重置后可重新进行一轮。
软件测试 · JUnit 专题 · 第三部分

谢谢大家,
欢迎提问。

01新项目直接使用 JUnit 5 / Jupiter。

02老项目借 Vintage 渐进迁移。

再做一轮小问答

参考资料

JUnit 5.14.4 User Guide · 固定版本 ↗JUnit 5 User Guide · 原 PPT 参考链接 ↗

本站内容与代码均来自随附素材;网页与互动可完全离线使用。参考链接需联网。

讲稿第 27 页 · 教师提示
  • 收束一句:新项目直接用 JUnit 5 写法,老项目借 Vintage 一步步迁移。
  • 邀请提问:具体项目怎样迁移、参数化怎样选数据源、异常断言怎样选。
  • 参考链接保留官方固定版本文档与原 PPT 中的 User Guide;离线讲解无需访问外网。
随附项目 · 只读原始素材

真实 Maven 演示项目

同一个项目配置 JUnit 4.13.2、Jupiter 5.14.4 与 Vintage;全部网页代码与该项目对应。

课前准备

  1. 用 IDEA 的 File → Open 打开 source/junit-demo,等待识别为 Maven 项目。
  2. 提前联网刷新 Maven,执行 mvn test 下载依赖;课堂上不需要临时改依赖。
  3. 确认 BUILD SUCCESS 且 Tests run 不是 0,并把下面各演示先运行一遍。

JDK 8 及以上(推荐 17 / 21);Maven 3.6.3 及以上,或 IDEA 自带 Maven。Surefire 已固定为 3.2.5。

演示对照表 · 与 README.md 一致

PPT 页打开的类怎么演示应该看到
10p10/Calc4Test 和 p10/Calc5Test两个分别运行都通过;新旧写法在同一项目共存
13p13/PersonAssertAllTest先运行;再把 EXPECTED_FIRST、EXPECTED_LAST 同时改错后运行普通断言只报 1 个失败;assertAll 报 2 个失败
13(补充)p13/PersonErrorCollector4Test同上JUnit 4 用 ErrorCollector 也能汇总失败
15p15/Exception4Test运行两种 JUnit 4 传统写法都通过
16p16/AssertThrows4Test、p16/AssertThrows5Test先让同学猜,再运行 AssertThrows5Test 整个类3 个通过、1 个失败(故意的):assertThrowsExactly 不接受子类
17p17/CalculatorNestedTest运行整个类,展开测试结果树计算器测试 → 加法 / 除法 → 具体测试
18–19p19/AddParameterized4Test、p19/AddParameterized5Test分别运行每组数据显示为一条结果,如 1 + 1 = 2
14(补充)p14/TimeoutAssumptionTest运行onlyOnCi 显示为跳过(aborted),不是失败
20(补充)p20/OrganizationTest运行重复 5 次、动态生成 3 个、1 个被禁用
故意失败项:AssertThrows5Test.exactlyParentType_fails 标有 fail-demo,Maven 默认排除;IDEA 单跑仍失败。第 13 页演示完恢复期望“张 / 三”。参数化代码使用 new Calculator().add(a, b)。

常用命令

先进入项目目录 source/junit-demo/,再执行:

JUnit 4JUnit 5Maven · 原 README 常用命令
mvn test
mvn test -Dtest=Calc5Test
mvn test -Dgroups=fast
真实文件 · 与 source/ 内容一致

源文件

打开原文件 ↗
JUnit 4JUnit 5

只读源码快照,完整保留原文件内容。互动输入不会修改 Java 项目。

复制代码

浏览器限制了自动复制。代码已选中,请按 Ctrl+C(Mac:⌘C)。