JUnit5注解详解及常用示例

# 1. JUnit5简介

## 1.1 JUnit5概述
JUnit5是最新版本的JUnit测试框架，它支持Java 8及以上版本，并且提供了许多新功能和改进，以帮助开发者编写更加优雅和灵活的测试代码。

## 1.2 JUnit5与JUnit4的区别
JUnit5相对于JUnit4来说有了许多改进，比如对Lambda表达式和方法引用的更好支持，新的扩展模型，改进的断言方式等等。

## 1.3 JUnit5核心理念
JUnit5的核心理念是灵活性和可扩展性，通过模块化的方式使得各个部分可以独立使用，同时也提供了丰富的API和注解，以满足各种测试需求。

# 2. JUnit5注解介绍

在JUnit5中，注解是非常重要的组成部分，可以帮助我们更好地控制测试用例的执行流程和结果。下面将介绍几个常用的JUnit5注解及其用法。

### 2.1 @Test注解

`@Test`注解用于标注测试方法，表示该方法是一个测试方法。在方法上添加该注解后，JUnit将会执行这个方法并输出测试结果。示例代码如下：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result, "2 + 3 应该等于 5");
    }
}

**代码说明：**
- 使用`@Test`注解标注`testAdd()`方法，表示这是一个测试方法。
- 在测试方法中执行计算器的加法操作，并使用断言方法`assertEquals`验证结果是否正确。

### 2.2 @BeforeEach和@AfterEach注解

`@BeforeEach`和`@AfterEach`注解分别表示在每个测试方法执行前后运行的方法。可以用来初始化测试环境或清理资源。示例代码如下：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @AfterEach
    void tearDown() {
        // 清理资源的操作，比如关闭文件流、数据库连接等
    }

    @Test
    void testAdd() {
        int result = calculator.add(2, 3);
        assertEquals(5, result, "2 + 3 应该等于 5");
    }
}

**代码说明：**
- 使用`@BeforeEach`注解标注`setUp()`方法，在测试方法执行前初始化`calculator`对象。
- 使用`@AfterEach`注解标注`tearDown()`方法，在测试方法执行后清理资源。

### 2.3 @BeforeAll和@AfterAll注解

`@BeforeAll`和`@AfterAll`注解分别表示在所有测试方法执行前和执行后运行一次的方法。通常用于一些全局准备和清理工作。示例代码如下：

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @BeforeAll
    static void setUpAll() {
        System.out.println("全局初始化工作");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("全局清理工作");
    }

    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result, "2 + 3 应该等于 5");
    }
}

**代码说明：**
- 使用`@BeforeAll`注解标注`setUpAll()`方法，在所有测试方法执行前进行全局初始化工作。
- 使用`@AfterAll`注解标注`tearDownAll()`方法，在所有测试方法执行后进行全局清理工作。

# 3. 常用断言方法

### 3.1 断言介绍
在编写测试用例时，经常需要验证代码的预期行为与实际行为是否一致。JUnit5提供了丰富的断言方法来帮助我们进行测试，通过断言方法可以验证代码在不同条件下的输出是否符合预期。常用的断言方法包括`assertEquals`、`assertTrue`、`assertNotNull`等，下面我们将介绍这些常用的断言方法的使用示例。

### 3.2 常用断言方法详解
#### 3.2.1 assertEquals断言
`assertEquals`断言用于验证预期值与实际值是否相等，它的语法格式为：

assertEquals(expected, actual);

其中`expected`为预期值，`actual`为实际值。如果预期值与实际值相等，则断言通过，否则断言失败。

@Test
void testAddition() {
    Calculator calculator = new Calculator();
    int result = calculator.add(3, 5);
    assertEquals(8, result, "3 + 5 should equal 8");
}

在上面的示例中，我们使用`assertEquals`断言来验证计算器的加法功能是否正确。

#### 3.2.2 assertTrue和assertFalse断言
`assertTrue`断言用于验证给定的条件是否为`true`，`assertFalse`断言用于验证给定的条件是否为`false`。它们的语法格式分别为：

assertTrue(boolean condition);
assertFalse(boolean condition);

@Test
void testAgeCheck() {
    Person person = new Person("John", 25);
    assertTrue(person.isAdult(), "John should be an adult");
    assertFalse(person.isStudent(), "John should not be a student");
}

上面的示例中，我们使用`assertTrue`和`assertFalse`断言来验证人员对象的年龄和学生状态是否符合预期。

#### 3.2.3 assertNotNull和assertNull断言
`assertNotNull`断言用于验证给定的对象不为`null`，`assertNull`断言用于验证给定的对象为`null`。它们的语法格式分别为：

assertNotNull(Object obj);
assertNull(Object obj);

