快速入门单元测试-Junit5

已于 2022-11-08 15:54:27 修改
阅读量370 收藏 2
点赞数
分类专栏： 服务端 文章标签： 单元测试 junit
于 2022-11-03 00:31:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianpengfei123/article/details/127662083
版权

快速入门单元测试-Junit5

文章目录

1. 简介

本文可以让你快速了解Junit5一些特性，迅速掌握Junit5的一些概念。有些地方大家清楚特性就行，当我们使用到的时候，再去通过官网探究功能接口的详细使用尤其是其他章节的部分。

2. 测试的结构

在这里插入图片描述

​ 从这个测试案例我们开始介绍，看上图的测试里面我们可以介绍几个相关的概念。

  • @Test注解表示这个方法是一个测试方法。使用IDE的支持，可以直接点击小图标直接运行测试。值得一提的是，现在大部分的IDE和构建工具都对Junit5进行了支持。 @BeforeAll就是本测试类的测试方法运行之前进行运行，一般用于测试环境的准备
  • 测试方法和所在的测试类不能是私有，其他的都可以。
  • 断言：判断执行结果是否正确，比如：assertEquals

通过上面的案例我们来做几个定义

Lifecycle Method： 生命周期方法 一般用于测试用例前或者后执行的方法，比如@BeforeAll, @AfterAll, @BeforeEach, or @AfterEach.上面的setUp就是一个Lifecycle Method。

Test Class：包含测试方法的类，可以是顶层类、静态成员类、或者Nested类。这些类不能是抽象且必须有构造方法。上面的MyFirstJUnitJupiterTests就是一个Test Class

Test Method：可以当作测试案例执行的方法。上面的方法addition就是一个 Test Method

3. Lifecycle Method

对测试的环境的准备必不可少，Junit提供了四个注解修饰方法，让我们使用来对我们测试进行准备。

@BeforeEach

表示该方法在当前测试类（Test Class）的每个测试方法（Test Method）运行之前执行一遍，必须是非静态方法

@AfterEach

表示该方法在当前测试类（Test Class）的每个测试方法（Test Method）运行完成之后执行一遍，必须是非静态方法。

@BeforeAll

表示的是该方法应当在当前测试类（Test Class）中所有测试方法（Test Method）之前执行，默认情况下该方法必须是静态（static）的。

@AfterAll

表示的是该方法应当在当前测试类（Test Class）中所有测试方法（Test Method）执行完成之后执行，默认情况下该方法必须是静态（static）的。

用一个案例进行说明

class LifecycleMethodTests {


    @BeforeAll
    static void initAll() {
        println("init all test...");
    }

    @BeforeEach
    void init() {
        println("init each test...");
    }

    @Test
    void test_1() {
        println("execute test 1");
    }
    @Test
    void test_2() {
        println("execute test 2");
    }

    @AfterEach
    void tearDown() {
        println("tear down each test...");
    }

    @AfterAll
    static void tearDownAll() {
        println("tear down all test...");
    }


    static void println(String message){
        System.out.println(message);
    }
}

执行结果为：

init all test...
init each test...
execute test 1
tear down each test...
init each test...
execute test 2
tear down each test...
tear down all test...

4. 测试时的实例

有没有想过， @BeforeAll和AftereAll修饰的方法为什么是静态的？

Junit5考虑到测试方法之间独立性和避免人为的修改状态对测试造成副作用。Junit为每一个测试方法创建一个测试类的实例。

public class TestInstanceDemo {
    private final Calculator calculator = new Calculator();

    @BeforeAll
    static void  setUp(){
        System.out.println("start to test....");
    }

    @Test
    void addition() {
        System.out.println(this);
        assertEquals(2, calculator.add(1, 1));
    }

    @Test
    void division () {
        System.out.println(this);
        assertEquals(2, calculator.divide(4, 2));
    }
}

在这里插入图片描述

@BeforeAll和AftereAll 的目的测试方法共享一些什么，不同实例共享的话，就只能是类的状态了，只能是静态方法了。

