JUnit单元测试常用方法知识整理-CSDN博客

我们在写程序的时候，往往最难的部分不是代码的编写，而是之后的debug阶段，我们都经历过花大量时间去检查代码，最后发现只是简单的错误导致了bug。而在实际应用中，对于我们所开发的程序来讲，仅仅让它跑起来是远远不够的，程序在运行过程中可能会遇到各种问题，用户在使用我们所开发的程序时也会有千奇百怪的输入等等。所以我们需要通过测试发现程序中可能存在的错误，确认我们的程序是否达到了可用级别。

二、什么是单元测试

对于一个体量很大的程序来讲，其代码量是远超过我们平时所编写的程序的，在实际开发中，我们不可能把整个程序编写好之后再去检查程序的正确性，其难度和工作量远超过我们想象。所以，我们可以考虑把程序分成小的模块。对于每个模块，当它在我们设计的测试用例下均能正确运行，实现预期的功能后，我们便可以聚焦于由着些模块构成成的更大的代码段的正确性。

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类。

三、IDEA下创建JUnit

1.JUnit5是什么？

JUnit 是一个 Java 编程语言的单元测试框架。它是由 Kent Beck （极限编

程）和 Erich Gamma（设计模式）建立，是 xUnit 家族中最成功的的一个。大部

分的 Java IDE 都集成了 JUnit 作为单元测试工具。JUnit 在测试驱动的开发方

面有很重要的发展。

JUnit 5 = JUnit Platform（基础平台） + JUnit Jupiter（ 核心程序） + JUnit Vintage（老版本的支持）

2.自动创建JUnit

首先我们创建一个Calculator类，为其编写下一个add方法。

public class Calculator {
    public int add(int x, int y) {
        return x + y;
    }
}

创建一个test文件夹，用于存放测试函数，这样做的目的是让测试文件和src文件有相同的目录结构，便于管理。
打开 Calculator .java 文件，在类的内部同时按下快捷键 ctrl + shift + T，选择 Create New Test（或右键选择 Generate -> Test）。如果之前并未安装JUnit5 Library，在界面中点击 Fix 按钮，IDEA 会帮助你下载好 JUnit5。在弹出框中我们可以选择JUnit的版本，以及要测试的方法。
查看test目录下自动生成的测试类

四、JUnit用法

1.基础测试方法

首先观察自动生成的测试文件，我们发现代码包含一个@Test注解和一个void修饰的add()方法。在add()方法中我们可以编写自己的测试代码。点击左侧的运行按钮，我们发现可以单独运行每一个方法或者整个测试类。点击按钮后将显示运行的结果。

下面，我们对要测试的类做一些规范：

测试的类不能是抽象类，且必须只含有一个构造器。
测试方法不能是抽象方法，而且一般情况下不能有返回值。
测试类和方法不是必须被public修饰，但不能被private修饰。通常建议测试类和方法省略public修饰符除非有一些特殊的要求。

一个标准的测试类如下图所示

import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;

class StandardTests {

    @BeforeAll
    static void initAll() {
    }

    @BeforeEach
    void init() {
    }

    @Test
    void succeedingTest() {
    }

    @Test
    void failingTest() {
        fail("a failing test");
    }

    @Test
    @Disabled("for demonstration purposes")
    void skippedTest() {
        // not executed
    }

    @Test
    void abortedTest() {
        assumeTrue("abc".contains("Z"));
        fail("test should have been aborted");
    }

    @AfterEach
    void tearDown() {
    }

    @AfterAll
    static void tearDownAll() {
    }

}

2.注解

@Test	表示方法是测试方法。
@ParameterizedTest	表示方法是参数化测试。
@RepeatedTest	表示方法是重复测试
@DisplayName	声明测试类或测试方法的自定义显示名称。
@BeforeEach	表示被注解的方法应在当前类的每个@Test，@RepeatedTest，@ParameterizedTest方法之前执行; 类似于JUnit 4的@Before。
@AfterEach	表示被注解的方法应在当前类的每个@Test，@RepeatedTest，@ParameterizedTest方法之后执行; 类似于JUnit 4的@After。
@BeforeAll	表示被注解的方法应该在当前类的所有@Test，@RepeatedTest，@ParameterizedTest和方法之前执行; 类似于JUnit 4的@BeforeClass。
@AfterAll	表示被注解的方法应该在当前类的所有@Test，@RepeatedTest，@ParameterizedTest和方法之后执行; 类似于JUnit 4的@AfterClass。
@Nested	表示被注解的类是一个嵌套的非静态测试类。
@Tag	在类或方法级别声明标签，用于过滤测试。
@Disabled	用于禁用测试类或测试方法; 类似于JUnit4的@Ignore。

3.使用断言

首先我们按常规思路，编写测试add的代码。当我们运行add方法，可以看到其通过了测试，并将结果展示在右边

