测试

测试概述

就是产品发布之前对已经开发好的功能记性差提前的测试,检测功能方法是否有漏洞,是否有bug,对于后端开发人员,我们可以使用junit单元测试对我们的代码就行测试.

Junit是java语言的单元测试框架,属于第三方的工具,一般情况下我们需要导入相应的jar包.对于开发人员,我们是用集成开发工具,一般来说都是自带的junit.是编写可重复测试的简单框架。它是单元测试框架的 xUnit 架构的一个实例。

junit属于白盒测试----->属于程序员的测试

测试分类

• 黑盒测试
  一般是通过软件来完成测试,一般是看不见步骤的,
• 白盒测试—junit(程序员主要学习目标)
  一般是通过代码来完成的测试,能够明确的看到每一步的测试步骤,我们能够看见测试的流程和细节

黑白盒测试图解

junit4的使用(完成白盒测试)

1. 首先------去https://github.com/junit-team/junit4/wiki/Download-and-Install下载两个jar包
2. 添加jar依赖到工程里面--------可以使用new modules模块---->找到Libraries—>+ 号---->java---->找到想要的jar包对应的文件---->把文件加入到相应的项目里面就可以了.
3. 定义一个测试类

   • 建议:测试包放到测试文件夹里面----->右击项目—>new---->Directory---->右击创建好的文件夹---->Mark Directory as---->Test Source root ---->就建立好了一个测试文件夹

     • 测试类名:被测试的类Test 例如:UserTest
     • 测试类:应该放到测试资源包里面
     • 测试包:XXX.xxx.test 例如:com.zhiyou100.user.test.user

   • 定义测试方法有要求:测试方法区别于之前的main函数.测试方法可以实现独立运行(不管是junit4或者junit5都可以独立运行)不依靠main方法

     • 测试方法名字:test被测试的功能方法 例如: testGetName()
     • 返回值统一要求为void
     • 参数列表: junit4 只能是空参 junit5 参数列表可要可不要
     • 修饰符: 一般来说 junit4 使用public junit5中使用范围很广.可以使用多种修饰符几乎不限制
4. 给方法上面添加注解 @Test
5. 结果判定:如何判断测试是否成功

  Assert.assertEquals(期望值,实际值)
Assert.assertEquals("小孙-----20",result);//然后点击运行小图标,能运行出来表示测试成功
 Assert.assertEquals("小孙-----30",result);//这个表示相同才成功,不同就不成功就会报红
 Assert.assertNotEquals("小孙-----30",result);//表示不同就成功

红色---->测试失败,中间可能出现异常

橘黄色—>测试失败,实际值和期望值不一样

绿色—>测试成功.

junit4和junit5的区别

junit4中

@Test 把一个方法标记为测试方法
@Before 每一个测试方法执行前会调用一次该方法(搭配@Test一起使用)
@After 每一个测试方法执行后会调用一次该方法(搭配@Test一起使用)
@BrforeClass 所有测试方法执行之前执行一次,在测试类没有进行实例化之前已经被加载到,他标记的方法为静态方法（必须用static修饰）(搭配@Test一起使用) 就类似于静态方法 ，可以用于资源加载
@AfterClass 所有测试方法执行之后执行一次,在测试类没有进行实例化之前已经被加载到,他标记的方法为静态方法，（必须用static修饰，(搭配@Test一起使用)，可以用于资源释放
@Ignore 是忽略的意思 被这个注解标注的方法,在测试执行的时候暂时不执行这个测试方法.待定执行(搭配@Test一起使用)

junit4代码演示

首先在测试文件夹,测试包里面写一个Calculator类,junit4里面就是测试这里面的方法

//计算器
public class Calculator {

    //测试相加
    public int addNum(int x,int y){
        return x+y;
    }

    //测试相减
    public int Subtract(int x,int y){
        return x-y;
    }

    //测试相乘
    public int multiply(int x,int y){
        return x*y;
    }

    //测试相除
    public int divide(int x,int y){
        return x*y;
    }


}

然后再去测试文件夹测试包里面写一个测试类CalcyulatorTest

package com.zhiyou100.test.junit4;
import com.zhiyou100.pojo.Calculator;
import org.junit.*;

public class CalcyulatorTest {  //点击这里的绿标就会执行所有的测试方法

    private final Calculator calculator=new Calculator();
    @Before
    public void testBefore(){//每一个测试方法执行之前都会执行一次这个方法
        System.out.println("@Before方法被加载");
    }

    @After
    public void testAfter(){//每一个测试方法执行之后都会执行一次这个方法
        System.out.println("@After方法被加载");
    }

    @BeforeClass  //注意必须用static修饰
    public static void testBeforeClass(){//在所有测试方法执行之前执行一次，只会执行一次
        System.out.println("@BeforeClass方法被加载");
    }

    @AfterClass //注意必须用static修饰
    public static void testAfterClass(){//在所有测试方法执行之后执行一次，只会执行一次
        System.out.println("@AfterClass方法被加载");
    }

    //测试相加
    @Test
    public void testAddNum(){
        //获取实际值
        int actul = calculator.addNum(10, 3);
        //使用断言验证数据是否正确
        Assert.assertEquals("测试值是否为13",13,actul);//正确的
        //Assert.assertEquals("测试值是否为13",12,actul);//不正确的
    }

    //测试相减
    @Test(timeout = 1)//超时测试 单位为毫秒，超过指定时间就是失败,一般是用来测试性能的，
    public void tsstSubtract(){
        int actul = calculator.Subtract(10, 3);
        Assert.assertEquals("期望值未7",7,actul);//正确的
        //Assert.assertEquals("期望值未7",6,actul);//不正确的
//        for(int i=0;i<100000;i++){
//            System.out.println(i);
//        }
    }

