这是我参与11月更文挑战的第27天，活动详情查看：2021最后一次更文挑战

前置条件

前置条件的作用和断言类似，但是，不同之处在于不满则的断言会使测试方法失败，而不满足的前置条件只会使测试方法终止执行，前置条件可以看成测试的执行前提。

    @DisplayName("测试前置条件")
    @Test
    void testAssumptions(){
        Assumptions.assumeTrue(false,"结果不是true");
        System.out.println("1111");
    }

\

嵌套测试

顾名思义，它可以让我们更有层次去测试我们的代码

我们直接引用官网的测试类

package com.example.springboot01;

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

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

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

/**
 * @author 良良
 * @date 2021/11/27 20:23
 */
public 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());
        }

        private void assertTrue(boolean empty) {
        }

        @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());
            }
        }
    }
}

@Nested标注了我们这个一个嵌套测试，isInstantiatedWithNew方法，只是创建一个新的栈

我们在嵌套的情况下，外层的Test不能驱动内层的Before之类的方法。

参数化测试

之前我们测试的时候，如果需要参数，我们就只能手动去输入一些参数，而且就比较固定，Junit5新引入的参数化测试，就可以很好地解决这个问题

    @ParameterizedTest
    @DisplayName("参数化测试")
    @ValueSource(ints = {1,2,3,4,5})
    void  testParameterizedTest(int i){
        System.out.println(i);
    }

我们这是使用直接输入的方式，但是它也可以接入更多的源，下面我们演示使用类去写入，我们的要输入的要是静态流

	@ParameterizedTest
    @DisplayName("参数化测试")
    @MethodSource("stringStream")
    void  testParameterizedTest(String i){
        System.out.println(i);
    }

    static Stream<String> stringStream(){
        return Stream.of("apple","banana","abc");
    }