但如果add方法错误，比如它返回的是x-y的值，这种情况下，我们运行测试方法发现其仍然通过了测试。虽然我们能通过右侧结果的展示观察到add方法错误，但对于大量测试来说，我们关注的重点应该是左侧控制台是否显示方法通过了测试。于是我们引入断言。下面列出Assertions类中的常用方法，更多方法可自行查阅API。

assertEquals	判断两个对象或者原始类型是否相等
assertNotEquals	判断两个对象或者原始类型是否不相等
assertSame	判断两个对象引用是否指向同一对象
assertNotSame	判断两个对象引用是否指向不同对象
assertNull	判断给定对象引用是否为null
assertNotNull	判断给定对象引用是否不为null

对于add方法我们采用assertEqulas判断，结果如下

可以看到我们给定预期值为11，而add方法返回的却是-1，因此我们去检查add方法，修改错误。

这里有一个问题，当我们加入了更多测试用例时，如果其中一个发生了错误，后面的测试代码将不再执行

这里我们可以使用Assertions类中的assertAll方法

@Test
    void add() {
        Calculator calculator = new Calculator();
        assertAll(  ()->assertEquals(11,calculator.add(5,6)),
                    () -> assertEquals(10, calculator.add(4, 6)),
                    () -> assertEquals(15, calculator.add(5, 10)));

    }

我们可以看到，用例中的所有错误都显示在了控制台。

4.假设

假设是 org.junit.jupiter.api.Assumptions 类中的静态方法。他们仅在满足指定条件时执行测试，否则测试将中止。当假设失败时，将抛出 org.opentest4j.TestAbortedException 并跳过测试。不会导致测试失败。

assumeTrue	验证给定的假设为true，若为falsee，将终止测试
assumeFalse	验证给定的假设为false，若为true，将终止测试
assumingThat	执行提供的可执行`Executable`，但仅在提供的假设有效时执行。如果假设无效，`Executable`将不执行

assumeTrue例子
assumingThat例子

5.显示名称

当我们编写了大量测试方法时，运行测试类，控制台将包含大量测试结果，对于某个的测试方法的含义我们可能不太清晰。测试类和测试方法可以通过以下方式声明自定义显示名称（带有空格、特殊字符甚至表情符号），这些名称将显示在控制台中。

@DisplayName("A special test case")
class DisplayNameDemo {

    @Test
    @DisplayName("Custom test name containing spaces")
    void testWithDisplayNameContainingSpaces() {
    }

    @Test
    @DisplayName("╯°□°）╯")
    void testWithDisplayNameContainingSpecialCharacters() {
    }

    @Test
    @DisplayName("😱")
    void testWithDisplayNameContainingEmoji() {
    }

}

6.禁用

有些情况下我们不希望自己编写的某个测试方法被运行，比如这个方法还未实现等。可以通过注释@Disabled，将其忽略。

7.@Before和@After

在之前的代码实例中，对于Calculator的测试方法我们都需要在方法开始时声明一个Calculator的对象以调用对应方法。我们可以通@BeforeEach@BeforeALL@AfterEach@AfterAll注解修饰一些用于初始化的方法。注解的具体含义见前文表格。

8.嵌套测试

嵌套测试为测试编写者提供了更多功能来表达几组测试之间的关系。这种嵌套测试利用Java的嵌套类，并促进对测试结构的分层思考。在使用中，我们用@Nested注解代替@Test。下面给出JUnit官方文档中的实例。

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.EmptyStackException;
import java.util.Stack;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

9.参数化测试

在某些情况下，我们可能希望对不同的对象进行相同的检查。首先，我们用@ParameterizedTest 注解，替代 @Test 注解。以基本数据源（支持 Java 的八大基本类型、字符串和 Class）测试为例，我们通过@ValueSource提供数据源，使用时赋值给注解上对应类型属性，以数组方式传递。同时，在测试方法中设置传入参数来接受数据源的数据。

class ParameterizedUnitTest {
    @ParameterizedTest
    @DisplayName("Test value source")
    @ValueSource(ints = {2, 4, 8})
    void testNumberShouldBeEven(int num) {
        Assertions.assertEquals(0, num % 2);
    }
}

10.重复测试

某些情况下，我们希望多次测试某一方法来检查其能力。在重复测试中，我们使用@RepeatTest注解代替@Test。重复次数可以通过@RepeatTest(重复次数)来设置。

11.设置时间限制

某些情况下，我们希望将测试的方法的运行时间限制在一定范围内。由此，可以使用@timeout注解。

超时配置参数

10	@Timeout(10)
10 ns	@Timeout(value = 10, unit = NANOSECONDS)
10 μs	@Timeout(value = 10, unit = MICROSECONDS)
10 ms	@Timeout(value = 10, unit = MILLISECONDS)
10 s	@Timeout(value = 10, unit = SECONDS)
10 m	@Timeout(value = 10, unit = MINUTES)
10 h	@Timeout(value = 10, unit = HOURS)
10 d	@Timeout(value = 10, unit = DAYS)