Java测试框架——JUnit详解(4&5)

这篇具有很好参考价值的文章主要介绍了Java测试框架——JUnit详解(4&5)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

JUnit是Java编程语言的单元测试框架,用于编写和运行可重复的自动化测试,也是当下主流的Java测试框架


前言

如果有对单元测试还不熟悉的小伙伴可以看一下我的这篇文章——浅谈单元测试,本文我们主要针对JUnit 来讲解Java中的常用单元测试关于JUnit4和5的区别可以参考这篇文章,从JUnit 4迁移到JUnit 5:重要的区别和好处。

何为JUnit?

JUint是Java编程语言的单元测试框架,用于编写和运行可重复的自动化测试

JUnit的好处(来自百度百科):

  1. 简单易用:JUnit 的 API 非常简单,开发人员可以轻松地编写和执行单元测试。

  2. 可维护:单元测试是可重复执行的,因此在修改代码时,可以通过运行单元测试来确保修改后的代码不会破坏已有的功能。

  3. 可扩展:JUnit 提供了一些扩展点,使开发人员可以根据自己的需要扩展它。

  4. 可集成:JUnit 可以与大多数流行的 Java IDE 和构建工具集成,开发人员可以在开发过程中轻松地执行单元测试。

  5. 社区支持:JUnit 拥有庞大的用户群和开发团队,因此如果遇到问题,可以得到很好的帮助。

官方资料

学习一个东西,最好的办法就是去看官方文档:
junit4 junit5,开发种的代码质量,junit,java,单元测试
junit4官网
junit5官网

下面我根据官网和自己常用测试,来讲解JUnit

JUnit4

常用注解和断言

junit4 junit5,开发种的代码质量,junit,java,单元测试
junit4 junit5,开发种的代码质量,junit,java,单元测试

代码测试搭建一个JUnit测试环境

这是一个springboot项目,为了后续的SpringBoot2+H2+Mockito测试,读者也可以做一个maven项目

项目搭建:
maven包引入

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

完整pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test</name>
    <description>test</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
    		
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

测试@Test
junit4 junit5,开发种的代码质量,junit,java,单元测试

package com.example.test;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */

public class HelloWorldTest {
    @Test
    public void test(){
        assertEquals(4, 1 + 3);
    }
}

执行结果:
junit4 junit5,开发种的代码质量,junit,java,单元测试
@Test注解在方法上标记方法为测试方法,以便构建工具和 IDE 能够识别并执行它们。JUnit 4 需要测试方法为public,这和Junit 5 有差别。

生命周期

@Before,@BeforeClass,@After,@AfterClass

junit4 junit5,开发种的代码质量,junit,java,单元测试

package com.example.test;

import org.junit.*;
/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class LifeCycleTest {
    @BeforeClass
    public static void beforeClass() {
        System.out.println("in before class");
    }

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

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

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

    @Test
    public void testCase1() {
        System.out.println("in test case 1");
    }

    @Test
    public void testCase2() {
        System.out.println("in test case 2");
    }
}

junit4 junit5,开发种的代码质量,junit,java,单元测试

忽略测试

package com.example.test;

import org.junit.Test;
import org.junit.Ignore;
/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class IgnoreTest {
    @Ignore
    @Test
    public void Ignore(){
        System.out.println("IgnoreTest...");
    }
}

junit4 junit5,开发种的代码质量,junit,java,单元测试

断言测试

junit4 junit5,开发种的代码质量,junit,java,单元测试
我们简单测试三个方法,后面的读者有兴趣可以自行测试,代码如下:

package com.example.test;

import org.junit.Assert;
import org.junit.Test;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class AssertionTest {
    @Test
    public void AssertionT(){
        Assert.assertEquals(1,1);
        Assert.assertTrue(true);
        Assert.assertFalse(false);
    }
}

junit4 junit5,开发种的代码质量,junit,java,单元测试

异常测试

@Test注解还提供了追踪异常的选择,expected 参数和 @Test 注释一起使用。

