Java Junit单元测试

于 2024-09-10 16:55:40 发布
阅读量825 收藏 16
点赞数 34
分类专栏： Java 文章标签： java junit 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49474843/article/details/142070996
版权

文章目录

前言

所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。

一、Junit单元测试—普通Java文件

对于普通Java文件的单元测试，由于未使用Maven进行依赖管理，我们需要手动导入依赖文件，这里首先介绍一下IDEA中如何导入依赖。

1. Idea依赖导入方式

  1. 在模块下创建lib文件夹
  2. 将需要导入的依赖复制到lib文件夹下
  3. 点击lib文件夹，右键选择Add as Library
    在这里插入图片描述
  4. 选择模块创建（根据实际需求选择即可）
    在这里插入图片描述

2. Junit的使用

在导入Junit依赖后，我们就可以使用Junit提供的工具进行测试
在这里插入图片描述

示例

被测试代码

package day14.MyJunit;

public class MathUtils {
    public static int getSum(int a, int b) {
        return a + b;
    }
    public static int subtract(int a, int b) {
        return a - b;
    }
    public static int multiply(int a, int b) {
        return a * b;
    }
    public static int divide(int a, int b) {
        return a / b;
    }
}

junit测试代码的实现

package day14.MyJunit;

import org.junit.Test;

//第一步: 创建测试类, 测试类的类名一般是:   被测试类类名 + Test
public class MathUtilsTest {
    /*
        第二步: 为了保证每个方法独立, 为测试的每个方法单独创建测试方法
        测试方法要求(规格):
            (1) 不能有参数
            (2) 不能返回值
            (3) 方法名建议:  test+被测试的方法（遵循驼峰命名规范）
            (4) 修饰符必须是public
     */

    // 第三步： 为了保证每个测试方法都能够独立运行,需要加上一个注解@Test

    /*
     @Test : 可以让测试方法独立运行  （核心注解）
     @Before(@BeforeEach): 在每个测试方法运行之前都运行一次
     @After(@AfterEach): 在每个测试方法运行之后都运行一次
     @BeforeClass(@BeforeAll): 在类加载的时候走一次(该注解修饰的测试方法必须是静态方法)
     @AfterClass(@AfterAll) : 在所有的测试方法走完之后走一次(同样只能修饰静态方法 就是静态代码块)

     总结:
        使用步骤:
            (1) 导包
            (2) 创建测试类:
                    类名要求: 要测试的类+Test
            (3) 在测试类中定义测试方法
                    方法要求:
                        (1) 没有返回值, 没有参数
                        (2) 权限修饰符必须是public
                        (3) 方法名要求:test+要被测试的方法名
            (4) 抗上@Test即可
    优点:
        (1) 每个方法测试都单独测试互不影响
        (2) 自动化测试
        (3) 能够生成测试报告
        (4) 还可以断言Assert
 */
/*
    断言：所谓断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。
    由junit的Asset工具类实现
        eg: Assset.assrtEquals("提示消息",预期目标,实际结果);
*/

    @BeforeClass
    public static void beforeOne(){
        System.out.println("我只走一次");
    }
    @AfterClass
    public static void afterOne(){
        System.out.println("我只走一次");
    }
    @Test
    public void textGetsum(){
        System.out.println(MathUtils.getSum(10086, 10010));
    }
    @Test
    public void testSubtract(){
        System.out.println(MathUtils.subtract(10086, 10010));
    }
    @Test
    public void testMultiply(){
        System.out.println(MathUtils.multiply(10086, 10010));
    }
    @Test
    public void testDivide(){
        System.out.println(MathUtils.divide(10086, 10010));
    }
    @Before
    public void before(){
        System.out.println("加载资源");
    }
    @After
    public void afer(){
        System.out.println("释放资源");
    }


    @Test
    public void textGetSum(){
        int sum = MathUtils.getSum(10, 20);
        Assert.assertEquals("提示消息",40,sum);
    }
}

Asset类方法展示

在这里插入图片描述

上述断言测试结果
在这里插入图片描述

二、Junit单元测试—Maven

在这里插入图片描述

  1. 在pom.xml中，引入JUnit的依赖。
<!--Junit单元测试依赖-->
<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>5.9.1</version>
  <scope>test</scope>
</dependency>
  1. 在test/java目录下，创建测试类，并编写对应的测试方法，并在方法上声明@Test注解。

1. 普通测试

被测试类

package org.example;

public class UserService {
    //身份证号---多少岁
    //412821200109114459
    public int getAge(String card){
        return (2024 - Integer.parseInt(card.substring(6, 10)));
    }
}

测试类1

import org.example.UserService;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.Test;


public class UserServiceTest {