我们可以通过@TestInstance注解，来让测试方法在统一实例下进行测试。---->@TestInstance(TestInstance.Lifecycle.PER_CLASS)

TestInstance.Lifecycle.PER_CLASS表示用一个此类的实例测试下面的测试方法,这时@BeforeAll和AftereAll就可以修饰非静态的方法了。

TestInstance.Lifecycle.PER_METHOD表示每一测试方法都有一个不同的当前测试类的实例（默认情况）。

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class TestInstanceDemo {
    private final Calculator calculator = new Calculator();

    @BeforeAll
    void  setUp(){
        System.out.println("start to test....");
    }

    @Test
    void addition() {
        System.out.println(this);
        assertEquals(2, calculator.add(1, 1));
    }

    @Test
    void division () {
        System.out.println(this);
        assertEquals(2, calculator.divide(4, 2));
    }
}

在这里插入图片描述

如果默认情况下使用非静态的就会报错

在这里插入图片描述

5. Test Method

测试方法，用于测试某个接口，直接可以运行的方法。

最简单最常用的是‘

5.1 Test

@Test修饰的方法为测试方法

示例：

	@Test
    void addition() {
        assertEquals(2, calculator.add(1, 1));
    }

5.2 Repeated Test

@RepeatedTest修饰的方法为测试方法。

这个是为了指定测试方法的执行次数。每一次执行效果就和@Test作用一样

public class RepeatedTestsSimpleDemo {
    @BeforeEach
    void beforeEach() {
        System.out.println("init each test...");
    }

    @RepeatedTest(3)
    void repeatedTest() {
        System.out.println("test...");
    }

    @AfterEach
    void tearDown() {
        System.out.println("tear down each test...");
    }

}

执行结果：

在这里插入图片描述

更多

5.3 Parameterized Test

@ParameterizedTest修饰的方法为测试方法。

此注解可以让我们的测试方法执行多次，但是可以使用不同的参数。必须配合@ValueSource注解。

public class ParameterizedTestDemo {

    @BeforeEach
    void beforeEach() {
        System.out.println("init each test...");
    }

    @ParameterizedTest
    @ValueSource(strings = { "racecar", "radar", "able was I ere I saw elba" })
    void palindromes(String candidate) {
        System.out.println("test...");
        assertTrue(StringUtils.isNotBlank(candidate));
    }

    @AfterEach
    void tearDown() {
        System.out.println("tear down each test...");
    }


}

执行结果：

在这里插入图片描述

更灵活详细的用法，请参考官方文档。

更多

5.4 Dynamic Test

我们的上面测试，在编译完成之后就是已经是固定的了。现在我们需要在运行时候，生成我们的测试。

​ 这时候我们使用**@TestFactory**注解，方法返回一个DynamicNode或者是它的Stream、Collection、Iterable,、Iterator，运行此方法就会生成我们一个个的测试并且执行。有点像生成测试的工厂，所以注解名字是TestFactory

举例：

	@TestFactory
    Stream<DynamicTest> dynamicTestsFromIntStream() {
        // Generates tests for the first 10 even integers.
        return IntStream.iterate(0, n -> n + 2).limit(10)
                .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0)));
    }

在这里插入图片描述

测试是我们运行时动态生成的。

更多

5.5 TestTemplate

不常用，略

更多

6. Nested Tests

为了更好描述测试之间的关系，比如有时候我们的测试的条件状态递进的，可以想象成一个状态树，每一个节点都有自己的测试状态。这样我们可以利用@Nested注解和java的NestClass,来更好描述描述测试层次结构。

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.EmptyStackException;
import java.util.Stack;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

@Nested修饰的类必须是非静态的内部类。默认上层的且同一条路线上的@BeforeEach and @AfterEach修饰的方法有效于下层的测试。默认情况下@Nested无中的@BeforeAll和@AfterAll无效，这是java本身的限制（java16之前不能在内部类里面有静态成员）。可使用@TestInstance(Lifecycle.PER_CLASS)进行避免，原理看测试时的对象

在这里插入图片描述

类的层次结构：

在这里插入图片描述

这里面的类都是测试类（Test Class）。

更多

7. 断言

断言之前我们描述过，就是判断我们的测试的执行结果是否正确

7.1 基本使用

Junit5本身提供了断言，来让我们进行判断测试结果是否正确。

assertEquals 判断相等，如果不相等则失败。

assertEquals(2, calculator.add(1, 1));

assertTrue：判断结果为True，如果不为True则失败。

assertTrue('a' < 'b')

assertNotNull：判断结果不为空，如果为空则失败。

assertNotNull(firstName);

assertTimeout：判断超时，如果超时，则失败。

assertTimeout(ofMinutes(2), () -> {
            // Perform task that takes less than 2 minutes.
        });

分组断言，就是把几个断言放在一个分组中

assertAll("person",
                () -> assertEquals("Jane", person.getFirstName(),"12"),
                () -> assertEquals("Doe", person.getLastName(),"12")
        );

如果失败了，设置失败的描述信息：

assertEquals(5, calculator.multiply(2, 2),
                "The optional failure message is now the last parameter");

org.opentest4j.AssertionFailedError: The optional failure message is now the last parameter ==> 
Expected :5
Actual   :4

在某些测试情况，我们功能模块是要抛出异常的，这也是功能的一部分，所以我们也需要对异常进行测试

void exceptionTesting() {
        Exception exception = assertThrows(ArithmeticException.class, () ->
                calculator.divide(1, 0));
        assertEquals("/ by zero", exception.getMessage());
}

7.2 三方库的断言

Junit的断言，有时候会让我们混淆哪里是期望值，那里是实际结果，比如assertEquals(2, calculator.add(1, 1));我们就比较容易混淆哪里放期望值哪里放实际结果值。

还有就是匹配条件不够灵活且描述性也不高。

所以我们可以使用第三方来进行补充，我们来看一个harmast来提供的断言，匹配条件。

 @Test
    void assertWithHamcrestMatcher() {
        assertThat(calculator.subtract(4, 1), is(equalTo(3)));
    }

我们就一眼看出，第一个参数是实际执行的结果，第二个参数就是对匹配条件的描述，可以看出第二参数描述性很强。

7.3 Void方法怎么测试

Void方法测试，我们可以使用Mockito框架，这是一个模拟依赖对象的框架，比如A模型依赖B模型,对A进行测试的时候，我们由于某些原因难以构建B模型，我们可以使用Mockito进行模拟一个B模型，来对A功能接口进行测试。

我们可以通过对模拟对象的一些接口的调用判断来测试我们的无返回值的接口。

实例：

@Test
void testAddItem(){
    B b = mock(B.class);
    A a = new A(b);
    service.doSomthing(parameter);
    verify(b).doSomething(any());
}

这样就可以测试到我们的功能实现了，但这也测试到了实现细节。测试到实现细节，有一个后果就是实现世界是不问稳定，同这样的功能今天这么么实现，明天那么实现，这就导致我们测试也得跟着改变。所以尽量少用verify。

更多

8. 其他

8.1 更好的描述

junit5 给我提供一个注解，来让我们更好的描述我们的测试类的测试方法，默认使用的是测试方法名称或者测试类的名称

@DisplayName

@DisplayName("A special test case")
class DisplayNameDemo {

    @Test
    @DisplayName("Custom test name containing spaces")
    void testWithDisplayNameContainingSpaces() {
    }

    @Test
    @DisplayName("╯°□°）╯")
    void testWithDisplayNameContainingSpecialCharacters() {
    }

    @Test
    @DisplayName("😱")
    void testWithDisplayNameContainingEmoji() {
    }

    @Test
    void testDefault(){
    }
    
}

在这里插入图片描述

还有很多有意思的使用方式，比如使用的是DisplayNameGenerator, 可以自定义使用什么方式生成测试的描述。比如 把测试类或者测试方法的名称中下划线替换成空格来当作测试的描述

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
 class A_year_is_not_supported {
	@Test
    void if_it_is_zero() {
      }
 }