@Test
void testCreatePerson() {
    Person person = new Person("Alice", 30);
    assertNotNull(person, "Person object should not be null");
    Person nullPerson = null;
    assertNull(nullPerson, "Null person object should be null");
}

在上面的示例中，我们使用`assertNotNull`和`assertNull`断言来验证创建的人员对象是否符合预期。

### 3.3 自定义断言方法
除了使用JUnit提供的常用断言方法外，我们还可以自定义断言方法来满足特定的测试需求。自定义断言方法可以通过`assertXXX`的命名规范来命名，例如`assertNameEquals`、`assertListNotEmpty`等。下面是一个简单的自定义断言方法示例：

public class CustomAssertions {
    public static void assertEvenNumber(int number) {
        assertTrue(number % 2 == 0, number + " should be an even number");
    }
}

在测试用例中可以使用自定义断言方法来验证特定的条件：

@Test
void testEvenNumberCheck() {
    CustomAssertions.assertEvenNumber(4); // Passes
    CustomAssertions.assertEvenNumber(3); // Fails
}

通过自定义断言方法，我们可以提高测试代码的可重用性和可读性。

在本章节中，我们详细介绍了JUnit5中常用的断言方法，包括`assertEquals`、`assertTrue`、`assertFalse`、`assertNotNull`、`assertNull`以及自定义断言方法的使用。这些断言方法帮助我们验证代码的行为是否符合预期，是编写高质量测试用例的关键工具。

# 4. 参数化测试

参数化测试是JUnit5中非常有用的功能之一，通过参数化测试可以简化重复的测试代码，提高测试的覆盖范围。接下来我们将介绍参数化测试的相关内容。

#### 4.1 参数化测试简介

参数化测试允许我们使用不同的参数多次运行相同的测试方法，这样我们可以轻松地测试多组输入数据以确保方法的正确性。

#### 4.2 @ParameterizedTest注解

在JUnit5中，我们使用 @ParameterizedTest 注解来标记参数化测试方法。通过该注解，我们可以指定参数源以及提供参数解析器来解析参数。

@ParameterizedTest
@ValueSource(ints = {1, 2, 3})
void testWithParameter(int number) {
    assertTrue(number > 0 && number < 4);
}

上面的示例中，@ValueSource 注解表示参数源为一个整数数组，参数化测试方法 testWithParameter() 会依次使用数组中的每个整数作为参数来运行测试。

#### 4.3 参数源注解介绍

JUnit5提供了多个参数源注解，常用的包括：

- @ValueSource：提供一个单一的参数源
- @EnumSource：提供一个枚举类型的参数源
- @CsvSource：提供一个CSV格式的参数源
- @MethodSource：提供一个方法作为参数源

#### 4.4 参数化测试示例

让我们通过一个简单的示例来演示参数化测试的用法：

@DisplayName("参数化测试示例")
@ParameterizedTest
@CsvSource({
        "1, 10, 11",
        "2, 20, 22",
        "3, 30, 33"
})
void testAdd(int a, int b, int result) {
    Calculator calculator = new Calculator();
    assertEquals(result, calculator.add(a, b));
}

在上面的示例中，我们使用 @CsvSource 注解提供了三组参数，分别为两个加数和预期的和，然后测试方法 testAdd() 里面使用这些参数运行了加法测试。

通过参数化测试，我们可以方便地验证方法对不同输入的处理是否正确，提升了测试的有效性和覆盖范围。

# 5. 测试顺序控制

在本章节中，我们将学习如何使用JUnit5来控制测试方法的执行顺序，并介绍如何利用元数据接口 TestInfo 和 @TestMethodOrder 注解来实现测试顺序控制。

#### 5.1 测试方法执行顺序

在单元测试中，有时我们希望对测试方法的执行顺序进行精确控制，以确保测试顺利进行，这在某些特定场景下非常重要。

#### 5.2 元数据接口 TestInfo

JUnit5中的 TestInfo 接口提供了当前测试的上下文信息，包括测试方法的名称、测试类的名称、测试标签等。通过 TestInfo 接口，我们可以在测试方法中获取到当前测试的相关信息。

以下是一个简单的示例：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

public class TestInfoExample {

    @Test
    void printTestInfo(TestInfo testInfo) {
        System.out.println("当前测试方法名称：" + testInfo.getDisplayName());
        System.out.println("当前测试类名称：" + testInfo.getTestClass().get().getName());
    }
}

在上面的示例中，我们通过 TestInfo 参数获取当前测试的方法名称和测试类名称，并将其输出到控制台。

#### 5.3 @TestMethodOrder注解

JUnit5中的 @TestMethodOrder 注解允许我们自定义测试方法的执行顺序。该注解提供了三种测试方法执行顺序的实现类：MethodOrderer.Default、MethodOrderer.Random 和 MethodOrderer.Alphanumeric。其中，MethodOrderer.Default 是默认的执行顺序。

