单元测试junit

已于 2022-07-11 17:16:14 修改
阅读量2.5k 收藏 16
点赞数 5
分类专栏： Java 文章标签： junit 单元测试 java
于 2022-07-11 16:57:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51613816/article/details/125723698
版权

一、介绍

官网：https://junit.org/
JUnit是一个Java语言的单元测试框架，Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何完成功能和完成什么样的功能，Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了

1.1注意事项

  • 测试方法必须使用 @Test 修饰
  • 测试方法必须使用 public void 进行修饰，不能带参数
  • 一般使用单元测试会新建一个 test 目录存放测试代码，在生产部署的时候只需要将 test 目录下代码删除即可
  • 测试代码的包应该和被测试代码包结构保持一致
  • 测试单元中的每个方法必须可以独立测试，方法间不能有任何依赖
  • 测试类一般使用 Test 作为类名的后缀
  • 测试方法使一般用 test 作为方法名的前缀

1.2测试失败说明

  • Failure：一般是由于测试结果和预期结果不一致引发的，表示测试的这个点发现了问题
  • error：是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中隐藏的 bug

1.3常用注解

  • @Test:将一个普通方法修饰成一个测试方法
    • @Test(excepted=xx.class): xx.class 表示异常类，表示测试的方法抛出此异常时，认为是正常的测试通过的
    • @Test(timeout = 毫秒数) ：测试方法执行时间是否符合预期
  • @BeforeClass： 会在所有的方法执行前被执行，static 方法 ，全局只会执行一次，而且是第一个运行
  • @AfterClass：会在所有的方法执行之后进行执行，static 方法 ，全局只会执行一次，而且是最后一个运行
  • @Before：会在每一个测试方法被运行前执行一次
  • @After：会在每一个测试方法运行后被执行一次
  • @Ignore：所修饰的测试方法会被测试运行器忽略
  • @RunWith：可以更改测试运行器 org.junit.runner.Runner
  • @Parameters：参数化注解

1.4Assert类

  1. void assertEquals(boolean expected, boolean actual)：检查预期值和实际值是否相等
  2. void assertTrue(boolean condition)：检查条件为真
  3. void assertFalse(boolean condition)：检查条件为假
  4. void assertNotNull(Object object)：判断对象是否不为空
  5. void assertNull(Object object)：判断对象是否不为空
  6. void assertSame(Object expected, Object actual)：判断两个对象是否指向同一个对象
  7. void assertNotSame(Object expected, Object actual)：判断两个对象是否不指向同一个对象
  8. void assertArrayEquals(expectedArray, resultArray)：判断两个数组是否相等

二、junit4测试案例

2.1普通工程

2.1.1导入依赖

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
</dependency>

2.1.2创建一个作为要测试的类

public class Calculate {

    public int add(int a , int b){
        return a + b;
    }

    public int subtract(int a , int b){
        return a - b;
    }

    public int multiply(int a , int b){
        return a * b;
    }

    public int divide(int a , int b){
        return a / b;
    }
}

2.1.3创建测试类

在test目录下与要测试的类相同包路径下创建测试类，也可以选择要测试的类的类名点击右键—Go To—Test进行快捷创建
在这里插入图片描述
这里的junit版本选择junit4
在这里插入图片描述

public class CalculateTest {

    @BeforeClass
    public static void beforeClass(){
        System.out.println("beforeClass…………");
    }

    @Before
    public void before(){
        System.out.println("before^^^^^^^^");
    }

    @Test
    public void testAdd() {
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }

    @Test
    public void testSubtract() {
        Calculate calculate = new Calculate();
        int subtract = calculate.subtract(3, 1);
        System.out.println(subtract);
    }

    @Test
    public void testMultiply() {
        Calculate calculate = new Calculate();
        int multiply = calculate.multiply(1, 3);
        System.out.println(multiply);
    }

    @Test
    public void testDivide() {
        Calculate calculate = new Calculate();
        int divide = calculate.divide(10, 2);
        System.out.println(divide);
    }

    @AfterClass
    public static void afterClass(){
        System.out.println("afterClass…………");
    }

    @After
    public void after(){
        System.out.println("after^^^^^^^");
    }
}

2.2junit4集成SpringBoot工程

2.2.1导入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.3</version>
</parent>
  
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
</dependency>

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
</dependency>