    //测试相除
    @Ignore //表示测试的时候不测试这个功能，表示葛洪能还没有写完不在测试范围之内
    public void testDivide(){
        System.out.println("改方法被加载到了");
        int actual = calculator.divide(10, 3);
        Assert.assertEquals("结果只未3",3,actual);//正确的
        //Assert.assertEquals("结果只未3",2,actual);//不正确的
    }

    //测试相乘
    @Test (expected = NullPointerException.class)  //如果出现了空指针异常就测试成功，否则测试失败
    public void testCheng(){
        System.out.println("改方法被加载到了");
        int actual = calculator.multiply(10, 3);
        Assert.assertEquals("结果只未30",30,actual);//正确的
        //Assert.assertEquals("结果只未3",2,actual);//不正确的
    }
}

junit5中

@Test 把一个方法标记为测试方法
@BeforeEach 每一个测试方法执行之前都会自动调用该方法(搭配@Test一起使用)
@AfterEach 每一个测试方法执行后会调用一次该方法(搭配@Test一起使用)
@BrforeAll 所有测试方法执行之前执行一次,在测试类没有进行实例化之前已经被加载到,他标记的方法为静态方法，必须用static修饰，(搭配@Test一起使用) 就类似于静态方法，可以用于资源加载
@AfterAll 所有测试方法执行之后执行一次,在测试类没有进行实例化之前已经被加载到,他标记的方法为静态方法(搭配@Test一起使用)，必须用static修饰，可以用于资源释放
@Disabled 是忽略的意思 被这个注解标注的方法,在测试执行的时候暂时不执行这个测试方法.待定执行(搭配@Test一起使用)

junit5代码演示

首先先在测试文件夹的测试包里面写一个测试类Calculator

package com.zhiyou100.pojo;
//计算器
public class Calculator {

    //测试相加
    public int addNum(int x,int y){
        return x+y;
    }

    //测试相减
    public int Subtract(int x,int y){
        return x-y;
    }

    //测试相乘
    public int multiply(int x,int y){
        return x*y;
    }

    //测试相除
    public int divide(int x,int y){
        return x*y;
    }
}

然后再去测试报里面写一个测试类CalculatorTest

package com.zhiyou100.test.junit5;

import com.zhiyou100.pojo.Calculator;
import org.junit.Assert;
import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;


//junit5里面的jar包与四不同
public class CalcyulatorTest {

    private final Calculator calculator=new Calculator();


    @BeforeEach
    void testBefore(){//每一个测试方法执行之前都会执行一次这个方法,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        System.out.println("@BeforeEach方法被加载");
    }

    @AfterEach
    void testAfter(){//每一个测试方法执行之后都会执行一次这个方法,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        System.out.println("@AfterEach方法被加载");
    }

    @BeforeAll  //注意必须用static修饰
    static void testBeforeClass(){//在所有测试方法执行之前执行一次，只会执行一次,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        System.out.println("@BeforeAll方法被加载");
    }

    @AfterAll //注意必须用static修饰
    static void testAfterClass(){//在所有测试方法执行之后执行一次，只会执行一次,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        System.out.println("@AfterAll方法被加载");
    }



    //测试相加
    @Test
    void testAddNum(){//,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        //获取实际值
        int actul = calculator.addNum(10, 3);
        //使用断言验证数据是否正确
        Assert.assertEquals("测试值是否为13",13,actul);//正确的
        //Assert.assertEquals("测试值是否为13",12,actul);//不正确的
    }

    //测试相减
    @Test
    void tsstSubtract(){//,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
        int actul = calculator.Subtract(10, 3);
        Assert.assertEquals("期望值未7",7,actul);//正确的
        //Assert.assertEquals("期望值未7",6,actul);//不正确的
    }

    //测试相除
    @Disabled //表示测试的时候不测试这个功能，表示葛洪能还没有写完不在测试范围之内,在junit5中修饰符可以不加，private不能修饰，但是在junit4里面必须被加，
    void testDivide(){
        System.out.println("改方法被加载到了");
        int actual = calculator.divide(10, 3);
        Assert.assertEquals("结果只未3",3,actual);//正确的
        //Assert.assertEquals("结果只未3",2,actual);//不正确的
    }
    
//    重复测试10次
    @RepeatedTest(10)
    void repeatedTest() {
        System.out.println("hello world！");
    }
}

静态导入

jdk5之后出现的新特性，只要在import后面加上关键字static就可以把后面的类的static修饰的变量和方法导入到本类中，调用的时候和调用被类中的静态成员没有区别，可以直接通过 类名.属性名调用，，或者直接省略

静态导入格式----import static 包名.类名.静态成员名------>import static 包名.类名.* * 表示导入所有的静态成员

注意事项----方法必须是静态的，如果有多个静态方法重名，就必须添加前缀类名来调用。

@Test里面的属性操作

expected属性，期望测试中有异常信息，格式：@Test(excepted = NullPointerException.class)，如果出现了我们想要的异常就测试成功，如果没有出现这个异常就算测试失败。

 @Test (expected = NullPointerException.class)  //如果出现了空指针异常就测试成功，否则测试失败

Timeout属性，测试方法的执行时间，格式：@Test(Timeout = 5) 单位为毫秒值，表示五毫秒，如果允许时间在设置值之内表示设置成功，如果超出了测试值范围就表示测试失败。

 @Test(timeout = 1)//超时测试 单位为毫秒，超过指定时间就是失败,一般是用来测试性能的，