@Test(expected):用来指示期望抛出的异常类型。

如果有读者不知道Java中异常的类型可以参考我之前写过的这篇文章:java处理异常这一篇就够了

package com.example.test;

import org.junit.Test;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class AbnormalTest {
    @Test(expected = NullPointerException.class)
    public void Abnomal(){
        int a = 0;
        System.out.println(1/a);
    }
}

junit4 junit5,开发种的代码质量,junit,java,单元测试

测试时间

简单的来说,就是JUnit中提供了一个如果测试时间超时的时候,也默认是测试失败,这个时间我们可以自己指定,@Test(timeout)

package com.example.test;

import org.junit.Test;

import java.util.concurrent.TimeUnit;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class TimeTest {
    @Test(timeout = 1000)
    public void time() throws InterruptedException {
        //time为毫秒
        
        //暂停时间
        TimeUnit.SECONDS.sleep(5000);
        System.out.println("in timeout exception");
    }
}

junit4 junit5,开发种的代码质量,junit,java,单元测试

套件测试

指捆绑了几个单元测试用例并运行起来,JUnit中,@RunWith和@Suite是用来运行套件测试的

package com.example.test.kit;

import org.junit.Test;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class Test1 {
    @Test
    public void printMessage(){
        System.out.println("Test1");
    }
}

package com.example.test.kit;

import org.junit.Test;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
public class Test2 {
    @Test
    public void printMessage(){
        System.out.println("Test2");
    }
}

package com.example.test.kit;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

/**
 * @Author 秋名山码神
 * @Date 2023/1/2
 * @Description
 */
@RunWith(Suite.class)
@Suite.SuiteClasses({

        //此处类的配置顺序会影响执行顺序

        Test1.class,
        Test2.class
})
public class Test {

}

junit4 junit5,开发种的代码质量,junit,java,单元测试

JUnit5

熟悉JUnit4,转变到JUnit5是十分容易的,并且JUnit 5可以使用Vintage库运行JUnit 4测试,这意味着对于JUnit4的项目你可以不用迁移测试,从而继续使用JUnit4的测试代码。

JUnit5对比JUnit4的好处

  • JUnit 5利用了Java 8或更高版本的特性,例如lambda函数,使测试更强大,更容易维护。
  • JUnit 5为描述、组织和执行测试添加了一些非常有用的新功能。例如,测试得到了更好的显示名称,并且可以分层组织。
  • JUnit 5被组织成多个库,所以只将你需要的功能导入到你的项目中。通过Maven和Gradle等构建系统,包含合适的库很容易。
  • JUnit 5可以同时使用多个扩展,这是JUnit 4无法做到的(一次只能使用一个runner)。这意味着你可以轻松地将Spring扩展与其他扩展(如你自己的自定义扩展)结合起来。

JUnit4 转变到JUnit5

  1. 将你的库和构建系统从JUnit 4更新到JUnit 5。确保在你的测试运行时路径中包含 junit-vintage-engine 工件,以允许你现有的测试执行。
  2. 使用新的JUnit 5构造开始构建新的测试。
  3. (可选)将JUnit测试用例转换为JUnit 5的测试用例。

导包的改变

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.1</version>
    <scope>test</scope>
</dependency>

JUnit 5 使用新的 org.junit.jupiter 包。例如,org.junit.junit.Test变成了org.junit.jupiter.api.Test。

注解的改变

junit4 junit5,开发种的代码质量,junit,java,单元测试
首先我们发现名称进行了改变,@Before变成了@BeforeEach等等……

其中@Test还将不再支持参数,这意味这JUnit4中,@Test(expected = Exception.class),不再支持,替换为:

@Test(expected = Exception.class)
public void testThrowsException() throws Exception {
    // ...
    //4
}
@Test
void testThrowsException() throws Exception {
    Assertions.assertThrows(Exception.class, () -> {
        //...
        //5
    });
}

扩展JUnit