在这里插入图片描述

更多

8.2 组合注解（Composed Annotations）

Junit提供的注解都是元注解（Meta-Annotations），我们可以使用这些元注解组合自己的注解形成组合注解。组合注解的语义继承这些元注解。

组合注解可以提高效率和可读性

比如我们不使用组合注解写法如下：

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
public @interface Fast {
}

@Fast
@Test
void myFastTest() {
    // ...
}

使用之后

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
@Test
public @interface FastTest {
}

@FastTest
void myFastTest() {
    // ...
}

上面是一样的效果。

8.3不测试、某种条件下测试

不测试，

由于某些原因不进行测试，使用@Disable

@Disabled("Disabled until bug #99 has been fixed")
class DisabledClassDemo {

    @Test
    void testWillBeSkipped() {
    }

}

class DisabledTestsDemo {

    @Disabled("Disabled until bug #42 has been resolved")
    @Test
    void testWillBeSkipped() {
    }

    @Test
    void testWillBeExecuted() {
    }

}

更多

某种条件下进行测试

这种条件可以是操作系统@EnabledOnOs、可以是java运行时环境EnabledOnJre、还可以是某个系统属性@EnabledIfSystemProperty，当然也可以自定义

@Test
@EnabledOnOs(MAC)
void onlyOnMacOs() {
    // ...
}

@TestOnMac
void testOnMac() {
    // ...
}

@Test
@EnabledOnOs({ LINUX, MAC })
void onLinuxOrMac() {
    // ...
}

