当前位置: 首页>编程语言>正文

testsuit 套件 junit testimplementation 'junit:junit:4.12'

Junit4单元测试的基本用法 快速入门

    • 单元测试
    • 添加依赖
    • Caculate 类测试
    • 执行顺序
    • Test的两个属性——细讲

单元测试

第一篇博客开始啦,用这个记录一下学习的过程,就相当于一个笔记,希望能一直坚持下去哦!

哈哈哈,大佬就勿看啦!这个给纯小白看的!嘻嘻嘻嘻

单元测试可以帮助我们验证程序的逻辑是否正确、可以降低bug修复的成本、更有利于代码重构等等。所以,我们在写代码的时候,尽量保证单元测试的覆盖率。能力好的可以先写测试用例,再写功能代码(测试先行)。

添加依赖

1、在build gradle(Module:app) 的dependencies添加依赖

	testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

Caculate 类测试

1、创建一个Caculate类
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第1张
里面先写四个方法,runadd(),runequal(),runmul(),runmul()

package com.example.testdemo;

public class Caculate {

    public int runadd(int a, int b){
        return a+b;
    }

    public int runequal(int a, int b){
        return a-b;
    }

    public int runmul(int a, int b){
        return a*b;
    }

    public int rundivide(int a,int b) throws Exception{
        if(b == 0){
            throw new Exception("被除数不能为0");
        }else{
            return a/b;
        }
    }
}

2、右键Caculate类名,点Go To Test
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第2张
选择JUnit4,因为Android studio 已经帮我们集成好了,下面Member中的四个方法要打勾,生成需要测试的代码,点击ok
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第3张

这时可以看到测试方法已经构建完了,我们开始在方法体中写具体的实现方法了。这里我写了一个CaculateTest构造方法,后面要用到滴,然后还写了个@Ignore,这后面也要用到先写上来了。

package com.example.testdemo;

import android.util.Log;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.*;

public class CaculateTest {

    public CaculateTest() {
        System.out.println("构造方法");
    }

    @BeforeClass
    public static void setUpBeforeClass() {
        System.out.println("BeforeClass");
    }

    @AfterClass
    public static void tearDownAfterClass() {
        System.out.println("AfterClass");
    }

    @Before
    public void setUp() throws Exception {
        System.out.println("Before");
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("After");
    }

    @Test
    public void runadd() {
        System.out.println("Test__runadd");
        assertEquals(7, new Caculate().runadd(2,3));
//        Caculate caculate =new Caculate();
//        int r= caculate.runadd(2,3);
//        assertEquals(r,5);

        //可以把这三行代码写成一段
        //assertEquals(5, new Claculate().add(2, 3));
        /**assertEquals这个方法是一个断言方法
         第一个参数表示预期的结果
         第二个参数表示程序的执行结果
         当预期结果与执行结果是一致的时候,则表示单元测试成功
         **/
    }

    @Test
    public void runequal() {
        System.out.println("Test__runequal");
        Caculate caculate =new Caculate();
        int r= caculate.runadd(2,3);
        assertEquals(r,5);
    }

    @Test
    public void runmul(){
        System.out.println("Test__runmul");
        assertEquals(20,new Caculate().runmul(4,5));
    }

    @Ignore
    @Test(expected = Exception.class)
    public void rundivide() throws Exception{
        System.out.println("Test__rundivide");
        assertEquals(2,new Caculate().rundivide(4,2));
        fail("被除数不能为0");
    }
}

上面我把2+3的结果故意写错,写成7,这样在运行test时,它就会报错,更方便我们了解。

执行Test代码,可以执行所有代码,在CaculateTest右键,run Test
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第4张

执行结果如下:
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第5张

如果我们把7,改为5,那么运行就不会报错了,运行成功结果如下:
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第6张

执行顺序

JUnit4利用JDK5的新特性Annotation,使用注解来定义测试规则。这里讲一下以下几个常用的注解:

  • @Test:把一个方法标记为测试方法
    • @Test(excepted=xx.class): xx.class表示异常类,表示测试的方法抛出此异常时,认为是正常的测试通过的
    • @Test(timeout=毫秒数) :测试方法执行时间是否符合预期
  • @Before:每一个测试方法执行前自动调用一次
  • @After:每一个测试方法执行完自动调用一次
  • @BeforeClass:所有测试方法执行前执行一次,在测试类还没有实例化就已经被加载,所以用static修饰,通常进行一些资源的加载。
  • @AfterClass:所有测试方法执行完执行一次,在测试类还没有实例化就已经被加载,所以用static修饰,通常用来释放资源。
  • @Ignore:暂不执行该测试方法
  • @RunWith:可以更改测试运行器org.junit.runner.Runner
  • Parameters:参数化注解
package com.example.testdemo;

import android.util.Log;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.*;

public class CaculateTest {

    public CaculateTest() {
        System.out.println("构造方法");
    }

    @BeforeClass
    public static void setUpBeforeClass() {
        System.out.println("BeforeClass");
    }

    @AfterClass
    public static void tearDownAfterClass() {
        System.out.println("AfterClass");
    }

    @Before
    public void setUp() throws Exception {
        System.out.println("Before");
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("After");
    }

