package com.yer.boot;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@DisplayName("junit5 功能测试类")
public class JUnit5Test {
    @DisplayName("测试displayname注解")
    @Test
    void testDisplayName(){
        System.out.println(999);
    }
}

package com.yer.boot;
import org.junit.jupiter.api.*;
@DisplayName("junit5 功能测试类")
public class JUnit5Test {
    @DisplayName("测试displayname注解")
    @Test
    void testDisplayName() {
        System.out.println(999);
    }
    @DisplayName("测试displayname注解2")
    @Test
    void testDisplayName2() {
        System.out.println(9992);
    }
    @BeforeEach
        //每个单元测试之前都要执行
    void testBeforeEach() {
        System.out.println("测试要开始了！");
    }
    @AfterEach
        //每个单元测试之后都要执行
    void testAfterEach() {
        System.out.println("测试结束了");
    }
    @BeforeAll
    static void testBeforeAll() {
        System.out.println("要测试所有测试了");
    }
    @AfterAll
    static void testAfterAll() {
        System.out.println("所有测试测试完了");
    }
}

/**
*
* 规定方法的超时时间
* 超出时间测试异常
* @throws InterruptedException
*/
@Timeout(value = 500,unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(1000);
    }

 @DisplayName("测试简单断言")
    @Test
    void testSimpleAssertions(){
        int cal = cal(3,3);
        assertEquals(6,cal);
    }
    int cal(int i,int j){
        return i+j;
    }
//成功 
=======================================
    /**
     *
     * 断言
     * 前面断言失败，后面代码不会执行
     */
    @DisplayName("测试简单断言")
    @Test
    void testSimpleAssertions(){
        int cal = cal(2,3);
        assertEquals(6,cal,"业务逻辑计算失败");
        Object o1 = new Object();
        Object o2 = new Object();
        assertEquals(o1,o2,"两个对象不一样");
    }
    int cal(int i,int j){
        return i+j;
    }

@Test
@DisplayName("array assertion")
public void array(){
    assertArrayEquals(new int[]{1,2},new int{1,2});
}

 @Test
 @DisplayName("组合断言")
  void all(){
    assertAll("test",
              ()->assertTrue(true&&true,"结果不为true"),
              ()->assertEquals(1,1,"结果不为1"));
    system.out.println("两个断言都成功才可以输出")
  }

@Test
    @DisplayName("异常断言")
    void testException(){
        assertThrows(ArithmeticException.class,
                ()-> { int i = 1/0;},"业务逻辑竟然能正常运行，不是吧");
    }

@Test
@DisplayName("超时断言")
public void timeOut(){
    //如果测试方法时间超过1s
    Assertions.assertTimeout(Duration.ofMillis(1000),
                             ()->Thread.sleep(500));
}

    @Test
    @DisplayName("快速失败")
    void testFai(){
        if (2 == 2 ){
            fail("测试失败");
        }
    }

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

package com.yer.boot;
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 java.util.EmptyStackException;
import java.util.Stack;
import static org.junit.jupiter.api.Assertions.*;
@DisplayName("嵌套测试")
public class TestAStackDemo {
    Stack<Object> stack;
    @Test
    @DisplayName("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());
            }
        }
    }
}

 @ParameterizedTest
    @DisplayName("参数化测试")
    @ValueSource(ints = {1,2,3,4,5})
    void  testParameterized(int i){
        System.out.println(i);
    }
    //五个参数同时传进来的效果  把所有要测的统一测一遍

@ParameterizedTest
    @DisplayName("参数化测试")
    @MethodSource("stringProvider")
    void  testParameterized2(String i){
        System.out.println(i);
    }
    static Stream<String> stringProvider() {
        return Stream.of("apple", "banana","我最喜欢的大樱桃");
    }