0
点赞
收藏
分享

微信扫一扫

全国大学生数学建模竞赛-2004-B题-电力市场的输电阻塞管理

少_游 2023-06-01 阅读 93

目录

一、什么是 JUnit

二、JUnit5 相关技术

1.注解

1.1 @Test

1.2 @Disabled

1.3 @BeforeAll、@AfterAll

1.4 @BeforeEach、@AfterEach

2.参数化

2.1 单参数

2.2 CSV 获取参数

2.3 方法获取参数

2.4 多参数

3.测试用例的执行顺序

3.1 顺序执行:@TestMethodOrder(MethodOrderer.OrderAnnotation.class)

3.2 随机执行:@TestMethodOrder(MethodOrderer.class)

4.断言

5.测试套件

5.1 通过 class 运行测试用例

5.2 通过包运行测试用例


🌈本节课我们来学习单元测试框架 Junit,这里的单元测试指的是对最小的软件设计单元(模块)进行验证,在UI自动化测试里面,我们的单元测试主要针对UI界面的功能进行自动化测试。

一、什么是 JUnit

JUnit是一个Java单元测试框架。它由Kent Beck和Erich Gamma建立,逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。

它包括以下特性:

  1. 用于测试期望结果的断言(Assertion)
  2. 用于共享共同测试数据的测试工具
  3. 用于方便的组织和运行测试的测试套件
  4. 图形和文本的测试运行器

🌈通常我们写完代码想要测试这段代码的正确性,那么必须新建一个类,然后创建一个 main() 方法,然后编写测试代码。如果需要测试的代码很多呢?那么要么就会建很多main() 方法来测试,要么将其全部写在一个 main() 方法里面。这也会大大的增加测试的复杂度,降低程序员的测试积极性。而 Junit 能很好的解决这个问题,简化单元测试,写一点测一点,在编写以后的代码中如果发现问题可以较快的追踪到问题的原因,减小回归错误的纠错难度。

二、JUnit5 相关技术

通常我们使用 JUnit5 版本

1.注解

注解(也可以称为 元数据)为在代码中添加信息提供了一种形式化的方法,使得在代码中任一时刻可以非常方便的使用这些数据;注解类型定义了一种新的特殊接口类型,在接口关键期 interface 之前加@符号,即用@interface即可区分注解与普通接口声明。目前大部分框架都是通过使用注解简化代码提高编码效率

1.1 @Test

JUnit提供了非常强大的注解功能,通过 @Test 注解修饰到方法上,该方法就变为了一个测试方法执行当前类时,会自动的执行该类下所有带 @Test 注解的用例

使用这些JUnit提供的注解时,需要在pom.xml文件中进行配置(记得配置完要进行刷新):maven中央仓库

<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.9.2</version>
        </dependency>
    </dependencies>

我们写一个测试用例:

import org.junit.jupiter.api.Test;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
}

❗❗需要注意的是写的代码几个运行按钮:

1.2 @Disabled

Disabled 表示 忽略

import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
}

1.3 @BeforeAll、@AfterAll

@BeforeAll:当前的方法需要在当前类下所有用例执行之前执行一次,且被该注解修饰的方法必须为静态方法

@AfterAll:当前的方法需要在当前类下所有用例执行之后执行一次,且被该注解修饰的方法必须为静态方法

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;


public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
    @BeforeAll
    static void SetUp() {
        System.out.println("这是我们 BeforeAll 里边的语句");
    }
    @AfterAll
    static void TearDown() {
        System.out.println("这是我们 AfterAll 里边的语句");
    }
}

1.4 @BeforeEach、@AfterEach

@BeforeEach:当前的方法需要在每个用例执行之前都执行一次

@AfterEach:当前的方法需要在每个用例执行之后都执行一次

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class JUnitDemo1 {
    @Test
    void Test01() {
        System.out.println("这是 JunitDemo1 里的 Test01");
    }
    @Test
    void Test02() {
        System.out.println("这是 JunitDemo1 里的 Test02");
    }
    @Disabled
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#kw")).sendKeys("521");
        webDriver.findElement(By.cssSelector("#su")).click();
    }
    @BeforeAll
    static void SetUp() {
        System.out.println("这是我们 BeforeAll 里边的语句");
    }
    @AfterAll
    static void TearDown() {
        System.out.println("这是我们 AfterAll 里边的语句");
    }
    @BeforeEach
    void BeforeEachTest() {
        System.out.println("这是 BeforeEach 里边的语句");
    }
    @AfterEach
    void AfterEachTest() {
        System.out.println("这是 AfterEach 里边的语句");
    }
}

2.参数化

参数化就是尽可能的通过一个用例,多组参数来模拟用户的行为;在使用参数化注解之前需要先用 @parameterizedTest 声明该方法为参数化方法,然后再通过注解提供数据来源

 

2.1 单参数

单参数:@ValueSource(数据类型方法={参数1,参数2…})

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

public class JUnitDemo2 {
    //单参数:@ValueSource(数据类型方法={参数1,参数2…})
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void Test01(int num) {
        System.out.println(num);
    }
    @ParameterizedTest
    @ValueSource(strings = {"1", "2", "3"})
    void Test02(String number) {
        System.out.println(number);
    }

}

