1. 什么是 Junit ？

Junit 是 Java 的单元测试框架

---

在 Java 项目中加入 Junit 依赖

		<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.1</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-params -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-params</artifactId>
            <version>5.9.1</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.junit.platform/junit-platform-suite -->
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-suite</artifactId>
            <version>1.9.1</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-engine -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.9.1</version>
            <scope>test</scope>
        </dependency>

2. 常见的注解

2.1 @Test

• @Test：表名当前的方法是一个测试用例

import org.junit.jupiter.api.Test;

public class JunitTest {
    @Test
    void Test01() {
        System.out.println("========这是第一个测试用例=======");
    }

    @Test
    void Test02() {
        System.out.println("========这是第二个测试用例=======");
    }
}

2.2 @BeforeAll，@AfterAll

• @BeforeAll：当前 class 中所有测试用例执行之前自动执行
• @AfterAll：当前 class 中所有测试用例执行结束之后自动执行

	@BeforeAll
    static void Start() {
        System.out.println("开始测试");
    }
    @AfterAll
    static void End() {
        System.out.println("结束测试");
    }

2.3 @BeforeEach，@AfterEach

• @BeforeEach：当前 class 中每一个测试用例执行结束之前执行一次
• @AfterEach：当前 class 中每一个测试用例执行结束之后执行一次

@BeforeEach
    void StartV1() {
        System.out.println("开始执行");
    }
    @AfterEach
    void EndV1() {
        System.out.println("执行结束");
    }

3. 测试用例顺序指定

• @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
  
  

4. 参数化

4.1 单个参数

	//单参数
    @ParameterizedTest
    @ValueSource(ints = {1,2,3,4})
    void Test03(int x) {
        System.out.println("接收参数是 x = " + x);
    }

单参数有它的弊端，只能接收一种类型的参数，对应的 Test 方法，只能接收一个参数

4.2 多个参数

	//多参数
    @ParameterizedTest
    @CsvSource({"'张三','18'"})
    void Test04(String name, int age) {
        System.out.println(name + "今年 " + age + " 岁");
    }

参数化对应的注解上面如果写了Test，测试用例就会执行两次
其中一次就会报错，因为 Test 和 方法结合，没有找到参数，就会报错

---

	//多参数，读取文件中的数据，进行操作
    @ParameterizedTest
    @CsvFileSource(resources = "test01.csv")
     void Test05(String name, int age) {
        System.out.println("name:" + name + ", age:" + age);
    }

4.3 通过方法生成

	public static Stream<Arguments> Generate() {
        return Stream.of(
                Arguments.arguments("张三", 13),
                Arguments.arguments("李四",14)
        );
    }
    
	//通过方法生成测试数据
    @ParameterizedTest
    @MethodSource("Generate")
    void Test06(String name, int age) {
        System.out.println("姓名：" + name + "年龄：" + age);
    }

5. 测试套件

• @Suite

---

6. 断言

6.1 断言相等

//断言相等
    @Test
    void Test07() {
        int x = 10;
        int y = 20;
        Assertions.assertEquals(x, y);
    }

6.2 断言不相等

	//断言不相等
    @Test
    void Test07() {
        int x = 10;
        int y = 20;
        Assertions.assertNotEquals(x, y);
    }

6.3 断言为空

	//断言为空
    @Test
    void Test07() {
        int x = 10;
        int y = 20;
        String tmp = null;
        Assertions.assertNull(tmp);
    }

6.4 断言不为空

	//断言不为空
    @Test
    void Test07() {
        int x = 10;
        int y = 20;
        String tmp = null;
        Assertions.assertNotNull(tmp);
    }