2.2.2 创建springboot启动类，并创建要测试的类

@SpringBootApplication
public class SpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplication.class,args);
    }
}

public class Calculate {

    public int add(int a , int b){
        return a + b;
    }

    public int subtract(int a , int b){
        return a - b;
    }

    public int multiply(int a , int b){
        return a * b;
    }

    public int divide(int a , int b){
        return a / b;
    }
}

2.2.3 创建测试类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest()
public class SpringBootJunit4 {
    @Test
    public void add(){
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }
}

三、junit5

3.1组成结构

  • JUnit Platform: 是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入
  • JUnit Jupiter: 提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个测试引擎，用于在Junit Platform上运行
  • JUnit Vintage: 由于JUint已经发展多年，为了照顾老的项目，其提供了兼容JUnit4.x,Junit3.x的测试引擎

3.2引入的依赖

<!--maven工程-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.7.1</version>
    <scope>test</scope>
</dependency>

<!--springboot项目，test依赖包含junit-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

3.3常用注解

  • @Test：被注解的方法是一个测试方法，与junit4相同
  • @BeforeAll：static 方法，会在所有的方法执行前被执行 ，全局只会执行一次而且是第一个运行，与junit4中的BeforeClass一样
  • @AfterAll：static 方法，会在所有的方法执行后被执行 ，全局只会执行一次而且是最后一个运行，与junit4中的AfterClass一样
  • @BeforeEach：被注解的方法将在当前类的每个@Test方法前执行，与junit4中的Before一样
  • @@AfterEach：被注解的方法将在当前类的每个@Test方法后执行，与junit4中的After一样
  • @Disable：被注解的方法不会执行，与junit4中的Ignore一样
  • @DisplayName：测试类或方法的显示名称
  • @Tag： 为测试类或方法加标签
  • @RepeatedTest：额外重复执行，根据参数额外执行指定次数
  • @Nested：嵌套测试
  • @Timeout：表示测试方法超过了指定时间将返回错误，可以有两个参数，一个为时间，一个为时间单位，默认为秒

3.4断言 static org.junit.jupiter.api.Assertions.*

  • assertEquals：判断两个对象是否相等
  • assertNotEquals：判断两个对象是否不相等
  • assertSame：判断两个对象是否指向通个对象
  • assertNotSame：判断两个对象是否不指向通个对象
  • assertTrue：判断是否为true
  • assertFalse：判断是否为false
  • assertNull：判断是否为空
  • assertNotNull：判断是否不为空

3.5前置条件 org.junit.jupiter.api

类似于断言，只不过不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止，可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要

