精华内容
下载资源
问答
  • junit单元测试
    千次阅读
    2022-06-06 13:20:07


    Springboot整合junit单元测试

    主要介绍springboot整合junit进行单元测试


    一、引入依赖

    	<dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
        </dependency>
    
    

    二、编写测试类

    代码如下(示例):
    @RunWith(SpringRunner.class):运行器指定
    SpringRunner.class的作用:
    在Spring项目中的Test测试类要使用注入的类,比如@Autowired注入的类或者spring管理的bean的时候,测试类在运行前,需要spring容器运行起来,加上这个@RunWith(SpringRunner.class)注解,就是先运行起来spring容器,再开始运行测试类
    @SpringBootTest:
    作用是加载ApplicationContext,启动spring容器。使用@SpringBootTest后,Spring将加载所有被管理的bean,基本等同于启动了整个服务,此时便可以开始功能测试。
    由于web服务是最常见的服务,且我们对于web服务的测试有一些特殊的期望,所以@SpringBootTest注解中,给出了webEnvironment参数指定了web的environment,该参数的值一共有四个可选值:
    MOCK:此值为默认值,该类型提供一个mock环境,可以和@AutoConfigureMockMvc或@AutoConfigureWebTestClient搭配使用,开启Mock相关的功能。注意此时内嵌的服务(servlet容器)并没有真正启动,也不会监听web服务端口。
    RANDOM_PORT:启动一个真实的web服务,监听一个随机端口。
    DEFINED_PORT:启动一个真实的web服务,监听一个定义好的端口(从application.properties读取)。
    NONE:启动一个非web的ApplicationContext,既不提供mock环境,也不提供真实的web服务。
    注:如果当前服务的classpath中没有包含web相关的依赖,spring将启动一个非web的ApplicationContext,此时的webEnvironment就没有什么意义了。

    @SpringBootTest(classes = Application.class)
    @RunWith(SpringRunner.class)
    public class test {
    
        @Test
        public void test1(){
            System.out.println("this is test1");
        }
    }
    

    总结

    以上就是今天要讲的内容,本文仅仅简单介绍了springboot整合junit的使用

    更多相关内容
  • 在本篇文章里小编给大家分享的是关于Java Junit单元测试的相关知识点内容,有兴趣的朋友们学习下。
  • 我们将会使用ant来编译一个junit单元测试实例项目,然后修改build.xml文件,加上clover的覆盖率分析任务target;而且我们还要通过三部分来学习clover超级无敌的地方:current报告、历史报告以及高级特征
  • 主要介绍了Spring Junit加载配置文件失败问题解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 下面小编就为大家分享一篇JUnit单元测试入门必看篇,对新手而言有很好的参考价值,希望对大家有所帮助
  • 主要介绍了idea +junit单元测试获取不到bean注入的解决方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • junittest.zip,junittest,.project,hs_err_pid19356.log,bin,AndroidManifest.xml,res,classes,com,liwei,junittest,R$string.class,R$layout.class,services,CalcService.class,MainActivity.class,R$dimen.class,...
  • Junit单元测试

    千次阅读 2021-12-02 15:12:41
    Junit 1 Junit是什么 JUnit 是一个 Java 编程语言的单元测试...3 Junit单元测试框架的作用以及好处 用来对类中的方法功能进行有目的的测试,以保证程序的正确性和稳定性。 能够让方法独立运行起来。 好处: 可以书写一

    Junit

    1 Junit是什么

    JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展,是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。

    2 单元测试概念

    • 单元:在Java中,一个类就是一个单元
    • 单元测试:程序猿编写的一小段代码,用来对某个类中的某个方法进行功能测试或业务逻辑测试。

    3 Junit单元测试框架的作用以及好处

    用来对类中的方法功能进行有目的的测试,以保证程序的正确性和稳定性。
    能够让方法独立运行起来。
    好处:

    可以书写一系列的测试方法,对项目所有的接口或者方法进行单元测试。
    启动后,自动化测试,并判断执行结果, 不需要人为的干预。
    只需要查看最后结果,就知道整个项目的方法接口是否通畅。
    每个单元测试用例相对独立,由Junit 启动,自动调用。不需要添加额外的调用语句。
    添加,删除,屏蔽测试方法,不影响其他的测试方法。 开源框架都对JUnit 有相应的支持。

    4 Junit单元测试框架的使用步骤

    编写业务类,在业务类中编写业务方法。比如增删改查的方法
    编写测试类,在测试类中编写测试方法,在测试方法中编写测试代码来测试。
    测试类的命名规范:以Test开头,以业务类类名结尾,使用驼峰命名法
    每一个单词首字母大写,称为大驼峰命名法,比如类名,接口名…
    从第二单词开始首字母大写,称为小驼峰命名法,比如方法命名
    比如业务类类名:ProductDao,那么测试类类名就应该叫:TestProductDao
    测试方法的命名规则:以test开头,以业务方法名结尾
    比如业务方法名为:save,那么测试方法名就应该叫:testSave

    5 测试方法注意事项

    • 必须是public修饰的,没有返回值,没有参数
    • 必须使注解@Test修饰

    6 如何运行测试方法

    • 选中方法名 --> 右键 --> Run ‘测试方法名’ 运行选中的测试方法
    • 选中测试类类名 --> 右键 --> Run ‘测试类类名’ 运行测试类中所有测试方法
    • 选中模块名 --> 右键 --> Run ‘All Tests’ 运行模块中的所有测试类的所有测试方法

    7 如何查看测试结果

    • 绿色:表示测试通过
    • 红色:表示测试失败,有问题

    8 Junit常用注解(Junit4.xxxx版本)

    * @Before:用来修饰方法,该方法会在每一个测试方法执行之前执行一次。
    * @After:用来修饰方法,该方法会在每一个测试方法执行之后执行一次。
    * @BeforeClass:用来静态修饰方法,该方法会在所有测试方法之前执行一次。
    * @AfterClass:用来静态修饰方法,该方法会在所有测试方法之后执行一次。
    

    9 Junit常用注解(Junit5.xxxx版本)

     @BeforeEach:用来修饰方法,该方法会在每一个测试方法执行之前执行一次。
     @AfterEach:用来修饰方法,该方法会在每一个测试方法执行之后执行一次。
     @BeforeAll:用来静态修饰方法,该方法会在所有测试方法之前执行一次。
     @AfterAll:用来静态修饰方法,该方法会在所有测试方法之后执行一次。
    

    10 Junit的使用

    • 示例代码:
    //一般的话是创建main方法,执行main方法才能执行
    
    public class Demo01 {
        public static void main(String[] args) {
          new Demo01().add();
        }
        public static void add(){
            int a=5;
            int b=10;
            System.out.println(a+b);
        }
    }
       //而增加@test之后,可以直接点击运行,也可以进行调试
        @Test
        public  void add(){
            int a=5;
            int b=10;
            System.out.println(a+b);
        }
    

    演示视频:
    请添加图片描述

    展开全文
  • Junit单元测试Junit单元测试Junit单元测试Junit单元测试
  • 超级详细的Junit单元测试教程

    万次阅读 多人点赞 2020-05-31 23:23:23
    如果你只会使用@Test来完成单元测试,那你是时候该深入一下了,其实知识点一点都不少!

    所有知识体系文章,GitHub已收录,欢迎Star!

    GitHub地址: https://github.com/Ziphtracks/JavaLearningmanual

    搜索关注微信公众号“码出Offer”,Z哥送你学习福利资源!

    Junit单元测试

    一、什么是单元测试?

    在计算机编程中,单元测试(英语:Unit Testing)又称为模块测试, 是针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作。 程序单元是应用的最小可测试部件。简单来说,就是测试数据的稳定性是否达到程序的预期。

    二、单元测试的重要性

    谈到测试,我们为什么要对程序进行测试呢?测试会为程序带来什么好处呢?

    首先,我们每个人都会犯错误。毕竟人嘛,没有完美的谁谁谁。在程序中犯错误就像生活中犯错一样,错误不是一天两天而形成的。当需要改的时候,也不是能花少的时间而改掉的。这里我谈到的程序中的错误,就是著名的Bug。

    我们可能在不经意间写错,如果你到了最后阶段去检验项目成果时,发现会有错误,这时候我们很难找到Bug的源头在哪里。我们都知道,有可能一处出错会导致步步错的情况。

    然而,测试就在我们的上述说法中,显得尤为重要。有了测试的概念,这时候当我们做完项目的一个小模块,我们先去测试一下这个小模块是否正确或达到预期,如果错误或者没有达到预期就需要反复修改,直到正确或达到预期。这里所说的也就是使用了单元测试。

    当我们一块一块的做完并一块一块的测试后OK后,这时候你会发现项目像拼图一样拼在了一起。简单来说,这就是单元测试存在的重要意义!

    声明: 术语显得过于生硬,白话文也许会让你们了解,请谅解我的大白话!谢谢!

    三、黑盒测试与白盒测试

    3.1 黑盒测试

    黑盒测试又称功能测试。它通过测试来检验程序是否能正常使用。在测试过程中,我们把程序看作为一个打不开的盒子,黑黑的什么也看不见,内部代码怎么写的也不知道。也就是说完全不考虑任何内部结构和性能的情况下为程序传入(Input)参数,然后去查看程序输出(Output)是否在正常范围内,通常这时候我们需要多此测试才得出结论。

    特点: 不需要我们中间参与编写任何代码,传入参数值后查看程序是否正常或达到预期值。

    image-20200531202329881

    3.2 白盒测试

    白盒测试又称结构测试。在这里白盒测试与黑盒测试不同,在测试过程中,我们可以把程序看作为一个可以看到的白色透明盒子,我们清楚盒子内部的代码和结构。我们在使用白盒测试的时候,测试人员必须检查程序的内部结构,而要从检查程序的逻辑开始,一步一步的检查传入参数(Input)并查看程序的运行过程和输出(Output)结果,最终得出测试数据。这也就是“白盒测试”为什么叫穷举路径测试的原因,再次强调,是因为我们清楚程序的内部结构和代码,从而检查所有结构的正确与否和预期值。

    注意: 单元测试就是白盒测试的一种!

    image-20200531202615957

    四、单元测试思想传递

    在这里我们忘掉单元测试,使用平时我们自己测试的方式来测试数据,看看它有什么缺点。

    首先,我先创建在一个计算器类,在其中随便创建两个运算方法,供我们模拟测试。

    package com.mylifes1110.java;
    
    /**
     * 计算器
     */
    public class Calculator {
        /**
         * 加法
         */
        public int add(int num1, int num2) {
            return num1 + num2;
        }
    
        /**
         * 减法
         */
        public int cut(int num1, int num2) {
            return num1 - num2;
        }
    }
    

    然后我们再去编写测试类,创建对象,先去测试加法。

    package com.mylifes1110.java;
    
    public class Test {
        public static void main(String[] args) {
            Calculator calculator = new Calculator();
            //测试加法
            System.out.println(calculator.add(10, 10));		//20		正确
        }
    }
    

    测试后,我们查看结果为正确的,然后进行下一步测试。因为我们有两条数据需要测试,平时在测试完一条数据后需要把测试过的数据注释掉,再进行接下来的测试。如下:

    package com.mylifes1110.java;
    
    //测试类
    public class Test {
        public static void main(String[] args) {
            Calculator calculator = new Calculator();
            //测试加法
    //        System.out.println(calculator.add(10, 10));		//20		正确
            //测试减法
            System.out.println(calculator.cut(10, 10));			//0		正确
        }
    }
    

    测试完两条数据后,再去继续编写我们的项目代码。

    其实,我们有没有发现这样做很麻烦呢?上一步骤为什么需要把测试过的数据注释掉呢?

    答案来了,的确很麻烦,至于为什么注释掉,那是因为我们在写项目代码的时候,需要测试,不可能在同一个测试类测试这么多数据。而且在测试的过程序,数据与数据之间是有关联是互相影响的。这就会造成我们的测试不准确从而影响后续编码进度和项目准确性。

    了解了上述测试的缺点,我们也需要了解单元测试的思想了。单元测试需要拥有什么样的特点才能解决掉上述测试的麻烦呢?其实我们的单元测试也是通过编码规范来约束的。至于编码规范嘛,你还不去看第五章?

    五、单元测试的编码规范

    单元测试的编码规范有这几条,小伙伴们拿小本本记好了!

    • 类名: 定义测试类,类名是由被测试类名Test构成。例如:CalculatorTest
    • 包名: 定义的测试类需要放在xxx.xxx.xxx.test包中。例如:package com.mylifes1110.test;
    • 方法名: 测试方法的方法名有两种定义方式test测试方法测试方法。例如:testAdd和add
    • 返回值: 因为我们的方法只是在类中测试,可以独立运行,所以不需要处理任何返回值,所以这里使用void。例如:public void add();
    • 参数列表: 因为我们的方法是用来测试的,至于参数列表的传入是没有必要的。我们在测试的时候自行传入需要的参数测试即可。所以在此参数列表为。例如:例如:public void add();
    • @Test注解: 测试是需要运行来完成的。如果我们只有一个main方法,显然在结构上还是需要我们去注释掉测试过的。解决此问题这里我们需要在测试方法上方加@Test注解来完成测试,只要是加该注解的方法,可以单独运行此方法来完成测试。
    • @Test注解jar包Junit4、5: @Test注解是需要我们导入jar包才能使用的。jar包有两个分别是:junit-4.13-rc-2hamcrest-core-1.3。这里我使用的是Junit4,单元测试还有Junit5,版本差异我没有做了解。主要是可以完成测试才是硬道理!
    • IDEA快捷导入Junit4、5: 使用IDEA的小伙伴,你们的福音来了。我们可以先创建测试类和方法,然后在测试方法上方加入@Test注解,此时IDEA显示的@Test注解是飘红的,这时候我们使用Alt + Enter组合键来打开导入Junit单元测试列表,然后再选择Junit4或者Junit5确定即可导入成功!这时候再查看注解就没有飘红了!

    image-20200531213742156

    六、@Test测试与Assert断言步骤

    断言方法描述
    assertNull(java.lang.Object object)检查对象是否为空
    assertNotNull(java.lang.Object object)检查对象是否不为空
    assertEquals(long expected, long actual)检查long类型的值是否相等
    assertEquals(double expected, double actual, double delta)检查指定精度的double值是否相等
    assertFalse(boolean condition)检查条件是否为假
    assertTrue(boolean condition)检查条件是否为真
    assertSame(java.lang.Object expected, java.lang.Object actual)检查两个对象引用是否引用同一对象(即对象是否相等)
    assertNotSame(java.lang.Object unexpected, java.lang.Object actual)检查两个对象引用是否不引用统一对象(即对象不等)

    首先,我们先去按照Junit单元测试规范来书写测试代码,如下:

    image-20200531215145357

    然后我们会发现每一个需要测试的方法左边都有一个绿色的小三角,这是用来单元测试运行的。也就是说,我们可以只运行某一个方法去测试。现在我们去运行add()方法,结果如下:

    image-20200531224224937

    这时候,我们发现控制台是绿色的并输出的打印结果,这说明我们的程序没有问题。如果我再其中加入一个算数异常会有怎么样的结果呢?如下:

    00

    在这里我们会发现,控制台变为了红色,并给出来报错信息。这证明了我们的程序测试后出现了问题。这仅是程序正确与失败的关系。

    如果我们需要一个预期值呢?那么测试的结果不是我想要的预期值,而程序还是绿色的,证明程序没有问题怎么办呢?有的小伙伴会说,我们已经查看了打印控制台的信息,打印结果不是预期值就说明程序有问题,需要去修改呗。对,其实这样说是没有任何毛病的。但是,我们在开发中,如果由于你的疏忽或者疲劳看到了绿色就觉得程序没有问题怎么办呢?所以面对这个问题,我们在单元测试的时候,尽量不要去打印预期值,需要注重观察是绿色和红色比较好,它可以直观的反映程序的是否准确性和达到预期值。

    这时候,我们就需要引入一个对象的静态方法来断言是否为预期值。

    Assert.assertEquals(预期值, 结果);
    

    image-20200531220749643

    这时候我们发现Assert句点出来的方法可以既可以断言数组,也可以断言普通数据类型。所以这时候我们就来使用它断言预期值。如下:

    image-20200531224130120

    这时候,我们就断言result结果的预期值为1。断言后,发现未达到预期值就会报错!

    注意: 我们使用断言的时候尽量不要去断言Double对象。对于双精度数,绝对有必要使用增量进行比较,以避免浮点舍入的问题。如果您使用assertEquals带有double参数的3参数版本。

    assertEquals(double expected, double actual, double delta);
    

    这样以来Double将被自动取消装箱,double并且一切正常,这样测试结果就不会失败。否则使用两个参数的来断言double类型,会有如下报错信息:

    七、@Before和@After注解

    我们在上述,你是否会发现有一些重复操作呢?比如,我们每一个方法都需要去new对象。有些聪明的小伙伴会说,我们可以把它提到类的里面与方法同级。对,这个处理方式也是一个正解。

    但是我们在Junit单元测试中,有一个@Before注解,是用作资源的申请。也就是被@Before注解修饰的的方法会在测试方法之前自动执行。所以,我们可以去定义一个init方法,去初始化这个创建对象的过程。这就是@Before注解的作用!

    有些应用场景,比如IO流的读写操作。如果我们要测试此代码,是需要一个关闭流的过程,通过我们关闭流使用finally块来保证最后流的关闭操作。这时,我们在Junit单元测试中,有一个@After注解,是用作资源的关闭。也就是说被@After注解修饰的方法会在测试方法之后自定执行。所以,我们在特定需要保证最后关闭、销毁资源的时候,可以去定义一个close方法,去关闭或销毁资源。这就是@After注解的作用!

    注意: @Before和@After注解在程序报错的时候,仍然可以保证数据的初始化和关闭销毁,两个方法是依旧执行的。这里有点像我们tomact服务器的初始阶段和销毁阶段,它们的执行不受任何影响。

    image-20200531225614728

    八、自定义@MyTest注解实现单元测试

    目的: 完成自定义注解@MyTest,并实现标有注解的方法并启动它。(模拟@Test注解做单元测试)
    步骤:

    1. 新建一个注解类(annotation),命名为MyTest
    2. 创建一个TestJunit单元测试类,写几个方法,比如:public void test1()
    3. 创建一个MyTestDemo测试类(主功能实现类),该类主要利用反射机制来实现对TestJunit单元测试类中加@MyTest注解方法的启动
    4. 给予注解类生命周期与反射机制吻合,也就是定义的注解可以保留到运行时,通过反射机制可以获取注解信息
    5. 编写MyTestDemo测试类,利用反射获取TestJunit单元测试类的Class对象,并获取单元测试类中所有的方法对象,遍历所有方法对象,只要加@MyTest的注解的方法把他执行起来,不加注解的不给予任何处理操作
    6. 启动测试类,查看结果(执行结果,在最后面!)

    注意:

    1. 自定义注解类中,没有编写注解体,也就是没有给默认value值。因为该注解只是起到了标识的作用,标识需要启动的方法
    2. 注解类编译后也是.class文件
    3. 通过反射机制来完成自定义注解操作,一定要给与注解和反射同样的生命周期
    4. 你要知道我们是不能完成Junit4、Junit5这样类型的插件功能的,可以选择性的执行加了注解的方法,而且我们有实力写出插件IDEA也是不承认的。不会给你生成run方法启动项
    MyTest注解类
    package com.mylifes1110.java.anno;
    
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    
    /**
     * 此自定义注解@MyTest只是作为需要单元测试的标记,不需要做默认值
     * @Retention注解表示给与@MyTest注解生命周期
     * 当前定义的注解可以保留到运行时,通过反射机制可以获取注解信息
     * 否则反射将对注解没有任何作用,失去了该意义和自定义单元测试的初衷
     */
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyTest {
    //    String value() default "";
    }
    
    TestJunit单元测试类
    package com.mylifes1110.java.test.junit;
    
    import com.mylifes1110.java.anno.MyTest;
    import org.junit.Test;
    
    public class TestJunit {
    
        @Test
        public void test1() {
            System.out.println("---test1---");
        }
    
        @MyTest
        public void test2() {
            System.out.println("---test2---");
        }
    
        @MyTest
        public void test3() {
            System.out.println("---test3---");
        }
    
        public void test4() {
            System.out.println("---test4---");
        }
    }
    
    MyTestDemo测试类(主要实现功能并测试)
    package com.mylifes1110.java.test.junit;
    
    import com.mylifes1110.java.anno.MyTest;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /**
     * 让自定义的MyTest注解起作用
     * 通过反射,扫描TestJunit类中有哪些方法上方加了MyTest注解
     * 如果加@MyTest注解的则执行它
     * 如果没有加@MyTest注解的则不做任何处理
     */
    public class MyTestDemo {
        public static void main(String[] args) {
            /**
             * 1.获取TestJunit类对应的Class对象
             */
            Class<TestJunit> junitClass = TestJunit.class;
            /**
             * 获取TestJunit类中所有的方法对象
             */
            Method[] methods = junitClass.getMethods();
    
            /**
             * 遍历所有方法对象查找有与没有@MyTest注解,并做出响应处理
             */
            for (Method method : methods) {
                boolean present = method.isAnnotationPresent(MyTest.class);
                /**
                 * TestJunit类中有@MyTest注解的执行该方法
                 */
                if (present) {
                    try {
                        method.invoke(junitClass.newInstance());
                    } catch (IllegalAccessException | InvocationTargetException | InstantiationException e) {
                        e.printStackTrace();
                    }
                } else {
                    /**
                     * TestJunit类中没有@MyTest注解的不做任何操作
                     * 此else分支冗余,只是为了做标记,让你们好理解
                     */
                }
            }
        }
    }
    
    执行结果图

    在这里插入图片描述

    展开全文
  • junit单元测试jar包集

    2014-12-11 14:30:46
    包含junit-4.11.jar, dbunit-2.4.9.jar, unitils-3.3-with-dependencies.zip, mockito-1.9.5.zip
  • JUnit 单元测试

    千次阅读 2020-05-24 14:13:53
    目录说明junit的使用spring整合junit依赖编写单元测试测试springboot整合junit依赖编写单元测试说明   说明 一般来说,封装的工具类库、服务端接口的核心service,都应该提供相应的单元测试junit 中有2个 @...


     

    说明

    • 一般来说,封装的工具类库、服务端接口的核心service,都应该提供相应的单元测试;
    • junit 中有2个 @Test 注解:junit4 中开始提供 @org.junit.Test ,junit5 中开始提供 @org.junit.jupiter.api.Test,这2个注解在普通java项目中的使用基本相同,需要注意的是低版本 springboot 中可能没有 @org.junit.jupiter.api.Test,只能使用 @org.junit.Test 。

     

    junit的使用

    public class XxxTest {
    
        @Before //执行每个测试方法之前都会先执行@Before标注的方法
        public void init(){
    
        }
    
        @After //执行每个测试方法之后都会执行@After标注的方法
        public void destroy(){
    
        }
        
        @Test
        public void testA(){
            //提示信息可以缺省
            Assert.assertEquals("提示信息", "期望数据", "实际数据");
        }
    
        @Test
        public void testB(){
    
        }
    
    }
    
    • 包、类的路径与源码保持一致,测试类通常命名为原类名+Test,测试方法名一般命名为test+原方法名
    • 测试方法不能有入参、返回值类型要是void

     

    spring整合junit

    依赖

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.8.RELEASE</version>
        <scope>test</scope>
    </dependency>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
        <scope>test</scope>
    </dependency>
    

     

    编写单元测试

    @RunWith(SpringRunner.class)  //提供spring容器环境,这样@Autowired之类的注解才能注入所需依赖。如果当前测试类不需要spring容器环境,可缺省
    @ContextConfiguration(locations = "classpath:spring-config.xml")  //指定配置文件的位置
    // @ContextConfiguration(locations = {"classpath:spring-config1.xml","classpath:spring-config2.xml"})  //有多个时写成数组
    public class UserMapperTest {
    
        @Autowired  //注入要测试的类的实例
        private UserMapper userMapper;
    
        @BeforeClass  //在测试这个类之前执行,常用于初始化静态成员变量
        public static void BeforeClass(){
    
        }
    
        @AfterClass  //在测试这个类之后执行
        public static void AfterClass(){
    
        }
    
        @Before  //每个测试方法执行之前都会执行此方法,常用于初始化实例的成员变量
        public void before(){
    
        }
    
        @After  //每个测试方法执行完毕后都会执行此方法
        public void after(){
    
        }
    
        @Test  //测试方法
        public void findUserByIdTest(){
            User user = userMapper.findUserById(1);
            //使用的Assert是junit中的,不要导错了
            Assert.assertEquals("返回的User对象与预期不符,未通过测试", user, new User(1,"chy",20));
        }
    
        @Ignore  //测试这个类时会忽略|跳过此方法,可备注一些信息
        // @Ignore("对应方法还存在bug,暂不测试")
        public void updateUserTest(){
            //.....
        }
    
    }
    

    注意

    • @RunWith(SpringRunner.class),SpringRunner 是 SpringJUnit4ClassRunner 的别名,2个都可以
    • 在测试类前后执行用的是 @BeforeClass、@AfterClass,不是 @BeforeTestClass、@AfterTestClass
    • @BeforeClass、@AfterClass 标注的方法必须是没有入参、返回值是void的静态方法

     

    测试

    选择JUnit
    在这里插入图片描述

     

    springboot整合junit

    依赖

    用Spring Initializr创建springboot项目时,默认会自动添加junit的依赖。如果不使用Spring Initializr,可以手动添加依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    

    junit-vintage-engine是使用老版本junit所需的依赖,不需要,使用<exclusions>排除,当然留着也行。

     

    编写单元测试

    @RunWith(SpringRunner.class)
    @SpringBootTest  // @SpringBootTest(classes = {MallApplication.class} )  //指定源码中的引导类,如果源码中只有1个引导类,可缺省classes属性。
    // @WebAppConfiguration   //模拟ServletContext、提供web环境,如果这个测试类不涉及web,可缺省
    public class UserMapperTest {
    
        @Autowired
        private UserMapper userMapper;
    
        @BeforeClass
        public static void BeforeClass(){
    
        }
    
        @AfterClass
        public static void AfterClass(){
    
        }
    
        @Before
        public void before(){
    
        }
    
        @After
        public void after(){
    
        }
    
        @Test
        public void testFindUserById(){
            User user = userMapper.findUserById(1);
            Assert.assertEquals("返回的User对象与预期不符,未通过测试", user, new User(1,"chy",20));
        }
    
        @Ignore
        public void testUpdateUser(){
            //.....
        }
    
    }
    
    

     

    说明

    1、每个测试类上都要写@RunWith、@SpringBootTest,很麻烦,可以封装为一个类,测试类都继承该类

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class BaseTest {
    
    }
    

     

    2、打包测试
    一个测试类一个测试类地去点击运行,很麻烦,可以把测试类打包到一个类中,运行该类即可

    @RunWith(Suite.class)
    @Suite.SuiteClasses({UserMapperTest.class, GooodsMapperTest.class})  //数组中写要运行的测试类
    public class TestSuits {
    
    }
    

     

    3、在高版本的springboot中, spring-boot-starter-test 已经移除了junit 提供的 Assert,不能再使用 Assert.assertEquals() 之类的方法,可以使用spring自带的 Assert 。

     

    常见问题

    IDEA执行单元测试时报错

    Error running ‘XxxTest.testXxx’: Command line is too long. Shorten command line for XxxTest.testXxx or also for JUnit default configuration?

    可在父项目的 workspace.xml 中找到 <component name="PropertiesComponent">,加一个子元素

    <property name="dynamic.classpath" value="true" />
    
    展开全文
  • 上下文时间软件测试中Junit单元测试实例在一种传统的结构化编程语言中,比如C,要进行测试的单元一般是函数或子过程。在象C++这样的面向对象的语言中,要进行测试的基本单元是类。对Ada语言来说,开发人员可以选择是...
  • 今天小编就为大家分享一篇解决java junit单元测试@Test报错的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • AS中使用Junit单元测试和Android JUnit 单元测试 在AndroidStudio中使用单元测试 1. 前言 在Android开发中,如果对一个简单的功能,每次修改代码都重新运行到设备中进行测试,会浪费大量时间,降低开发工作效率。...
  • Java中的JUnit单元测试

    2022-06-23 07:48:44
    此时的Java类要求:① 此类是public的 ②此类提供公共的无参的构造器此时的单元测试方法:方法的权限是public,没有返回值,没有形参
  • Junit单元测试的基本步骤
  • 我们曾经和大家探讨过全面剖析JavaME单元测试理念,其实在Android上实现JUnit单元测试也不是很困难,主要是在配置文件和测试环境上将花费很长时间,下面从四步简单讲一下在Android上实  我们曾经和大家探讨过全面...
  • 第 三 章 J U n i t 单 元 测 试 实验 1 开始使用 JUnit 实验目的 1 学习使用进行单元测试 2 掌握编写测试代码的方法 3 应用 JUnit 进行单元测试掌握最佳实践编写测试代码 实验环境 1 Windows环境 MyEclipse 或 ...
  • 使用Idea进行Junit单元测试

    千次阅读 2022-03-31 17:45:15
    使用IDEA进行Junit单元测试
  • 进行SpringBoot整合Junit单元测试时,我们需要先将junit的start的依赖引入 在pom.xml中引入Junit环境依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...
  • JUnit单元测试

    2017-04-29 02:09:22
    JUnit单元测试
  • Junit单元测试文档

    2012-07-29 13:38:31
    junit3 junit4 api,单元测试的利器
  • Junit 单元测试

    2017-06-09 09:11:43
    junit 单元测试
  • junit单元测试

    2012-03-28 21:37:53
    junit单元测试测试是测试部门的责任,我的责任应该关注在写代码上; 测试不是一种技术工作,毫无乐趣可言,请不要骚扰我。我可是一个了不起的SSH程序员 我们有测试人员,有集成/系统/确认测试,他们迟早会发现我的...
  • Junit 单元测试 mybatis

    千次阅读 2021-12-04 10:22:09
    Junit 单元测试 Mybatis 语句

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,293
精华内容 42,117
关键字:

junit单元测试

友情链接: 日报统计.rar