@Test
@DisabledOnOs(WINDOWS)
void notOnWindows() {
    // ...
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Test
@EnabledOnOs(MAC)
@interface TestOnMac {
}

更多

8.4 测试的执行顺序

测试之间是相互独立的，所以测试的顺序不影响结果，但是测试顺序有时候也相当重要，尤其是集成测试的时候，比如对性能的影响等。Junit支持测试顺序的设置。相关注解@Order @TestClassOrder

更多

8.5 设置超时时间

**@Timeout(5) ** 可以添加到Lifecle Method 和Test Method上，执行的过程中，超时就报异常

更多

8.6 扩展（Extension）

如果Junit提供的接口，大部分都是注解，不能很好进行测试。我们可以自己通过扩展来实现自己想要的功能,例如Spring提供的SpringExtension,

使用方式@ExtendWith(CertainExtension.class)，Junit也提供了一些内置扩展

内置扩展

扩展模型

8.7 测试中使用接口和默认方法

@Test, @RepeatedTest, @ParameterizedTest, @TestFactory, @TestTemplate, @BeforeEach, and @AfterEach都可以修饰inteface中的default方法。

继承接口的类，也会把这些继承过去。

以打印测试日志场景举例

interface TestLifecycleLogger {

    Logger logger = Logger.getLogger(TestLifecycleLogger.class.getName());

    @BeforeAll
     static void beforeAllTests() {
        logger.info("Before all tests");
    }

    @AfterAll
    static void afterAllTests() {
        logger.info("After all tests");
    }

    @BeforeEach
    default void beforeEachTest(TestInfo testInfo) {
        logger.info(() -> String.format("About to execute [%s]",
                testInfo.getDisplayName()));
    }

    @AfterEach
    default void afterEachTest(TestInfo testInfo) {
        logger.info(() -> String.format("Finished executing [%s]",
                testInfo.getDisplayName()));
    }

}

public class TestLifecycleLoggerImplDemo implements TestLifecycleLogger{

    @RepeatedTest(10)
    void repeatedTest() {
        System.out.println("test...");
    }
}

在这里插入图片描述

还有一种情况，就是为某个接口的锲约写测试，比如Object.equals or Comparable.compareTo。遵守一定的规则，来测试他们到底遵守没有遵守。可在接口使用测试

更多

9. 总结

测试的结构里面有，Test Class Test Method 、Lifecycle Method、断言。

Test Class是我们测试所在的类，其中@Nested修饰的class会让测试更有表达性和层次，

Test Method是我们要运行的测试的方法，其中包含一些可多次执行的测试方法，执行可指定测试案例的测试方法

Lifecycle Method是我们在测试前后执行的方法，主要用于一些环境的准备和资源的释放

断言是判断测试执行是否正确，我们也可以使用第三方库的断言让判断更有表达性。

我们思考分析了为什么@BeforeAll和@AfterAll默认情况只能修饰静态方法，这和测试时生成的测试用例有关。Junit还有一些其他的特性,其中扩展让我们在测试中根据特定的场景使用一些外部的扩展功能，更加灵活。

在这里插入图片描述

10. 参考

JUnit 5 User Guide

愿凌飞
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Junit5单元测试框架详解
m0_63635730的博客
05-28 3312
Junit5单元测试框架详解
Junit5单元测试
weixin_43600910的博客
05-30 2283
单元测试 单元测试是代码正确性验证的最重要的工具，也是系统测试当中最重要的环节。在标准的开发过程中，单元测试的代码与实际程序的代码具有同等的重要性。单元测试是为了保证程序如期望的运行和获得结果，进行一些假定条件和假定结果的一种编程思维。 单元测试是为了提高代码质量和可维护性，保证模块修改后的兼容性，可以通过单元测试来判断一个模块在修改后是否与修改前保持兼容、多大程度上不兼容、影响范围有多大。开发者就可以更加专注于模块内部的业务。单元测试无法代替人工的工作，他能够做到的是衡量一个模块修改后会不会影响其他模块的
JUnit5-单元测试操作详解
最新发布
2401_83441752的博客
03-12 1708
JUnit5-单元测试操作详解
JUnit5单元测试(基于SpringBoot)
maogenb的博客
04-28 2281
SpringBoot2之单元测试（JUnit5） 1.JUnit版本的变迁（了解） 相信很多小伙伴们都用过JUnit4,但是自从SpringBoot 2.2.0 版本的出现，JUnit5就作为了单元测试的默认库。 毛哥(博主)我使用的SpringBoot2.6.7，默认的JUnit版本仲裁 5.8.2： 所以今天咱们就来聊聊最新版本JUnit5： JUnit5与之前版本(JUnit3/4)做了很大的改变。它由三个不同子项目的几个模块组成： JUnit Platform：Junit Platform是
单元测试框架——Junit5
weixin_46913665的博客
11-11 2401
单元测试是对软件中的最小可测试单元进行检查和验证的过程单元测试是开发者编写一小段代码，用于检验被测代码的一个很小的，很明确的（代码）功能是否正确，执行测试单元就是为了证明某段代码的执行结果是否符合我们的预期。如果测试结果符合我们的预期，称之为测试通过，否则就是测试不通过。编写代码时，我们往往会做出假设，断言用于判断这些假设为真还是为假。因此断言表示为布尔表达式。
《单元测试》Junit5入门教程——非常详细，入门即精通
雨水的早晨的博客
10-14 5512
junit5入门教程，junit5依赖，常用注解，套件测试
CppUnit测试框架入门
02-27
XUnit，一个基于测试驱动开发的测试框架，它为我们在开发过程中使用测试驱动开发提供了一个方便的工具，使我们得以快速的进行单元测试。XUnit的成员有很多，如JUnit，PythonUnit等。今天给大家介绍的CppUnit即是...
Spring MVC 教程 快速入门 深入分析
07-30
十三、如何给spring3 MVC中的Action做JUnit单元测试？ 十四、spring mvc 转发与重定向 十五、spring mvc 处理ajax请求 十六、spring mvc 关于写几个配置文件的说明 十七、spring mvc 如何取得Spring管理的bean 十八...
Android Studio JUnit基础
04-21
Android Studio单元测试快速入门
bourne-shell-unit-testing:单元测试Bourne Shell脚本，包括存根和模拟！
05-05
使用shunit2对Bash（或与Bourne兼容的任何版本）shell脚本进行单元测试，并完成存根和模拟（kinda）！ 被测试的脚本是modules/packages/freebsd_ports ，测试套件在tests/package_module.sh 。设置OS X和Homebrew的...
【SpringBoot深入浅出系列】SpringBoot之集成JUnit5进行单元测试
邓邓子的博客
02-25 3367
文章目录一、JUnit 5 是什么？JUnit PlatformJUnit JupiterJUnit Vintage二、为什么使用 JUnit 5 ？三、JUnit 4 和 JUnit 5 的区别1.导入2.@Test 注解3.超时写法发生变化4.其它注解5.断言6.假设7.扩展四、创建项目集成 JUnit5 进行单元测试1.项目说明2.创建 Spring Initializr 项目 junit（1）.添加依赖（2）.添加配置（3）.新建实体类 User（4）.新建控制类 LoginController3.
使用JUnit5进行单元测试
02-20
对于所有的Java开发人员来说，你可以没有听说过Spring或是Hibernate框架，但是一定听说过JUnit。JUnit作为Java单元测试的鼻祖与事实上的标准，在非常多的项目中被使用。即便新兴的单元测试框架，如TestNG等，不断出现，JUnit的重要性仍然是不言而喻的。目前广泛使用的是JUnit4版本，而JUnit即将迎来它的最新版本JUnit5。JUnit5在增加了很多的新特性的同时，又保持了对JUnit4的向后兼容性。本文对JUnit5进行了详细的介绍。与之前的版本不同，JUnit5由三个不同的模块组成。第一个模块是JUnit平台，其主要作用是在JVM上启动测试框架。它定义了一个抽
【软件测试开发】Junit5单元测试框架
xqs196301的博客
02-12 910
Junit5单元测试框架
JUnit 5单元测试（一）—— 基本配置
西凉的悲伤博客
03-16 2955
它会帮你执行如下过程 validate --> compile --> test --> package --> integration-test --> verify --> install ，也就是说它会帮你执行验证、编译、单元测试、打包、整合测试、最后再把生成的jar包发布到本地仓库，换句话说它会帮你执行 install 之前的所有操作，最后执行 install。它只会帮你把生成的jar包发布到本地仓库，也就是说它只会帮你执行 install ，其前面的操作它不会帮你执行。
JUnit5中@TestInstance(TestInstance.Lifecycle.PER_CLASS)
HD243608836的博客
09-18 5404
测试实例生命周期 为了允许隔离执行单个的测试方法，并避免由于可变测试实例状态而产生的意外副作用，JUnit在执行每个测试方法之前创建每个测试类的新实例（请参阅下面的讲解，何为测试方法）。这个”per-method”测试实例生命周期是JUnit Jupiter中的默认行为，类似于JUnit以前的所有版本。 如果您希望JUnit Jupiter在同一个测试实例上执行所有测试方法，只需使用@Test...
JUnit 5 单元测试教程
未读代码
11-18 1089
在 Java 中比较有名的测试工具是 JUnit ，通常我们使用 JUnit 可以对一个逻辑单元进行测试，因此也叫单元测试。多个单元测试组合测试，可以确保我们的程序符合预期。JUnit 单元测试可以在开发阶段发现问题，让我们可以提前修复代码，因此十分重要。
Junit5单元测试使用详解
孑辞的博客
10-19 1258
文章目录Junit5单元测试使用详解常用注解介绍功能含义对比Junit4测试控制流程maven依赖导入基本测试@Test示例参数化测试@ParameterizedTest示例@ValueSource单一参数测试@CsvSource多参数测试@MethodSource多参数测试@CsvFileSource文件参数测试 Junit5单元测试使用详解 常用注解介绍 功能含义 注解 功能 ...
ecolipse单元测试Junit入门
04-22
好的，我能为您提供一些关于 Eclipse 单元测试 JUnit 的入门指南。JUnit是一个针对Java语言的单元测试框架，可以帮助开发者更方便高效地进行测试。以下是一些入门步骤： 1. 在 Eclipse 中创建一个新的 Java 项目或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值