    @Test
    public void testGetAge(){
        int age = new UserService().getAge("412821200109114459");
        System.out.println(age);
        Assertions.assertEquals(23,age,"结果有误");
    }
    @BeforeEach
    public void beforeEach(){
        System.out.println("每个方法执行之前，都先执行我");
    }
    @BeforeAll
    public static void beforeAll(){
        System.out.println("我在类加载的时候加载一次");
    }
    @AfterEach
    public void afterEach(){
        System.out.println("每个方法执行执行之后，我都要执行");
    }
    @AfterAll
    public static void afterAll(){
        System.out.println("我在所以方法执行结束时执行一次");
    }
}

在这里插入图片描述

2. 单参数测试

@DisplayName注解和(@ParameterizedTest,@ValueSource注解）

import org.example.UserService;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

//设置执测试类名  默认为类名
@DisplayName("测试-学生业务")
public class UserServiceTest {

    //设置测试方法名 默认为方法名
    @DisplayName("测试-学生年龄")
    @Test
    public void testGetAge(){
        int age = new UserService().getAge("412821200109114459");
        System.out.println(age);
        Assertions.assertEquals(23,age,"结果有误");
    }

    @DisplayName("多参数测试-学生年龄")
    //标志，代表有参数测试
    @ParameterizedTest
    //设置测试参数  方法测试方法会依次遍历注解数组中的元素
    @ValueSource(strings={"412821196245632147","412821196214141118","145987196212354415"})
    public void testGetAges(String s){
        int age = new UserService().getAge(s);
        //断言
        Assertions.assertEquals(62,age,"戳");
    }
}

测试结果

在这里插入图片描述

@ValueSoure注解源码

在这里插入图片描述

3. 多参数测试

@CsvSource注解

 /*
    @CsvSource 是一个在 JUnit 5 中用于提供测试数据的注解，特别是在参数化测试中非常有用。它允许你以逗号分隔值（CSV）
    格式直接在测试类中定义测试数据，并且这些数据会被自动注入到测试方法中。

    基本用法
    @CsvSource 注解可以被用在 @ParameterizedTest 上，来为测试方法提供一组或多组参数。每组参数都是一行CSV格式的数据，
    其中每个值由逗号分隔。
*/
    @ParameterizedTest
    @CsvSource({"lvbu,123456", "xiaoqiao,123456"})  //每个字符串数组的元素都是一组数据     
    public void testQuery(String username , String password) { //方法参数与每组数据对应，方法会依次测试每组数据
        //方法体
    }

/*
    CSV 文件的基本结构
        分隔符：最常用的分隔符是逗号（,），但也可以使用其他字符，比如制表符（\t）、竖线（|）等。
        行：每行代表一条记录或一行数据。
        列：每列代表一个特定的属性或字段。
    CSV 文件的例子
        Alice,22,New York
        Bob,25,Los Angeles
*/

@CsvFileSource注解 读取CSV文件中数据

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvFileSource;
import org.junit.jupiter.params.provider.CsvSource;

import java.sql.*;

public class JDBCDQLTest {
    @Test
    @ParameterizedTest
    @CsvFileSource(resources = "jdbctest.csv")  //该注解可以读取csv文件中内容，每一行为一组
    public void testDqlJDBC(String _name,String _password) throws ClassNotFoundException, SQLException {
        //链接数据库
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "JDBC:mysql://localhost:3306/itheima";
        Connection connection = DriverManager.getConnection(url, "root", "root");

        //获取数据库执行对象
        Statement statement = connection.createStatement();

        //执行SQL语句
        ResultSet resultSet = statement.executeQuery("select * from user where username ='"+ _name+"'and password = '"+_password+"'");

        //读取结果中的语句
        while (resultSet.next()){
            int id = resultSet.getInt("id");
            String username = resultSet.getString("username");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            System.out.println("id:"+id+"  username:"+username+"  name:"+name+"  age:"+age);
        }

        //关闭资源
        connection.close();
        statement.close();

    }
}

在这里插入图片描述

三、Junit单元测试—SpringBoot项目

在SpringBoot项目中，如果只是进行简单的单元测试，这直接按照上述Maven操作即可，但如果测试需要获取项目上下文内容(也就是Bean)，则需要创建与主配置类结构一致的测试类，并加上引入@SpringBootTest

1. 使用步骤

  1. 引入Maven依赖
   <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
   </dependency>
  1. 创建测试类
    在这里插入图片描述
  2. 引入@SpringBootTest注解
    在这里插入图片描述
  3. 进行测试操作，使用注解进行测试即可

2. @SpringBootTest详解

  • @SpringBootTest 是 Spring Boot 提供的一个注解，用于启动一个完整的 Spring Boot 应用程序上下文，并在其中执行测试。这个注解通常用于集成测试，因为它可以模拟完整的应用程序环境，包括配置文件、自动装配的 Bean、以及依赖项等。
  • @SpringBootTest 注解可以被应用在一个测试类上，它会启动一个完整的 Spring Boot 应用程序上下文，并加载所有的 Bean。（扫描相同包结构下对应的主配置类，或者classes指定的住配置类，SpringBoot项目中导入spring-boot-startr-test后测试类和包结构会自动生产，该注解包含了junit单元测试注解,所以实际上用的还是junit）

示例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class ApplicationContextTest {

    @Autowired
    private SomeService someService;

    @Test
    public void contextLoads() {
        // 这里可以验证应用程序上下文是否正确加载
        // 例如，验证某些 Bean 是否正确初始化
        assert someService != null;
    }
}
/*
在这个例子中：
● @SpringBootTest 注解启动了一个完整的 Spring Boot 应用程序上下文。
● @Autowired 注入了一个 SomeService Bean，用于测试。

*/
  • 配置选项
    • @SpringBootTest 注解还提供了一些可选的配置选项，用于控制应用程序上下文的加载方式：
      • webEnvironment：指定是否启动 Web 环境。可以选择 WebEnvironment.RANDOM_PORT、WebEnvironment.DEFINED_PORT 或 WebEnvironment.NONE。
      • classes：指定要加载的主配置类(就是引导类，启动类)。
      • properties：指定要在测试期间覆盖的属性。

示例 通过classes指定后，这不必须与主配置类结构一致

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
                classes = Application.class,
                properties = {"server.port=0", "spring.datasource.url=jdbc:h2:mem:testdb"})