在JUnit5中提供了@ExtendWith 注解,是可重复的,例如在JUnit4中添加Spring框架构建测试:

@RunWith(SpringJUnit4ClassRunner.class)
public class MyControllerTest {
    // ...
}

而在JUnit5中:

@ExtendWith(SpringExtension.class)
class MyControllerTest {
    // ...
}

新功能:

显示名称。使用JUnit 5,你可以在类和方法中添加@DisplayName注释。这个名称在生成报告时使用,这使得描述测试的目的和追踪失败更容易,比如说:

@DisplayName("Test MyClass")
class MyClassTest {
    @Test
    @DisplayName("Verify MyClass.myMethod returns true")
    void testMyMethod() throws Exception {    
        // ...
    }
}

断言:
断言。JUnit 5引入了一些新的断言,比如以下这些:

assertIterableEquals()使用equals()对两个迭代项进行深度验证。
assertLinesMatch()验证两个字符串列表是否匹配;它接受期望参数中的正则表达式。
assertAll() 将多个断言分组在一起。附加的好处是所有的断言都会被执行,即使单个断言失败。
assertThrows()和 assertDoesNotThrow()取代了 @Test 注释中的预期属性。


嵌套测试。JUnit 4中的测试套件是很有用的,但JUnit 5中的嵌套测试更容易设置和维护,它们能更好地描述测试组之间的关系,比如说:

@DisplayName("Verify MyClass")
class MyClassTest {
    MyClass underTest;

    @Test
    @DisplayName("can be instantiated")
    public void testConstructor() throws Exception {    
        new MyClass();
    }
    @Nested
    @DisplayName("with initialization")
    class WithInitialization {
        @BeforeEach
        void setup() {
            underTest = new MyClass();
            underTest.init("foo");
        }

        @Test
        @DisplayName("myMethod returns true")
        void testMyMethod() {
            assertTrue(underTest.myMethod());
        }
    }
}

测试的参数化
测试参数化在JUnit 4中就已经存在,有内置的库如JUnit4Parameterized或第三方库如JUnitParams等。在JUnit 5中,参数化测试完全内置,并采用了JUnit4Parameterized和JUnitParams等一些最好的特性。例子:

@ParameterizedTest
@ValueSource(strings = {"foo", "bar"})
@NullAndEmptySource
void myParameterizedTest(String arg) {
    underTest.performAction(arg);
}

其格式看起来像JUnitParams,其中参数直接传递给测试方法。注意,要测试的值可以来自多个不同的来源。这里,我只用了一个参数,所以使用@ValueSource很方便。@EmptySource和@NullSource分别表示你要在要运行的值列表中添加一个空字符串和一个空值(如果你使用这两个值,你可以把它们组合在一起,如上所示)。还有其他多个值源,比如@EnumSource和@ArgumentsSource(一种自定义值提供者)。如果你需要一个以上的参数,也可以使用@MethodSource或@CsvSource。

在JUnit 5中添加的另一个测试类型是@RepeatedTest,在这里,一个测试被重复指定次数的测试。


最后还是建议大家参考一下:junit5官网

参考文章

网络:
https://blog.csdn.net/qq_34264849/article/details/88243278
https://zhuanlan.zhihu.com/p/144763642文章来源地址https://www.toymoban.com/news/detail-796563.html