以下是一个使用 @TestMethodOrder 注解的示例：

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TestMethodOrderExample {

    @Test
    @Order(2)
    void testMethodA() {
        // 测试方法 A 的实现
    }

    @Test
    @Order(1)
    void testMethodB() {
        // 测试方法 B 的实现
    }
}

在上面的示例中，我们使用 @TestMethodOrder 注解以及 @Order 注解来指定测试方法的执行顺序。

#### 5.4 测试顺序控制示例

下面通过一个完整的示例来演示如何使用 TestInfo 接口和 @TestMethodOrder 注解来进行测试顺序控制：

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TestOrderExample {

    @Test
    @Order(2)
    void testMethodA(TestInfo testInfo) {
        System.out.println("当前测试方法：" + testInfo.getDisplayName());
        // 测试方法 A 的实现
    }

    @Test
    @Order(1)
    void testMethodB() {
        // 测试方法 B 的实现
    }

    @BeforeAll
    static void beforeAll() {
        System.out.println("在所有测试方法执行之前执行");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("在所有测试方法执行之后执行");
    }
}

在上面的示例中，我们使用 @TestMethodOrder 注解和 @Order 注解来控制测试方法的执行顺序，并在测试方法中使用 TestInfo 接口来获取测试上下文信息。

通过本示例，我们可以看到测试方法 A 和测试方法 B 的执行顺序与 @Order 注解中指定的顺序一致。同时，在测试方法中利用 TestInfo 接口输出了当前测试方法的信息。

通过以上示例，我们对于测试顺序控制已有了一个清晰的认识。

希望本章内容能够帮助你更好地掌握JUnit5中的测试顺序控制方法。

# 6. 扩展模型

JUnit5提供了扩展模型（Extension Model）来允许开发人员自定义测试引擎的行为。通过扩展模型，可以在测试执行过程中添加额外的逻辑，如日志记录、性能监控、事务管理等。在本章中，我们将深入介绍JUnit5的扩展模型，包括扩展模型的概述、扩展模型接口介绍、自定义扩展示例以及如何使用第三方扩展。

#### 6.1 扩展模型概述

JUnit5的扩展模型是基于Java的SPI（Service Provider Interface）机制实现的，允许开发人员根据需要注册和使用扩展。通过扩展模型，可以对测试生命周期中的不同阶段进行干预和扩展，以实现自定义的测试逻辑。

#### 6.2 扩展模型接口介绍

JUnit5中定义了多个扩展模型接口，包括 `BeforeAllCallback`、`AfterAllCallback`、`BeforeEachCallback`、`AfterEachCallback` 等。这些接口分别对应测试生命周期中不同阶段的回调函数，开发人员可以实现这些接口来编写自定义的扩展逻辑。

import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.ExtensionContext;

public class MyBeforeAllCallback implements BeforeAllCallback {
    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        // 在所有测试之前执行的逻辑
        System.out.println("Before all tests");
    }
}

上面的代码展示了一个实现 `BeforeAllCallback` 接口的自定义扩展类 `MyBeforeAllCallback`，通过实现 `beforeAll` 方法来定义在所有测试之前执行的逻辑。

#### 6.3 自定义扩展示例

下面是一个示例，演示如何自定义一个简单的扩展来统计测试执行时间：

import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.InvocationInterceptor;
import org.junit.jupiter.api.extension.RegisterExtension;

public class TimingExtension implements InvocationInterceptor {
    @Override
    public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
        long start = System.currentTimeMillis();
        invocation.proceed();
        long end = System.currentTimeMillis();
        System.out.println("Test method " + invocationContext.getTestMethod().getName() + " took " + (end - start) + "ms");
    }
}

class ExampleTestClass {
    @RegisterExtension
    static TimingExtension extension = new TimingExtension();

    // 测试方法
}

在上面的示例中，自定义的 `TimingExtension` 实现了 `InvocationInterceptor` 接口，通过 `interceptTestMethod` 方法对测试方法的执行时间进行统计，然后在测试执行完成后输出执行时间。

#### 6.4 使用第三方扩展

除了自定义扩展外，JUnit5还支持使用第三方扩展来扩展测试框架的功能。比如，JUnit Pioneer 提供了一些常用的扩展，如 `JUnit Pioneer’s ParameterizedTestExtension` 用于参数化测试，`JUnit Pioneer’s RepetitionInfoParameterResolver` 用于重复测试等。开发人员可以根据需要引入不同的扩展来增强测试框架的功能。

通过本章的学习，读者可以深入了解JUnit5的扩展模型，并学会如何自定义和使用扩展来实现更灵活和强大的测试逻辑。