public class ApplicationContextTest {

    @Autowired
    private SomeService someService;

    @Test
    public void contextLoads() {
        // 这里可以验证应用程序上下文是否正确加载
        // 例如，验证某些 Bean 是否正确初始化
        assert someService != null;
    }
}
/*
● webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT 
    表示启动一个随机端口的 Web 环境。
● classes = Application.class 指定主配置类。
● properties 用于覆盖配置文件中的属性。

*/
  • 使用 @RunWith(SpringRunner.class)
    在 JUnit 4 中，你需要使用 @RunWith(SpringRunner.class) 来启动 Spring Boot 应用程序上下文。但在 JUnit 5 中，Spring Boot 已经默认使用了 SpringRunner，因此不再需要显式声明。
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationContextTest {

    @Autowired
    private SomeService someService;

    @Test
    public void contextLoads() {
        // 这里可以验证应用程序上下文是否正确加载
        // 例如，验证某些 Bean 是否正确初始化
        assert someService != null;
    }
}
风清已存在
关注
  • 34
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文详解Java单元测试Junit
wk_cjs的博客
12-07 1821
就是针对最小的功能单元（方法），编写测试代码对其进行正确性测试。
java 单元测试实例_java junit单元测试实例，junit单元测试例子
weixin_29315569的博客
02-16 1102
下面给大家分享的是一个java junit单元测试实例，一起来了解一下吧，希望下面的java实例可以对你有所帮助呢。首先的话，创建一个java工程，在工程当中创建一个被单元测试的Student数据类。packagecom.phicomme.hu;publicclassStudent{privateStringname;privateStringsex;privateinthigh...
Java Junit单元测试（入门必看篇）
Jin_Xiang123的博客
11-13 8460
什么是Junit单元测试？为什么要使用Junit单元测试？Junit单元测试的使用：1、注解；2、用例的执行顺序；3、测试套件； Junit 是一个 Java 编程语言的单元测试框架。Junit 在测试驱动的开发方面有很重要的发展，是起源于 Junit 的一个统称为 xUnit 的单元测试框架之一。所谓 xUnit,就是一套基于测试驱动开发的测试框架，它的机制：将程序 预期的结果与程序运行的最终结果进行比对，确保对结果的可预知性。单元测试是一个对单一实体（类或方法）的测试。
【Java】单元测试JUnit
qq_39921135的博客
07-25 819
我们在运行代码的时候都是一个方法方法的运行，是不可以只运行方法中的某一行代码，因此Java程序最小的功能单元是方法。单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此单元测试就是针对Java方法的测试，进而检查方法的正确性。以前没有单元测试的时候，只有一个main方法，如果一个方法的测试失败了，其他方法测试都会受到影响。因为main方法都是运行在main线程中的，一个方法只要出现了异常，那么这条线程就没了，下面的代码就执行不到了。
Java IDEA JUnit 单元测试
笔记
12-29 5773
JUnit是一个开源的 Java 单元测试框架，它使得组织和运行测试代码变得非常简单，利用JUnit可以轻松地编写和执行单元测试，并且可以清楚地看到哪些测试成功，哪些失败JUnit 还提供了生成测试报告的功能，报告不仅包含测试的成功率，还能统计被测试代码的覆盖率。通过进行单元测试，我们可以确保每个方法按照预期正确运行。如果我们修改了某个方法的代码，只需要确保相应的单元测试通过，就可以认为修改是正确的。此外，测试代码本身也可以作为示例代码，用于演示如何调用该方法。
IDEA Java Junit单元测试入门实战
xueping_wu的博客
10-19 3301
IDEA Java Junit单元测试入门实战１、下载jar包２、在IDEA中添加jar包３、创建单元测试代码 junit的使用： 　　junit不是javase的一部分，想要使用需要导入jar包。 　　测试对象是一个类中的方法。单元测试的方法命名规则： 　　public void 方法名() {} 　　注：所有测试方法返回类型必须为void且方法名中无参数 　　使用注解方式运行测试方法： 　　　　１）@Test：表示方法进行单元测试 　　　　２）@Ignore：表示这个方法不进行单元测试 　　　　３）@B
java--Junit单元测试
qq_34577961的博客
03-25 677
2、 实际作用简化以下两行代码，通过注解方式获取bean对象3、配置基本的xml配置文件-- 开启组件扫描-->4、代码举例。
JUnit单元测试
weixin_44084024的博客
04-18 3395
JUnit是一种Java语言的单元测试框架，它是最流行的单元测试框架之一。它提供了一些可用于编写和运行测试的API，并且可以生成测试报告。JUnit适用于所有Java语言的项目，例如Java应用程序、Java Servlet、Java EE应用程序以及Android应用程序等。
Java—junit单元测试
qq_56725871的博客
05-21 886
JUnit 5是Java编程语言中的一个单元测试框架，它提供了一组API和注解，用于编写和运行测试。以下是JUnit 5的主要特点：支持多种扩展模型：JUnit 5采用了插件架构，开发人员可以通过不同的扩展模型来定制测试框架，以满足其特定需求。改进的注解支持：JUnit 5提供了一系列新的注解，如@Test、@BeforeEach和@AfterEach等，这些注解使得编写测试更加简单和直观。
超级详细的Junit单元测试教程
热门推荐
奈何的人生
05-31 10万+
如果你只会使用@Test来完成单元测试，那你是时候该深入一下了，其实知识点一点都不少！
Java Junit单元测试实例详解
08-25
Java Junit 单元测试实例详解 Java Junit 单元测试是软件测试中的一种重要方法，旨在确保软件的质量和可靠性。本篇文章将为大家详细讲解 Java Junit 单元测试的相关知识点内容。 一、测试分类 在软件测试中，测试...
解决java junit单元测试@Test报错的问题
08-26
通过以上步骤，大多数情况下都可以解决Java JUnit单元测试中遇到的@Test报错问题。同时，了解JUnit的基本用法和最佳实践也能帮助避免这类问题的发生，比如合理组织测试类和测试方法，以及正确使用断言(Assertions)来...
junit4 jar包 Java单元测试框架绿色免费版.zip
11-21
JUnit4是Java编程语言中最广泛使用的单元测试框架之一，它为开发者提供了一种方便、高效的方式来验证代码的正确性。这个“junit4 jar包 Java单元测试框架绿色免费版.zip”文件包含的是JUnit4框架的可执行jar包，用于...
spring事务详细讲解-深入浅出
小电玩
09-08 461
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1447
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 517
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 534
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 709
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 390
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
java junit单元测试
02-19
JUnit是一个用于编写和运行单元测试的Java框架。它提供了一组注解和断言方法，使得编写和执行单元测试变得简单和方便。 在JUnit中，我们可以使用以下注解来标记测试方法： 1. `@Test`：用于标记一个测试方法。 2. `@Before`：用于在每个测试方法之前执行的方法。 3. `@After`：用于在每个测试方法之后执行的方法。 4. `@BeforeClass`：用于在所有测试方法之前执行的方法，通常用于初始化一些共享的资源。 5. `@AfterClass`：用于在所有测试方法之后执行的方法，通常用于释放一些共享的资源。 除了注解，JUnit还提供了一些断言方法来验证测试结果： 1. `assertEquals(expected, actual)`：验证两个值是否相等。 2. `assertTrue(condition)`：验证条件是否为真。 3. `assertFalse(condition)`：验证条件是否为假。 4. `assertNull(object)`：验证对象是否为null。 5. `assertNotNull(object)`：验证对象是否不为null。 通过使用这些注解和断言方法，我们可以编写各种各样的单元测试来验证代码的正确性。JUnit还提供了丰富的功能，如参数化测试、异常测试等，以满足不同的测试需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值