2.2 CSV 获取参数

CSV 获取参数:@CsvFileSource(resources = "____.csv")

这个时候我们需要在 main 文件下 resources 中创建一个 test.csv 文件.csv 和 参数必须相同):

张三1,李四1,王五1
张三2,李四2,王五2

代码编写: 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvFileSource;
//参数化

public class JUnitDemo2 {
    @ParameterizedTest
    @CsvFileSource(resources = "test.csv")
    void Test03(String name) {
        System.out.println(name);
    }

}

2.3 方法获取参数

@CsvFileSource、@ValueSource 只能传递同种类型的参数,那么我们想要传多种参数,那么可以用方法获取参数

方法获取参数:@MethodSource("Generator")

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.stream.Stream;

public class JUnitDemo2 {
    public static Stream<Arguments> Generator() {
        return Stream.of(Arguments.arguments(1, "张三"),
                Arguments.arguments(2, "李四"),
                Arguments.arguments(3, "王五")
        );
    }

    @ParameterizedTest
    @MethodSource("Generator")
    void Test04(int num, String name) {
        System.out.println(num + ":" + name);
    }

}

2.4 多参数

多参数:@CsvSource({“数据组合1”,“数据组合2”…}),每个双引号是一组参数(测试用例)

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
import java.util.stream.Stream;
public class JUnitDemo2 {
    //多参数:@CsvSource({“数据组合1”,“数据组合2”…})
    @ParameterizedTest
    @CsvSource({"1, 张三", "2, 李四", "3, 王五"})
    void manyTest(int num, String name) {
        System.out.println("num:" + num + ", name:" + name);
    }

}

3.测试用例的执行顺序

我们看以下代码:

所以 测试用例的执行顺序并不会按照我们编写代码的顺序来执行

3.1 顺序执行:@TestMethodOrder(MethodOrderer.OrderAnnotation.class)

顺序执行:@TestMethodOrder(MethodOrderer.OrderAnnotation.class),然后再每次执行的时候添加 @order(执行顺序)

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class JUnitDemo1 {
    @Order(2)
    @Test
    void test03() {
        System.out.println("C");
    }
    @Order(3)
    @Test
    void test01() {
        System.out.println("A");
    }
    @Order(1)
    @Test
    void test02() {
        System.out.println("B");
    }
}

3.2 随机执行:@TestMethodOrder(MethodOrderer.class)

随机执行@TestMethodOrder(MethodOrderer.class),也就是我们看到的一开始的执行顺序

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
@TestMethodOrder(MethodOrderer.class)
public class JUnitDemo2 {
    @Test
    void test03() {
        System.out.println("C");
    }
    @Test
    void test01() {
        System.out.println("A");
    }
    @Test
    void test02() {
        System.out.println("B");
    }
}

4.断言

检查测试方法的期望结果值真实返回值,通过 Assertions 类实现

public class JUnitDemo3 {
    @Test
    void test01() {
        Assertions.assertTrue(1 == 1);
    }
    @Test
    void test02() {
        Assertions.assertTrue(2 == 1);
    }
}

5.测试套件

当我们一个类中有多个测试用例时,我们不可能挨个去运行,那样将会很耗费时间,这时我们就需要 测试套件 来指定类或者指定包名来运行类下或者包下的所有测试用例。

使用测试套件,需要引入依赖

<!-- 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>

还需要引入依赖(使用 suite 需要引入 引擎engine 依赖):

<!-- 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>
</dependency>

5.1 通过 class 运行测试用例

使用 @SelectClasses({指定类, 指定类, 指定类})

JUnitDemo1:

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class JUnitDemo1 {
    @Order(2)
    @Test
    void test03() {
        System.out.println("C");
    }
    @Order(3)
    @Test
    void test01() {
        System.out.println("A");
    }
    @Order(1)
    @Test
    void test02() {
        System.out.println("B");
    }
}

JUnitDemo4:

public class JUnitDemo4 {
    public static Stream<Arguments> Generator() {
        return Stream.of(Arguments.arguments(1, "张三"),
                Arguments.arguments(2, "李四"),
                Arguments.arguments(3, "王五")
        );
    }

    @ParameterizedTest
    @MethodSource("Generator")
    void Test04(int num, String name) {
        System.out.println(num + ":" + name);
    }
}

RunSuite:

@Suite
@SelectClasses({JUnitDemo4.class, JUnitDemo1.class})
public class RunSuite {

}

5.2 通过包运行测试用例

@SelectPackages(value = {"包1", "包2","..."})

JUnit1 包下 Test1:

public class Test1 {
    @Test
    void test1() {
        System.out.println("JUnit1 package Test1 test1");
    }
}

JUnit2 包下 Test2:

public class Test2 {
    @Test
    void test2() {
        System.out.println("JUnit2 package Test2 test2");
    }
}

RunSuite2:

@Suite
@SelectPackages(value = {"JUnit1", "JUnit2"})
public class RunSuite2 {
}

举报

相关推荐

0 条评论