    @Test
    public void runadd() {
        System.out.println("Test__runadd");
        assertEquals(5, new Caculate().runadd(2,3));
//        Caculate caculate =new Caculate();
//        int r= caculate.runadd(2,3);
//        assertEquals(r,5);

        //可以把这三行代码写成一段
        //assertEquals(5, new Claculate().add(2, 3));
        /**assertEquals这个方法是一个断言方法
         第一个参数表示预期的结果
         第二个参数表示程序的执行结果
         当预期结果与执行结果是一致的时候,则表示单元测试成功
         **/
    }

    @Test
    public void runequal() {
        System.out.println("Test__runequal");
        Caculate caculate =new Caculate();
        int r= caculate.runadd(2,3);
        assertEquals(r,5);
    }

    @Test
    public void runmul(){
        System.out.println("Test__runmul");
        assertEquals(20,new Caculate().runmul(4,5));
    }

    @Ignore
    @Test(expected = Exception.class)
    public void rundivide() throws Exception{
        System.out.println("Test__rundivide");
        assertEquals(2,new Caculate().rundivide(4,2));
        fail("被除数不能为0");
    }
}

运行结果
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第7张

  • @BeforeClass和@AfterClass在类被实例化前(构造方法执行前)就被调用了,而且只执行一次,通常用来初始化和关闭资源。

  • @Before和@After和在每个@Test执行前后都会被执行一次。

  • @Test标记一个方法为测试方法没什么好说的,被@Ignore标记的测试方法不会被执行,例如这个模块还没完成或者现在想测试别的不想测试这一块。

  • 以上有一个问题,构造方法居然被执行了三次次。所以我这里要说明一下,JUnit4为了保证每个测试方法都是单元测试,是独立的互不影响。所以每个测试方法执行前都会重新实例化测试类。

Test的两个属性——细讲

我们都能看到上面Test中有两个属性,一个异常类,还有个检测时间逾期问题,那么下面通过一个例子带大家详细了解一下。

我们可以看到在Caculate类里面有一个rundivide()方法,执行除法,运算时时不允许被除数为0的,这时候就要抛出异常

 public int rundivide(int a,int b) throws Exception{
        if(b == 0){
            throw new Exception("被除数不能为0");
        }else{
            return a/b;
        }
    }

然后去CaculateTest测试类中,将@Ignore删除

   @Test(expected = Exception.class)
    public void rundivide() throws Exception{
        System.out.println("Test__rundivide");
        assertEquals(2,new Caculate().rundivide(4,2));
        fail("被除数参数为0没有抛出异常");
    }

我们将被除数设置为不为0的数,执行结果如下
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第8张
将参数设为0,结果如下
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第9张
这个方法就是(expected = Exception.class)和fail(“被除数参数为0没有抛出异常”);之间的配合。就是这个测试方法会检查是否抛出Exception异常(当然也可以检测是否抛出其它异常),如果抛出了异常那么测试通过(因为你的预期就是传进负数会抛出异常)。没有抛出异常则测试不通过执行fail(“被除数参数为0没有抛出异常”);

然后说下timeout属性,这个是用来测试性能的,就是测试一个方法能不能在规定时间内完成。
在Caculate类里面添加一个新的方法sort(),创建一个数组排序的方法,用的是冒泡排序。

public void sort(int[] arr) {
        //冒泡排序
        for (int i = 0; i < arr.length - 1; i++) { //控制比较轮数
            for (int j = 0; j < arr.length - i - 1; j++) { //控制每轮的两两比较次数
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

接下来在CaculateTest类中添加测试方法,随机生成一个长度为50000的数组然后测试排序所用时间。timeout的值为2000,单位和毫秒,也就是说超出2秒将视为测试不通过。

   @Test(timeout = 2000)
    public void runSort() throws Exception {
        int[] arr = new int[50000]; //数组长度为50000
        int arrLength = arr.length;
        //随机生成数组元素
        Random r = new Random();
        for (int i = 0; i < arrLength; i++) {
            arr[i] = r.nextInt(arrLength);
        }
        new Caculate().sort(arr);
    }

运行CaculateTest,测试结果不通过,
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第10张
那接下来,该怎么办呢?我想大家应该都知道了吧,将sort()方法进行改进,用一种快速的排序方法——快速排序

 public void sort(int[] arr) {
        //快速排序
        if (arr.length <= 1) {
            return;
        } else {
            partition(arr, 0, arr.length - 1);
        }

    }

    static void partition(int[] arr, int left, int right) {
        int i = left;
        int j = right;
        int pivotKey = arr[left]; //基准数

        while (i < j) {

            while (i < j && arr[j] >= pivotKey) {
                j--;
            }

            while (i < j && arr[i] <= pivotKey) {
                i++;
            }

            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        if (i != left) {
            arr[left] = arr[i];
            arr[i] = pivotKey;
        }

        if (i - left > 1) {
            partition(arr, left, i - 1);
        }

        if (right - j > 1) {
            partition(arr, j + 1, right);
        }
    }

再运行一次,就完美通过啦!
testsuit 套件 junit testimplementation 'junit:junit:4.12',testsuit 套件 junit testimplementation ,第11张


https://www.xamrdz.com/lan/5ne1967433.html

相关文章: