单元测试Junit5

写在前面：建议大家看官网，别人写的不一定全，但是官网一定是全面且详细的。

测试注解

package com.example.demo;

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.TimeUnit;

/**
 * Created by 酥梨 on 2021/12/27 21:58
 */

@DisplayName("测试类")
@SpringBootTest//导入spring，从此可以直接使用@Autowired
public class Junit5Test {

    @RepeatedTest(5)//多次测试
    @DisplayName("测试方法1")
    @Test
    void testDisplayName(){
        System.out.println("==========");
    }

    @Disabled//禁用该测试方法
    @DisplayName("测试方法2")
    @Test
    void testDisplayName2(){
        System.out.println("==========");
    }

    @BeforeEach//每个测试方法执行之前都打印
    void testBeforeEach(){
        System.out.println("---------+++++++++++++");
    }

    /**
     * 规定方法超时时间，超出时间测试出异常
     */
    @Timeout(value = 500,unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout(){
        try {
            Thread.sleep(600);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    @AfterEach//每个测试方法执行之后都打印
    void testAfterEach(){
        System.out.println("+++++++++---------");
    }

    @BeforeAll//所有测试方法执行之前都打印
    static void testBeforeAll(){
        System.out.println("所有测试要开始了");
    }


    @AfterAll//所有测试方法执行之后都打印
    static void testAfterAll(){
        System.out.println("所有测试要结束了");
    }
}

断言

官方文档

//需要引入
import static org.junit.jupiter.api.Assertions.*;

	/**
     * 多个断言的情况下：前一个断言失败，后面的代码将不执行
     */
    @DisplayName("测试简单断言")
    @Test
    void testSimpleAssertions(){
        int plus = plus(3, 3);
        //判断相同
        assertEquals(5,plus,"值不同");
        //判断不相同
        assertNotEquals(6,plus,"值相同");

        Object o = new Object();
        Object o_copy = o;
        Object o1 = new Object();
        //相同引用
        assertSame(o,o1,"不同引用");
        //不相同引用
        assertNotSame(o_copy,o,"同引用");

        //数组比较
        assertArrayEquals(new int[]{2,2},new int[]{1,2},"不一样的数组");
    }


    @DisplayName("组合断言")
    @Test
    void all(){
        //全部成功才是成功
        assertAll("test",
                ()->assertEquals(1,2,"msg"),
                ()->assertTrue(true&&true,"msg"));
    }


    @DisplayName("异常断言")
    @Test
    void testException(){
        assertThrows(ArithmeticException.class,
                ()->{int i = 10/0;},
                "数学运算居然正常");
    }

    @DisplayName("超时测试")
    @Test
    void testTimeout(){
        assertTimeout(Duration.ofMillis(1000),
                ()->Thread.sleep(500),
                "超时了");
    }


    @DisplayName("快速失败")
    @Test
    void shouldFail(){
        fail("This should fail");
    }

前置条件

官方文档

	/**
     * 测试前置条件
     */
    @Test
    @DisplayName("测试前置条件")
    void testAsssumptions(){
        //如果不成功，就跳过，而不是异常报错
        Assumptions.assumeTrue(false,"结果不是true");
        System.out.println("1111111111");
    }

注意对比上图

嵌套测试

官方文档

package com.example.demo;

import static org.junit.jupiter.api.Assertions.*;

import java.util.*;

import org.junit.jupiter.api.*;

/**
 * Created by 酥梨 on 2021/12/29 23:36
 */

@DisplayName("嵌套测试类")
public class TestingAStackDemo {
    Stack<Object> stack;

    @Test
    @DisplayName("new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
        //外层的test，无法让内层的BeforeEach/All方法启动
        assertNull(stack);
    }

    @Nested//第二层的类，注解表明嵌套
    @DisplayName("when new")
    class WhenNew {//该类本身有3个test

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

        //内层的test可以驱动外层的BeforeEach/All
        @Test
        @DisplayName("空栈")
        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());
            }
        }
    }
}

参数化测试

官方文档

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

	@ParameterizedTest//参数化测试
    @DisplayName("参数化测试")
    @ValueSource(ints = {1,2,3,4,5})//八种基本类型+String+class任你选择
    void testpalindromes(int i){
        System.out.println(i);
    }

其他注解请看官网。