到了这里,关于Java测试框架——JUnit详解(4&5)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • TestNG和Junit5测试框架梳理

    1. testNG优势 2. testNG常用注解 3. testNG中@Test有哪些参数 举例: 4.  在 TestNG 中实现参数化测试 以Yaml文件为例 创建一个Yaml文件testdata.yaml 获取测试数据及使用 5. 执行顺序 6. testNG断言 7. 失败重试 1. junit5的优势 2. 常用注解 3. TestFactory使用示例 TestFactory其实就是参数化执行同一条

    2024年02月13日
    浏览(37)
  • SpringBoot单元测试--Mockito+Junit5框架使用

    作为程序员为了提前发现代码bug,优化代码; 通常我们写完某个功能模块代码后都需要写单元测试对代码块进行测试(特别是敏捷开发中);Java项目最常用的单元测试框架即为Junit(目前最新版本为Junit5),SpringBoot本身也整合了该框架。在写单元测试时代码块中的调到第三方接口方

    2024年02月02日
    浏览(47)
  • JUnit5-单元测试操作详解

    JUnit 5是JUnit测试框架的下一个主要版本,用于编写和运行单元测试。 与以前版本的 JUnit 不同,JUnit 5 由来自三个不同子项目的多个不同模块组成。 JUnit 5 =  JUnit 平台 +  JUnit Jupiter  +  JUnit Vintage JUnit 平台 是在 JVM 上启动测试框架的基础。它还定义了 TestEngine 用于开发在平台

    2024年04月10日
    浏览(53)
  • Junit5+Mockito单元测试详解

    1.宏观层面:AIR原则 A:Automatic(自动化) 全自动执行,输出结果无需人工检查,而是通过断言验证。 I:Independent(独立性) 分层测试,各层之间不相互依赖。 R:Repeatable(可重复) 可重复执行,不受外部环境( 网络、服务、中间件等)影响。 2.微观层面:BCDE原则 B: Bord

    2024年01月17日
    浏览(48)
  • Java高级技术 单元测试(JUnit4)

    所谓单元测试,就是针对最小的功能单元,编写测试代码对其进行正确性测试。 我们之前一直使用的测试便是通过main方法来实现,但在main方法中写测试代码有如下的几个问题存在: 只能在main方法编写测试代码,去调用其他方法进行测试。 无法实现自动化测试,一个方法测

    2024年02月03日
    浏览(52)
  • 在 Java 中使用JUnit5进行单元测试和自动化测试

    单元测试和自动化测试是现代软件开发过程中必不可少的环节,可以提高代码质量和开发效率。JUnit5是Java中流行的单元测试框架,本文将介绍如何在Java中使用JUnit5进行单元测试和自动化测试。 2.1 单元测试的基本概念和原理 单元测试是一种测试方法,用于对软件系统中的最

    2024年02月03日
    浏览(46)
  • Java测试框架——JUnit详解(4&5)

    JUnit是Java编程语言的单元测试框架,用于编写和运行可重复的自动化测试,也是当下主流的Java测试框架 如果有对单元测试还不熟悉的小伙伴可以看一下我的这篇文章——浅谈单元测试,本文我们主要针对 JUnit 来讲解Java中的常用单元测试 关于JUnit4和5的区别可以参考这篇文章

    2024年01月17日
    浏览(35)
  • 如何在 Java 中使用JUnit5进行单元测试和自动化测试

    单元测试和自动化测试是现代软件开发过程中必不可少的环节,可以提高代码质量和开发效率。JUnit5是Java中流行的单元测试框架,本文将介绍如何在Java中使用JUnit5进行单元测试和自动化测试。 单元测试是一种测试方法,用于对软件系统中的最小可测试单元进行测试。这些单

    2024年02月05日
    浏览(58)
  • 【单元测试】Junit 4(三)--Junit4断言

    ​ **断言(assertion)**是一种在程序中的一阶逻辑(如:一个结果为真或假的逻辑判断式),目的为了表示与验证软件开发者预期的结果——当程序执行到断言的位置时,对应的断言应该为真。若断言不为真时,程序会中止执行,并给出错误信息。 这里我们直接上例子 接下来我们

    2024年02月08日
    浏览(52)
  • springboot框架(2):整合junit4

    junit用于单元测试。 新建springboot项目(不依赖任何插件,所以不需要选择任何插件) 引入test依赖(新建项目自动引入了这个依赖,如果没有这个依赖,才需要添加) 高版本的springboot(例如:2.6.5)只有junit5没有引入junit4,所以需要导入依赖(如果出现import灰色时,请检查是不是需要导

    2023年04月26日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包