精华内容
下载资源
问答
  • junit5
    万次阅读
    2022-07-23 14:37:35

    junit5 的变化

    junit5 由三个不同子项目的几个不同模块组成。
    junit5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

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

    junit5 常用注解

    • @Test :表示方法是测试方法。但是与JUnit4的@Test不同,他的职责非常单一不能声明任何属性,拓展的测试将会由Jupiter提供额外测试
    • @ParameterizedTest :表示方法是参数化测试,下方会有详细介绍
    • @RepeatedTest :表示方法可重复执行,下方会有详细介绍
    • @DisplayName :为测试类或者测试方法设置展示名称
    • @BeforeEach :表示在每个单元测试之前执行 注解的⽅法不得为静态⽅法,否则它将引发运⾏时错误。
    • @AfterEach :表示在每个单元测试之后执行
    • @BeforeAll :表示在所有单元测试之前执行 注解的⽅法必须为静态⽅法,否则它将引发运⾏时错误。
    • @AfterAll :表示在所有单元测试之后执行
    • @Tag :表示单元测试类别,类似于JUnit4中的@Categories
    • @Disabled :表示测试类或测试方法不执行,类似于JUnit4中的@Ignore
    • @Timeout :表示测试方法运行如果超过了指定时间将会返回错误
    • @ExtendWith :为测试类或测试方法提供扩展类引用
    更多相关内容
  • JUnit 5 用户指南中文版 junit5 User Guide Chinese document JUnit 5 用户指南中文版 junit5 User Guide Chinese document JUnit 5 用户指南中文版 junit5 User Guide Chinese document ...
  • 目前广泛使用的是JUnit4版本,而JUnit即将迎来它的最新版本JUnit5JUnit5在增加了很多的新特性的同时,又保持了对JUnit4的向后兼容性。本文对JUnit5进行了详细的介绍。与之前的版本不同,JUnit5由三个不同的模块...
  • JUnit Jupiter是JUnit5扩展的新的编程模型和扩展模型,用来编写测试用例。Jupiter子项目为在平台上运行Jupiter的测试提供了一个TestEngine (测试引擎)。 JUnit Vintage提供了一个在平台上运行JUnit 3和JUnit 4的...
  • Junit5.zip

    2020-01-13 17:11:25
    此资源包含了junit5的jar包和源码,junit5-r5.4.0.zip 和demo的zip文件,对于测试来说是比较有用的
  • JUnit 5 网上都没有说需要哪些jar包,我自己搞了好久才找到,最基本的4个包,都是最新的5版本,导入这4个就可以用junit5了,不然每次都得下载
  • junit5jar包,从官网下的。放到这里,需要的可以下载,当然也可以从官网下载,这里下载会方便一些
  • JUnit 5 所需要的 JUnit Platform 依赖包,主要版本包含:junit-platform-launcher-1.4.2.jar,junit-platform-launcher-1.5.0.jar,junit-platform-launcher-1.5.1.jar,junit-platform-testkit-1.4.2.jar,junit-...
  • JUnit 5.pdf

    2020-06-17 16:20:20
    JUnit 5中文学习文档。JUnit 5JUnit的下一代。目标是为JVM上的开发人员端测试创建一个最新的基础。这包括专注于Java 8及更高版 本,以及启用许多不同风格的测试。
  • Junit5 jar包

    2018-06-13 18:26:49
    Junit5的jar包,可用来测试Lambda表达式等。
  • JUnit 5 User Guide 中文版

    2018-01-01 12:25:25
    JUnit 5官方用户指南(http://junit.org/junit5/docs/current/user-guide)的中文翻译(http://sjyuan.cc/junit5/user-guide-cn)
  • SpringBoot 单元测试——JUnit5

    千次阅读 2022-04-19 22:06:40
    目录 1、JUnit5概述 1.1、JUnit5 构成 1.2、JUnit5 配置 1.2.1、导入 Junit5 开发场景 1.2.2、Junit5 开发场景自动导入依赖项 2、JUnit5 使用 2.1、Jnuit5 测试代码开发 2.1.1、测试代码格式 2.1.2、测试样例 2.2、...

    目录

    1、JUnit5概述

    1.1、JUnit5 构成

    1.2、JUnit5 配置

    1.2.1、导入 Junit5 开发场景

     1.2.2、Junit5 开发场景自动导入依赖项

    2、JUnit5 使用

    2.1、Jnuit5 测试代码开发

    2.1.1、测试代码格式

    2.1.2、测试样例 

    2.2、JUnit5常用注解

     2.2.1、@Test :表示方法是测试方法。

     2.2.2、@DisplayName :为测试类或者测试方法设置展示名称

     2.2.3、@BeforeEach、@AfterEach、@BeforeAll、@AfterAll

     2.2.4、@Disabled :表示测试类或测试方法不执行

     2.2.5、@Timeout :表示测试方法运行如果超过了指定时间将会返回错误

     2.2.6、@RepeatedTest :表示方法可重复执行

     2.2.7、其他注解

    2.3、Jnuit5 断言(assertions)

     2.3.1、简单断言

     2.3.2、数组断言

     2.3.3、组合断言

     2.3.4、异常断言

     2.3.5、超时断言

     2.3.6、快速失败

    2.4、前置条件

    2.5、嵌套测试

    2.6、参数化测试


    1、JUnit5概述

    1.1、JUnit5 构成

     JUnit5 由三个不同子项目的几个不同模块组成。

    JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

     1)JUnit Platform: 是在JVM上启动测试框架的基础,不仅支持Junit自制的测试引擎,其他测试引擎也都可以接入。

     2)JUnit Jupiter: 提供了JUnit5的新的编程模型,是JUnit5新特性的核心。内部包含了一个测试引擎,用于在Junit Platform上运行。

     3)JUnit Vintage: 由于JUint已经发展多年,为了照顾老的项目,其提供了兼容JUnit4.x,Junit3.x的测试引擎。

    1.2、JUnit5 配置

    1.2.1、导入 Junit5 开发场景

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

     1.2.2、Junit5 开发场景自动导入依赖项

     

    2、JUnit5 使用

    2.1、Jnuit5 测试代码开发

    2.1.1、测试代码格式

     @SpringBootTest注解:添加在需要依赖springboot框架的测试类上,

                                            不然不能使用Springboot的相关开发功能

    @Test注解:添加在测试方法上

    @SpringBootTest
    class Boot05WebAdminApplicationTests {
    
        @Test
        void contextLoads() {
    
        }
    }
    

    2.1.2、测试样例 

    @Slf4j
    @SpringBootTest
    class SpringBootThymeleafApplicationTests {
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
        @Autowired
        UserMapper userMapper;
    
        @Autowired
        StringRedisTemplate redisTemplate;
    
        @Test
        void contextLoads() {
            Long along = jdbcTemplate.queryForObject("select count(*) from account", long.class);
            log.info("记录总数{}", along);
            log.info("数据源类型{}", dataSource.getClass());
        }
    
        @Test
        void testUserMapper() {
            User user = userMapper.selectById(1);
            log.info("用户信息{}", user);
        }
    
        @Test
        void testRedis() {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
    
            operations.set("hello", "world");
    
            String hello = operations.get("hello");
            System.out.println(hello);
        }
    }
    

    2.2、JUnit5常用注解

     2.2.1、@Test :表示方法是测试方法。

    @SpringBootTest
    class Boot05WebAdminApplicationTests {
    
        @Test
        void contextLoads() {
    
        }
    }
    

     2.2.2、@DisplayName :为测试类或者测试方法设置展示名称

     测试代码:

    @DisplayName("junit5功能测试")
    public class Junit5Test {
    
        @DisplayName("测试displayname注解")
        @Test
        void testDisplayName() {
            System.out.println(1);
        }
    }
    

     输出结果:

     2.2.3、@BeforeEach、@AfterEach、@BeforeAll、@AfterAll

     注解功能:

    注解功能

    @BeforeEach

    表示在每个单元测试之前执行

    @AfterEach

    表示在每个单元测试之后执行

    @BeforeAll

    表示在所有单元测试之前执行

    @AfterAll

    表示在所有单元测试之后执行

     测试代码: 

    @SpringBootTest
    @DisplayName("junit5功能测试")
    public class Junit5Test {
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        /**
         * 测试前置条件
         */
        @DisplayName("测试前置条件")
        @Test
        void testAssumptions() {
            Assumptions.assumeTrue(false, "结果不足true");
            System.out.println("11111");
        }
    
        @DisplayName("测试displayname注解")
        @Test
        void testDisplayName() {
            System.out.println(1);
        }
    
        @Disabled
        @DisplayName("测试2")
        @Test
        void test2() {
            System.out.println(2);
            System.out.println(jdbcTemplate.getClass());
        }
    
        @BeforeEach
        void testBeforeEach() {
            System.out.println("测试就要开始。。。");
        }
    
        @AfterEach
        void testAfterEach() {
            System.out.println("测试就要结束。。。");
        }
    
        @BeforeAll
        static void testBeforeAll() {
            System.out.println("所有测试就要开始。。。");
        }
    
        @AfterAll
        static void testAfterAll() {
            System.out.println("所有测试已经结束。。。");
        }
    }
    

     输出结果: 

     2.2.4、@Disabled :表示测试类或测试方法不执行

     测试代码:

        @Disabled
        @DisplayName("测试2")
        @Test
        void test2() {
            System.out.println(2);
            System.out.println(jdbcTemplate.getClass());
        }

     2.2.5、@Timeout :表示测试方法运行如果超过了指定时间将会返回错误

     测试代码:设置执行时间为500ms,超时报错

        @Test
        @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
        void testTimeOut() throws InterruptedException {
            Thread.sleep(520);
        }
    

     返回结果:

     2.2.6、@RepeatedTest :表示方法可重复执行

     测试代码:

        @RepeatedTest(5)    //重复测试5次
        @DisplayName("测试3")
        @Test
        void test3() {
            System.out.println(3);
            System.out.println(jdbcTemplate.getClass());
        }

     执行结果:

     

     2.2.7、其他注解

     @ParameterizedTest :表示方法是参数化测试

     @Tag :表示单元测试类别

     @ExtendWith :为测试类或测试方法提供扩展类引用

    2.3、Jnuit5 断言(assertions)

    • 检查业务逻辑返回的数据是否合理。
    • 所有的测试运行结束以后,会有一个详细的测试报告;

     2.3.1、简单断言

     1)简单断言功能:

    方法

    说明

    assertEquals

    判断两个对象或两个原始类型是否相等

    assertNotEquals

    判断两个对象或两个原始类型是否不相等

    assertSame

    判断两个对象引用是否指向同一个对象

    assertNotSame

    判断两个对象引用是否指向不同的对象

    assertTrue

    判断给定的布尔值是否为 true

    assertFalse

    判断给定的布尔值是否为 false

    assertNull

    判断给定的对象引用是否为 null

    assertNotNull

    判断给定的对象引用是否不为 null

     2)测试代码:

    @SpringBootTest
    @DisplayName("junit5功能测试")
    public class Junit5Test {
        @DisplayName("测试简单断言")
        @Test
        void testSimpleAssertions() {
            int call = call(1,2);
            assertEquals(2, call, "业务逻辑计算失败");
    
            Object obj1 = new Object();
            Object obj2 = new Object();
            assertSame(obj1, obj2, "两个对象不一样");
        }
    
        int call (int x, int y) {
            return x + y;
        }
        }
    }
    

     3)测试结果:

     2.3.2、数组断言

     通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等

     测试代码:

    @Test
    @DisplayName("array assertion")
    public void array() {
     assertArrayEquals(new int[]{1, 2}, new int[] {1, 2});
    }

     2.3.3、组合断言

    • assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言

      • 可以通过 lambda 表达式很容易的提供这些断言

      • 前边断言失败,后续代码不会执行 

      • 组合断言,当组合中的所有断言都通过才是true,否则是false

     测试代码:

    @Test
    @DisplayName("assert all")
    public void all() {
     assertAll("Math",
        () -> assertEquals(2, 1 + 1),
        () -> assertTrue(1 > 0)
     );
    }

     2.3.4、异常断言

     JUnit5提供了Assertions.assertThrows() ,配合函数式编程就可以进行使用。

        @Test
        @DisplayName("异常断言")
        public void exceptionTest() {
            ArithmeticException exception = Assertions.assertThrows(
                    //扔出断言异常
                    ArithmeticException.class, () -> System.out.println(1 % 0));
    
        }

     2.3.5、超时断言

     Junit5提供了Assertions.assertTimeout() 为测试方法设置了超时时间

    @Test
    @DisplayName("超时测试")
    public void timeoutTest() {
        //如果测试方法时间超过1s将会异常
        Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
    }

     2.3.6、快速失败

    • 当满足某一条件,需要退出测试程序时,可以使用快速失败方法
    • 当调用快速失败方法时,程序会退出,同时输出失败提示
    @Test
    @DisplayName("fail")
    public void shouldFail() {
     fail("This should fail");
    }

    2.4、前置条件

    • JUnit 5 中的前置条件(assumptions【假设】)类似于断言,
    • 不满足的断言会使得测试方法失败,而不满足的前置条件只会使得测试方法的执行终止
    • 前置条件可以看成是测试方法执行的前提,当该前提不满足时,就没有继续执行的必要。

     测试代码:

    @SpringBootTest
    @DisplayName("junit5功能测试")
    public class Junit5Test {
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        /**
         * 测试前置条件
         */
        @DisplayName("测试前置条件")
        @Test
        void testAssumptions() {
            Assumptions.assumeTrue(false, "结果不足true");
            System.out.println("11111");
        }
    }

    返回结果:

            1.当不满足前置条件时,后续输出代码未执行

            2.当不满足前置条件时,程序未报错退出,而是终止执行

    2.5、嵌套测试

    • JUnit 5 可以通过 Java 中的内部类和@Nested 注解实现嵌套测试
    • 将相关的测试方法组织在一起。
    • 在内部类中可以使用@BeforeEach 和@AfterEach 注解,而且嵌套的层次没有限制。

     注意:

     1.外层测试方法的执行,不会驱动内层方法:

        当内层方法中有 before 或 after 等注解时,调用外层测试方法,并不会驱动其提前或最后执行

     2.内层方法的执行,可以驱动外层方法:

        当外层方法定义了某一数据结果时,内层测试方法可以直接调用该结构

     测试代码:

    @DisplayName("嵌套测试")
    public class TestingAstackDemo {
    
        Stack<Object> stack;
    
        @ParameterizedTest
        @DisplayName("参数化测试")
        @ValueSource(ints = {1, 2, 3, 4, 5})
        void testParamterized(int i) {
            System.out.println(i);
        }
    
        @ParameterizedTest
        @DisplayName("参数化方法测试")
        @MethodSource("stringProvider")
        void testParamterized2(String s) {
            System.out.println(s);
        }
    
        static Stream<String> stringProvider() {
            return Stream.of("apple", "banana");
        }
    
        @Test
        @DisplayName("is instantiated with new Stack()")
        void isInstantiatedWithNew() {
            new Stack<>();
            //在嵌套测试情况下,外层的test不能驱动内层
            //的beforeall等方法,在提前/之后运行
            //内层的test可以驱动外层
    //        assertNotNull(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());
                }
            }
        }
    }
    

    2.6、参数化测试

     1)参数化测试,可以指定测试方法的输入参数

     2)参数化测试的注解类型:

    注解

    功能

    @ValueSource

    为参数化测试指定入参来源,支持八大基础类以及String类型,Class类型

    @NullSource

    表示为参数化测试提供一个null的入参

    @EnumSource

    表示为参数化测试提供一个枚举入参

    @CsvFileSource

    表示读取指定CSV文件内容作为参数化测试入参

    @MethodSource

    表示读取指定方法的返回值作为参数化测试入参(方法的返回值为流)

     测试代码:

            1)入参为基础类型

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

             2)入参为方法返回值类型

        @ParameterizedTest
        @DisplayName("参数化方法测试")
        @MethodSource("stringProvider")
        void testParamterized2(String s) {
            System.out.println(s);
        }
    
        static Stream<String> stringProvider() {
            return Stream.of("apple", "banana");
        }

    展开全文
  • 1. JUnit 5开发人员指南 2. GitHub存储库 3.重要的Java开发人员指南 Spring开发人员指南 Maven开发人员指南 4. JUnit 4与JUnit 5的备忘单 ... https://github.com/RameshMF/ebooks/blob/master/junit5-user-guide.pdf
  • junit5教程_JUnit5教程

    千次阅读 2020-07-12 11:44:52
    junit5教程 JUnit5教程 (JUnit5 Tutorial) In this Junit tutorial, we will introduce basics of JUnit5 and its new features using examples. In Java world, JUnit is one of the popular framework used to ...

    junit5教程

    JUnit5教程 (JUnit5 Tutorial)

    In this Junit tutorial, we will introduce basics of JUnit5 and its new features using examples. In Java world, JUnit is one of the popular framework used to implement unit tests against java code. JUnit primarily helps developers to test their code on the JVM by themselves.

    在本Junit教程中,我们将通过示例介绍JUnit5的基础知识及其新功能。 在Java世界中,JUnit是用于对Java代码实施单元测试的流行框架之一。 JUnit主要帮助开发人员自己在JVM上测试其代码。

    JUnit5架构 (JUnit5 Architecture)

    JUnit平台 (JUnit Platform)

    • Launches testing frameworks on the JVM

      在JVM上启动测试框架
    • Has TestEngine API used to build a testing framework that runs on the JUnit platform

      使用TestEngine API来构建在JUnit平台上运行的测试框架

    JUnit木星 (JUnit Jupiter)

    • Blend of new programming model for writing tests and extension model for extensions

      混合了用于编写测试的新编程模型和用于扩展的扩展模型
    • Addition of new annotations like @BeforeEach, @AfterEach, @AfterAll, @BeforeAll etc.

      添加新的注释,例如@BeforeEach@AfterEach@AfterAll@BeforeAll等。

    JUnit复古 (JUnit Vintage)

    • Provides support to execute previous JUnit version 3 and 4 tests on this new platform

      提供支持以在此新平台上执行以前的JUnit版本3和4测试

    JUnit Maven依赖关系 (JUnit Maven Dependencies)

    To implement JUnit5 based test cases in a project, add the following dependency to the pom.xml file of the project:

    要在项目中实现基于JUnit5的测试用例,请将以下依赖项添加到项目的pom.xml文件中:

    • JUnit 5 Library

      JUnit 5库
    <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-engine</artifactId>
         <version>5.1.1</version>
         <scope>test</scope>
    </dependency>
    <dependency>
         <groupId>org.junit.platform</groupId>
         <artifactId>junit-platform-runner</artifactId>
         <version> 1.1.1</version>
         <scope>test</scope>
    </dependency>
    • JUnit5 maven surefire provider to execute the unit tests where IDE does not have JUnit5 support (if IDE has support then this point is not required)

      JUnit5 maven surefire提供程序在IDE不支持JUnit5的情况下执行单元测试(如果IDE支持,则不需要这一点)
    • <plugin>
           <artifactId>maven-surefire-plugin</artifactId>
           <version>2.19.1</version>
           <dependencies>
                <dependency>
                     <groupId>org.junit.platform</groupId>
                     <artifactId>junit-platform-surefire-provider</artifactId>
                     <version>1.0.2</version>
                </dependency>
           </dependencies>
      </plugin>

      JUnit5的新功能 (JUnit5 New Features)

      It requires Java 8 or higher at runtime. But one can still test code which is compiled using previous Java versions. There are various new features got introduced in it.

      运行时需要Java 8或更高版本。 但是仍然可以测试使用以前的Java版本编译的代码。 其中引入了各种新功能。

      JUnit注释 (JUnit Annotations)

      Listed below are some commonly used annotations provided in it:

      下面列出了其中提供的一些常用注释:

      AnnotationDescription
      @Test Denotes a test method
      @DisplayName Declares a custom display name for the test class or test method
      @BeforeEach Denotes that the annotated method should be executed before each test method
      @AfterEach Denotes that the annotated method should be executed after each test method
      @BeforeAll Denotes that the annotated method should be executed before all test methods
      @AfterAll Denotes that the annotated method should be executed after all test methods
      @Disable Used to disable a test class or test method
      @Nested Denotes that the annotated class is a nested, non-static test class
      @Tag Declare tags for filtering tests
      @ExtendWith Register custom extensions
      注解 描述
      @测试 表示测试方法
      @显示名称 声明测试类或测试方法的自定义显示名称
      @BeforeEach 表示带注释的方法应在每个测试方法之前执行
      @AfterEach 表示带注释的方法应在每个测试方法之后执行
      @BeforeAll 表示带注释的方法应在所有测试方法之前执行
      @毕竟 表示带注释的方法应在所有测试方法之后执行
      @禁用 用于禁用测试类或测试方法
      @嵌套 表示带注释的类是嵌套的非静态测试类
      @标签 声明标签以过滤测试
      @ExtendWith 注册自定义扩展
      package com.journaldev;
      
      import org.junit.jupiter.api.AfterAll;
      import org.junit.jupiter.api.AfterEach;
      import org.junit.jupiter.api.BeforeAll;
      import org.junit.jupiter.api.BeforeEach;
      import org.junit.jupiter.api.Disabled;
      import org.junit.jupiter.api.DisplayName;
      import org.junit.jupiter.api.Test;
      
      public class JUnit5Sample1Test {
      
        @BeforeAll
        static void beforeAll() {
          System.out.println("**--- Executed once before all test methods in this class ---**");
        }
      
        @BeforeEach
        void beforeEach() {
          System.out.println("**--- Executed before each test method in this class ---**");
        }
      
        @Test
        void testMethod1() {
          System.out.println("**--- Test method1 executed ---**");
        }
      
        @DisplayName("Test method2 with condition")
        @Test
        void testMethod2() {
          System.out.println("**--- Test method2 executed ---**");
        }
      
        @Test
        @Disabled("implementation pending")
        void testMethod3() {
      	  System.out.println("**--- Test method3 executed ---**");
        }
      
        @AfterEach
        void afterEach() {
          System.out.println("**--- Executed after each test method in this class ---**");
        }
      
        @AfterAll
        static void afterAll() {
          System.out.println("**--- Executed once after all test methods in this class ---**");
        }
      
      
      }

      We can run above JUnit test class in Eclipse -> Run As -> JUnit Test.

      我们可以在Eclipse-> Run As-> JUnit Test中的 JUnit测试类之上运行

      JUnit断言 (JUnit Assertions)

      Every test method must be evaluated against condition to true using assertions so that the test can continue to execute. JUnit Jupiter assertions are kept in the org.junit.jupiter.api.Assertions class. All of the methods are static.

      必须使用断言将每个测试方法的条件评估为true,以便测试可以继续执行。 JUnit Jupiter断言保存在org.junit.jupiter.api.Assertions类中。 所有方法都是静态的。

      AssertionDescription
      assertEquals(expected, actual)Fails when expected does not equal actual
      assertFalse(expression)Fails when expression is not false
      assertNull(actual)Fails when actual is not null
      assertNotNull(actual)Fails when actual is null
      assertAll()Group many assertions and every assertion is executed even if one or more of them fails
      assertTrue(expression)Fails if expression is not true
      assertThrows()Class to be tested is expected to throw an exception
      断言 描述
      assertEquals(预期的,实际的) 预期不等于实际时失败
      assertFalse(表达式) 表达式不为假时失败
      assertNull(实际) 实际不为空时失败
      assertNotNull(实际) 当real为null时失败
      assertAll() 对许多断言进行分组,并且每个断言都会执行,即使其中一个或多个失败
      assertTrue(表达式) 如果表达式不正确则失败
      assertThrows() 预期要测试的类将引发异常
      @Test
      void testAssertEqual() {
      	 assertEquals("ABC", "ABC");
      	 assertEquals(20, 20, "optional assertion message");
      	 assertEquals(2 + 2, 4);
      }
      
      @Test
      void testAssertFalse() {
      	 assertFalse("FirstName".length() == 10);
      	 assertFalse(10 > 20, "assertion message");
      }
      
      @Test
      void testAssertNull() {
           String str1 = null;
      	 String str2 = "abc";
      	 assertNull(str1);
      	 assertNotNull(str2);	
      }
      
      @Test
      void testAssertAll() {
      	 String str1 = "abc";
      	 String str2 = "pqr";
      	 String str3 = "xyz";
      	 assertAll("numbers",
      	      () -> assertEquals(str1,"abc"),
      		  () -> assertEquals(str2,"pqr"),
      		  () -> assertEquals(str3,"xyz")
      	 );
      	 //uncomment below code and understand each assert execution
           /*assertAll("numbers",
      		  () -> assertEquals(str1,"abc"),
      		  () -> assertEquals(str2,"pqr1"),
      		  () -> assertEquals(str3,"xyz1")
      	 );*/
      }
      
      @Test
      void testAssertTrue() {
      	 assertTrue("FirstName".startsWith("F"));
      	 assertTrue(10  {
      	      throw new IllegalArgumentException("Illegal Argument Exception occured");
      	 });
      	 assertEquals("Illegal Argument Exception occured", exception.getMessage());
      }

      JUnit5导入 (JUnit5 Imports)

      Its test classes need org.junit.jupiter.api.Test import statement and not org.junit.Test. Also, the test methods need not be a public and local package.

      它的测试类需要org.junit.jupiter.api.Test导入语句,而不是org.junit.Test 。 同样,测试方法不必是公共和本地程序包。

      import org.junit.jupiter.api.Test;

      JUnit5假设 (JUnit5 Assumptions)

      Assumptions are static methods in the org.junit.jupiter.api.Assumptions class. They will execute a test only when the specified condition met otherwise test will be aborted. The aborted test will not cause build failure. When an assumption fails, org.opentest4j.TestAbortedException is thrown and the test is skipped.

      假设是org.junit.jupiter.api.Assumptions类中的静态方法。 他们仅在满足指定条件时执行测试,否则测试将中止。 中止的测试不会导致构建失败。 当假设失败时,将抛出org.opentest4j.TestAbortedException并跳过测试。

      AssumptionsDescription
      assumeTrueExecute the body of lamda when the positive condition hold else test will be skipped
      assumeFalseExecute the body of lamda when the negative condition hold else test will be skipped
      assumingThatPortion of the test method will execute if an assumption holds true and everything after the lambda will execute irrespective of the assumption in assumingThat() holds
      假设条件 描述
      假设是真的 当阳性条件成立时执行lamda主体,否则将跳过测试
      假设为假 负条件成立时执行lamda主体,否则将跳过测试
      假如说 如果假设成立,则测试方法的一部分将执行,并且lambda之后的所有内容都将执行,而与前提条件thatthat()成立的情况无关
      @Test
      void testAssumeTrue() {
           boolean b = 'A' == 'A';
           assumeTrue(b);
           assertEquals("Hello", "Hello");
      }
      
      @Test
      @DisplayName("test executes only on Saturday")
      public void testAssumeTrueSaturday() {
           LocalDateTime dt = LocalDateTime.now();
           assumeTrue(dt.getDayOfWeek().getValue() == 6);
           System.out.println("further code will execute only if above assumption holds true");
      }
      
      @Test
      void testAssumeFalse() {
           boolean b = 'A' != 'A';
           assumeFalse(b);
           assertEquals("Hello", "Hello");
      }
      
      @Test
      void testAssumeFalseEnvProp() {
           System.setProperty("env", "prod");
           assumeFalse("dev".equals(System.getProperty("env")));
           System.out.println("further code will execute only if above assumption hold");
      }
      
      @Test
      void testAssumingThat() {
           System.setProperty("env", "test");
           assumingThat("test".equals(System.getProperty("env")),
                () -> {
                     assertEquals(10, 10);
                     System.out.println("perform below assertions only on the test env");
                     });
      
           assertEquals(20, 20);
           System.out.println("perform below assertions on all env");
      }

      JUnit嵌套测试类 (JUnit Nested Test Classes)

      Nested tests allow to create nested classes and execute all of its test methods. The inner classes must be non-static. Just annotate inner classes with @Nested and all test methods inside it will be executed.

      嵌套测试允许创建嵌套类并执行其所有测试方法。 内部类必须是非静态的。 只需使用@Nested注释内部类,即可执行其中的所有测试方法。

      @BeforeAll
      static void beforeAll() {
           System.out.println("**--- JUnit5Sample4Test :: beforeAll :: Executed once before all test methods ---**");
      }
       
      @BeforeEach
      void beforeEach() {
      	 System.out.println("**--- JUnit5Sample4Test :: beforeEach :: Executed before each test method ---**");
      }
      
      @AfterEach
      void afterEach() {
      	 System.out.println("**--- JUnit5Sample4Test :: afterEach :: Executed after each test method ---**");
      }
      
      @AfterAll
      static void afterAll() {
      	 System.out.println("**--- JUnit5Sample4Test :: afterAll :: Executed after all test method ---**");
      }
       
           @Nested
           class InnerClass {
       
                @BeforeEach
                void beforeEach() {
                     System.out.println("**--- InnerClass :: beforeEach :: Executed before each test method ---**");
                }
       
                @AfterEach
                void afterEach() {
              	   System.out.println("**--- InnerClass :: afterEach :: Executed after each test method ---**");
                }
       
                @Test
                void testMethod1() {
              	   System.out.println("**--- InnerClass :: testMethod1 :: Executed test method1 ---**");
                }
       
                @Nested
                class InnerMostClass {
       
                     @BeforeEach
                     void beforeEach() {
                          System.out.println("**--- InnerMostClass :: beforeEach :: Executed before each test method ---**");
                     }
       
                     @AfterEach
                     void afterEach() {
                  	    System.out.println("**--- InnerMostClass :: afterEach :: Executed after each test method ---**");
                     }
       
                     @Test
                     void testMethod2() {
                  	    System.out.println("**--- InnerMostClass :: testMethod2 :: Executed test method2 ---**");
                     }
              }
          }

      JUnit测试异常 (JUnit Test Exception)

      There are situations in which methods are expected to throw an exception under a specific condition. assertThrows will fail the test if the given method does not throw the specified exception.

      在某些情况下,期望方法在特定条件下引发异常。 如果给定方法未引发指定的异常,则assertThrows将使测试失败。

      Throwable exception = assertThrows(IllegalArgumentException.class, () -> {
           throw new IllegalArgumentException("Illegal Argument Exception occured");
      });
      assertEquals("Illegal Argument Exception occured", exception.getMessage());

      JUnit测试执行 (JUnit Test Execution)

      The unit tests can be executed in many ways, two of the ways are as follows:

      单元测试可以通过多种方式执行,其中两种方式如下:

      • Use Eclipse IDE Oxygen.3a (4.7.3a) Release and open test file to be executed. Right-click on the file and choose option Runs As followed by JUnit Test

        使用Eclipse IDE Oxygen.3a(4.7.3a)发行并打开要执行的测试文件。 右键单击文件,然后选择选项Runs As,然后选择JUnit Test
      • Use mvn test command on Windows command prompt

        在Windows命令提示符下使用mvn test命令

      摘要 (Summary)

      We’ve explored JUnit5 and its new features with some examples. We also looked how we can use JUnit annotations, assertions, assumptions, exceptions and write nested test classes.

      我们通过一些示例探索了JUnit5及其新功能。 我们还研究了如何使用JUnit批注,断言,假设,异常并编写嵌套的测试类。

      GitHub Repository. GitHub Repository下载完整的示例项目。

      翻译自: https://www.journaldev.com/20834/junit5-tutorial

      junit5教程

    展开全文
  • JUNIT5 + Mockito

    千次阅读 2022-04-27 10:06:03
    JUNIT5+Mockito maven配置与实践

    目录

    一、前言

    二、Maven依赖

    2.1 JUNIT5

    2.2 Mockito3

    2.3 surefire

    三、UT示例

    3.1 业务代码

    3.2 单元测试

    一、前言

    JUNIT和Mockito这两个单元测试框架在Java工程中被广泛应用。

    但到2021年,仍有很多开发者在使用JUNIT4+Mockito2+PowerMock,但不得不说,这套配置已经开始过时。

    如今,JUNIT5已经迭代到5.8.x,Mockito也进入了4.0.0阶段,我们可以开始尝试基于JUNIT5+Mockito3来进行单测的开发。由于PowerMock在JUNIT5上无法工作,所以不再使用PowerMock。Mockito3.4后,已经支持mock静态方法(Mockito (Mockito 3.5.10 API) (javadoc.io)),不引入PowerMock也能继续单测开发。

    二、Maven依赖

    2.1 JUNIT5

    首先引入JUNIT5。

                <!-- junit5 -->
                <dependency>
                    <groupId>org.junit.jupiter</groupId>
                    <artifactId>junit-jupiter</artifactId>
                    <version>5.8.2</version>
                    <scope>test</scope>
                </dependency>

    2.2 Mockito3

    除了引入mockito-core外,还需要引入mockito-jupiter扩展包。

    其中mockito-inline是对Mockito的增强,包括mock final类 static方法。

                <!-- mockito3 -->
                <dependency>
                    <groupId>org.mockito</groupId>
                    <artifactId>mockito-core</artifactId>
                    <version>3.12.4</version>
                    <scope>test</scope>
                </dependency>
                <dependency>
                    <groupId>org.mockito</groupId>
                    <artifactId>mockito-inline</artifactId>
                    <version>3.6.28</version>
                    <scope>test</scope>
                </dependency>
                <!-- mockito for junit5 -->
                <dependency>
                    <groupId>org.mockito</groupId>
                    <artifactId>mockito-junit-jupiter</artifactId>
                    <version>2.23.0</version>
                    <scope>test</scope>
                    <exclusions>
                        <exclusion>
                            <artifactId>junit-jupiter-api</artifactId>
                            <groupId>org.junit.jupiter</groupId>
                        </exclusion>
                    </exclusions>
                </dependency>

    2.3 surefire

    为了单测能正常运行并被mvn test识别,还需要更新maven-surefire-plugin,添加相关依赖。

                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.0</version>
                    <configuration>
                        <testFailureIgnore>true</testFailureIgnore>
                    </configuration>
                    <dependencies>
                        <dependency>
                            <groupId>org.junit.platform</groupId>
                            <artifactId>junit-platform-surefire-provider</artifactId>
                            <version>1.2.0</version>
                        </dependency>
                    </dependencies>
                </plugin>

    三、UT示例

    3.1 业务代码

    @Service
    public class DomainServiceImpl implements DomainService {
    
        @Resource
        private DataJpa dataJpa;
    
        @Override
        public Boolean foo(List<String> names) {
            int res = dataJpa.update(names);
            return res == 1;
        }
    }

    3.2 单元测试

    在JUNIT5中,不再提供@RunWith注解,需要使用@ExtendWith注解。

    为了让Mockito正常工作,需要在@ExtendWith注解中使用MockitoExtension.class

    同时,@Before被@BeforeAll或者@BeforeEach替换,若使用@BeforeAll,需要写在静态方法上。

    @ExtendWith(MockitoExtension.class)
    class DomainServiceImplTest {
    
        @InjectMocks
        private DomainServiceImpl domainService;
    
        @Mock
        private DataJpa dataJpa;
    
        @BeforeAll
        static void setUp() {
        }
    
        @Test
        void foo() {
            List<String> names = Lists.newArrayList("a", "b");
            Mockito.when(dataJpa.update(Mockito.anyList())).thenReturn(1);
            boolean res = domainService.foo(names);
            Assertions.assertTrue(res);
        }
    }

    展开全文
  • Junit 5 文档

    2017-11-14 08:39:56
    Junit 5 测试java项目 新的Junit结构,与junit4相比,变化较大!
  • Junit5使用示例

    千次阅读 2022-01-17 11:04:11
    junit5使用详解
  • JUnit5学习之一:基本操作

    千次阅读 2020-10-08 09:23:25
    JUnit5学习》是欣宸的又一个实战主题的Java技术栈原创系列,欢迎大家一起来学习和掌握最新的单元测试技术
  • JUnit 4和JUnit 5区别

    千次阅读 2021-02-18 15:24:53
    JUNIT 5 声明一种测试方法 @Test @Test 在当前类中的所有测试方法之前执行 @BeforeClass @BeforeAll 在当前类中的所有测试方法之后执行 @AfterClass @AfterAll 在每个测试方法之前执行...
  • Java测试框架-junit5详解

    千次阅读 2022-04-23 16:37:03
    Java测试框架-junit5 java当前主流的测试框架有两个:TESTNG、Junit5;这两个框架在功能上都比较完善,也没有说哪个更好,因为笔者平时用的比较多的是Junit5,所以本文主要讲的是Junit5的使用 1、Junit5的构成 ...
  • JUnit 5 所需要的JUnit Vintage.jar依赖包,包含:junit-vintage-engine-5.4.2.jar,junit-vintage-engine-5.5.0.jar, junit-vintage-engine-5.5.1.jar
  • spring中 junit4 和 junit5 使用

    万次阅读 2022-07-20 12:49:19
    @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:ApplicationContext.xml") @SpringJUnitConfig(locations = "classpath:ApplicationContext.xml")
  • JUnit 5 对比 TestNG

    千次阅读 2020-09-10 11:02:06
    JUnit 和 TestNG 是 Java 应用测试领域最流行的测试框架。这两个框架早已经是很完善并且简单易用。所以当你为你的应用去选择测试框架时,最好有一个高层次的想法,对比两种框架的所有的特质,然后再基于你的项目的...
  • 全网最全:Junit5的@Suite注解-上

    万次阅读 2021-12-01 19:24:29
    Junit5的Suite套件 最近在研究对应的suite套件,发现官网上有了对应的直接@Suite注解配合就可以使用套件,不需要再声明@RunWith(JUnitPlatform.class) 由于官网的解释不是很详细,在这里给大家写一篇比较详细的文章 ...
  • Junit 4 与Junit 5区别

    千次阅读 2020-10-20 15:10:17
    所需JDK Junit 4 Junit 5 ...需要 Java 5 或以上版本 ...Junit 4 所有的东西在一...Junit 5JUnit Platform, JUnit Jupiter 和 JUnit Vintage 三个子项目组成: JUnit Platform 定义了 test engine API,用于开发在
  • IDEA中使用JUnit5(单元测试框架)

    千次阅读 2021-03-29 10:21:40
    JUnit单元测试框架由Erich Gamma和Kent Beck编写的一个回归测试框架(Regresion Testing Framework),主要用于Java语言程序的单元测试。
  • JUnit Jupiter: JUnit Jupiter提供了JUnit5的新的编程模型,是JUnit5新特性的核心。内部 包含了一个测试引擎,用于在Junit Platform上运行。 JUnit Vintage: 由于JUint已经发展多年,为了照顾老的项目,JUnit ...
  • JUnit 5预期异常

    千次阅读 2020-07-21 15:17:42
    JUnit 5中,我们可以使用assertThrows声明抛出了异常。 PS已通过JUnit 5.5.2测试 1.未检查的异常 1.1捕获运行时异常的JUnit示例。 ExceptionExample1.java package com.mkyong.assertions; import org.junit....
  • JUnit5 + JMockit 知识整理

    千次阅读 2019-01-22 15:15:47
    JUnit5 https://junit.org/junit5/ 基本概念 JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage JUnit Platform: JUnit5 框架,复杂启动并加载运行 Test Cases; JUnit Jupiter: JUnit5 Test Case 开发...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 448,799
精华内容 179,519
关键字:

junit5