3.6代码案例

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class SpringBootJunit5 {

    @BeforeAll
    public static void before(){
        System.out.println("before^^^^^^^");
    }

    @RepeatedTest(2)
    @DisplayName("测试一下")
    @Test
    public void add(){
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }

    @Test
    @Timeout(value = 500 , unit = TimeUnit.MILLISECONDS)
    public void divide(){
        Calculate calculate = new Calculate();
        int divide = calculate.divide(8, 2);
        System.out.println(divide);
        try {
            Thread.sleep(501);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 如果预期值与实际值一致，正常执行
     * 如果预期值与实际值不一样，打印错误信息和预期值、实际值
     */
    @Test
    public void multiply(){
        Calculate calculate = new Calculate();
        int multiply = calculate.multiply(1, 2);
        System.out.println(multiply);
        assertEquals(multiply ,2 , "两个对象一样");
    }

    @Test
    public void subtract(){
        Assumptions.assumeTrue(false,"不满足就不执行");
        Calculate calculate = new Calculate();
        int subtract = calculate.subtract(5, 1);
        System.out.println(subtract);
    }

    @AfterAll
    public static void after(){
        System.out.println("after^^^^^^^");
    }
}

注解@DisplayName和@RepeatedTest执行效果，使用@RepeatedTest注解会另加执行指定次数所标注的方法
注解@DisplayName和@RepeatedTest执行效果
注解@Timeout执行效果，超过指定时间会失败
在这里插入图片描述
断言不一致的执行效果，程序会失败，并指出预期值与实际值
在这里插入图片描述
前置条件不一致的执行效果，方法不执行，打印指定的消息
在这里插入图片描述

3.7 嵌套测试

  • JUnit 5 通过 Java 中的内部类和@Nested 注解实现嵌套测试，将相关的测试方法组织在一起，在内部类中可以使用@BeforeEach 和@AfterEach 注解，而且嵌套的层次没有限制
  • 外层测试方法的执行不会驱动内层方法，当内层方法有 before 或 after 等注解调用外层测试方法，并不会驱动其提前或最后执行
  • 内层方法的执行，可以驱动外层方法，当外层方法定义了某一数据结果时，内层测试方法可以直接调用该结构
import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@DisplayName("嵌套测试")
public class TestNested {

    @BeforeAll
    public static void before(){
        System.out.println("beforeAll^^^^^^");
    }

    @Test
    @DisplayName("外层测试方法1")
    void outer1() {
        System.out.println("在嵌套测试情况下，外层的test不能驱动内层的beforeAll等方法,内层的test可以驱动外层");
    }

    @Test
    @DisplayName("外层测试方法2")
    String outer2(){
        return "外层测试方法2";
    }

    @Nested
    @DisplayName("内部类1")
    class InnerClass1{

        @BeforeEach
        void innerClass1BeforeEach() {
            System.out.println("InnerClass1BeforeEach1^^^^^^^");
        }

        @Test
        @DisplayName("内部类1内部方法1")
        void InnerClass1Method1() {
            String s = outer2();
            System.out.println("内部类1内部方法1 " +s);
        }

        @Nested
        @DisplayName("内部类2")
        class InnerClass2 {

            @BeforeEach
            void innerClass2BeforeEach() {
                System.out.println("InnerClass2BeforeEach1^^^^^^^^^^");
            }

            @Test
            @DisplayName("内部类2内部方法2")
            void InnerClass2Method2() {
                System.out.println("内部类2内部方法2");
            }
        }
    }
}

执行整个类效果
在这里插入图片描述

3.8参数化测试

可以指定测试方法的输入参数

  • @ValueSource：为参数化测试指定入参来源，支持八大基础类以及String类型、Class类型
  • @NullSource：表示为参数化测试提供一个null的入参
  • @EnumSource：表示为参数化测试提供一个枚举入参
  • @CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参
  • @MethodSource：表示读取指定方法的返回值作为参数化测试入参，方法的返回值为流
package com.haomu;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.stream.Stream;

@SpringBootTest
public class ParametricTest {

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

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

    @ParameterizedTest
    @DisplayName("参数化测试2")
    @MethodSource("stringProvider")
    void testParameterized2(String s) {
        System.out.println(s);
    }
}

执行整个类效果
在这里插入图片描述

这些就是关于junit的介绍，如有问题请指出，谢谢阅读！

皓慕
关注
专栏目录
大数据必学Java基础（八十三）：Junit单元测试
Lansonli（蓝深李）的博客
10-21 1334
软件的白盒测试是对软件的过程性细节做细致的检查。这种方法是把测试对象看做一个打开的盒子，它允许测试人员利用程序内部的逻辑结构及有关信息，设计或选择测试用例，对程序的所有逻辑路径进行测试,通过在不同点检查程序状态，确定实际状态是否与预期的状态一致。这种方法是把测试对象看做一个黑盒子，测试人员完全不考虑程序内部的逻辑结构和内部特性，只依据程序的需求规格说明书,检查程序的功能是否符合它的功能说明。一般会在@After修饰的那个方法中加入：加入释放资源的代码：释放数据库资源，释放IO资源，释放网络资源。
一文详解Java单元测试Junit
最新发布
wk_cjs的博客
12-07 1832
就是针对最小的功能单元（方法），编写测试代码对其进行正确性测试。
Junit单元测试
赵广陆
09-13 722
目录 1 测试分类 2 Junit使用：白盒测试 3 判定结果： 4 执行顺序 1 测试分类 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 2 Junit使用：白盒测试 步骤： 定义一个普通的计算类,有方法需要测试 /** * 计算器类 */ public class Calculator { /** * 加法 * @param a * @...
Junit之Test测试
qq_40926127的博客
05-01 3442
Junit之Test测试 Junit使用:首先需要导入Junit的jar包。 使用方式:在方法前加@Test注解 import org.junit.Test; public class junitTest { public static void main(String[] args) { System.out.println("这是main方法"); } /* ...
单元测试JUnit Test
伟庭的博客
11-29 1386
单元测试 JUnit Test
JUnitTest
tim_tang
04-24 271
对增删改查的测试用例的编写方法 1-增加对象的一条记录： 方法：-先把表中的所有记录删除       -手工插入一条记录       -用SQL语句查出总的记录数，断言与1相等       2-删除对象的一条记录 方法：-查找到表中的所有记录，并放在一个LIST中       -遍历这个LIST的同时，删除所有记录       -查询所有记录，断言取到的LIST与0相等       3-更新对...
junit单元测试junit单元测试junit单元测试
03-15
JUnit是Java编程语言中最常用的单元测试框架之一，它允许开发者编写可重复运行的测试用例，以确保代码的正确性和稳定性。单元测试是软件开发过程中的一个重要环节，它旨在对程序中的最小可测试单元——通常是单个...
SpringBoot 单元测试JUnit的使用详解
08-25
SpringBoot 单元测试JUnit的使用详解 在本文中，我们将详细介绍 SpringBoot 中的单元测试 JUnit 的使用方法。JUnit 是一个优秀的开源 Java 单元测试框架，目前使用率最高、最流行的测试框架。开发工具 Eclipse 和 ...
JunitTest
03-28
NULL 博文链接：https://zhang-he.iteye.com/blog/1228237
JunitTest单元测试
Mark姚
09-24 570
1.Junit单元测试，用于测试自己写的类的方法是否有问题。 用法： //被测试的类 public class MyUtils { //加法 public int add(int a, int b){ return a-b;//故意写错 } //减法 public int sub(int a,int b){ return a-b; } } import org.junit.Test;//导入这个 @Test//加上
Junit 单元测试（详解）
weixin_52533007的博客
04-07 7636
本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！JUnit 是一种流行的单元测试框架，它可以帮助开发人员编写、运行和调试单元测试，以确保代码的正确性。在本篇博客中，我们将介绍 JUnit 的基本概念、特点和用法，以及如何编写和运行单元测试。
单元测试JUnit
伟大的程序员的博客
05-08 577
今天总结一下java中常用的一种测试方法–单元测试JUnit。单元测试针的对象是类中的方法，被测试的方法必须满足如下几个条件： 1. 无返回值 2. 无参数 3. public修饰 下面给出一个例子：import org.junit.Test; public class Test2 { @Test public void sum() { int a=9
JunitTest---1
java开发指南博客 【转载】
04-14 160
1. 使用Junit的最佳实践： 1） 新建一个名为test的source folder，用于存放测试类源代码 2） 目标类与测试类应该位于同一个包下面，这样测试类中就不必导入源代码所在的包，因为他们位于同一个包下面 3） 测试类的命名规则：假如目标类是Calculator，那么测试类应该命名为TestCalculator或者是CalculatorTest 2. Junit的口号：keep...
单元测试(JUnit)
sunny潘先生的博客
03-26 223
JUnit的知识点1 注释/元数据引入库类：import org.junit.;1. 说明@Before 初始化方法 @After 释放资源 @Test 测试方法，在这里可以测试期望异常和超时时间 @Ignore 忽略的测试方法； 当测试的方法还没有实现，或者测试的方法已经过时，或者在某种条件下才能测试该方法（比如需要一个数据库联接，而在本地测试的时候，数据库并没有连接），那么使用该标...
ecolipse单元测试Junit入门
04-22
好的，我能为您提供一些关于 Eclipse 单元测试 JUnit 的入门指南。JUnit是一个针对Java语言的单元测试框架，可以帮助开发者更方便高效地进行测试。以下是一些入门步骤： 1. 在 Eclipse 中创建一个新的 Java 项目或打开您已有的项目。 2. 在 package explorer 窗口中，右键单击您要进行单元测试的类名，选择“New” > “JUnit Test Case”。 3. 在弹出的对话框中，选择您要测试的类并指定生成的测试类的名称。点击“Next”。 4. 选择要包含在测试中的方法并指定相关的测试方法名称。点击“Finish”。 5. 在生成的测试类中，编写测试方法并执行测试。 希望这些信息可以帮助您入门 Eclipse 单元测试 JUnit。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值