自动化测试之idea+gradle+JUnit的使用（参数化测试与非参数化测试）

本次博客更新的是，上次使用eclise+JUint测试完，想用idea进行测试，同时maven项目已经学习过了，想学习新的知识为前提。

知识储备，

Gradle是什么
Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，目前也增加了基于Kotlin语言的kotlin-based DSL，抛弃了基于XML的各种繁琐配置

如需更多理解，推荐博客https://www.cnblogs.com/Bonker/p/5619458.html

我的理解就是类似于Maven这样子的一个包管理工具，然后导入的时候，用的不是pom文件，然后可以支持从maven库里面直接拉代码

新的东西肯定需要新的配置，mac配置有空写，windows配置一大堆，百度找，不是重点。

正文

测试题目如下

请依据提供的程序(改成java程序)，采用逻辑覆盖进行白盒测试用例设计（Z路径覆盖）。 
 Int main(int argc, _TCHAR * argv[])
{
      int x,y;
      scanf( “%d%d”,&x&y);
      if (x>10&&y>10 )
      { 
int i=1;
         if(x>y)
         {
            while( (x*i) %y!=0 )
               i++;
            printf(“%d \n ”,x*i);
}
else{
             while( (y*i) %x!=0 )
               i++;
             printf(“%d \n ”,y*i);
}
} 
return 0;
}

• 依旧是先设计一下思路，

  1.分析代码
  2.画出流程图
  3.分析一下白盒的几种逻辑覆盖的路径
  4.开始写测试用例
  -------------------------------------分界线----------------------------------------------

代码分析：没啥好分析的，if语句里面，套了一个if语句，然后在判定条件进行循环

流程图：

分析逻辑：
前提是知道白盒测试的几种覆盖逻辑，推荐博客如下
https://blog.csdn.net/write6/article/details/78702977

如下：

开始写测试用例：
先搭建一个gradle项目，

这几个选中为，采用自动导入，使用本地的gradle库，用的Jdk1.8

点了next就会生成一个gradle，同时默认添加Junit依赖，同时会生成对应的Test文件夹，选中测试类，和上一篇文章一样，可以直接生成在Test文件夹里面的测试类。

然后，按照要求改为Java代码，如下

public int baihe(int x, int y) {
        if (x > 10 && y > 10) {
            int i = 1;
            if (x > y) {
                while ((x * i) % y != 0)
                    i++;
                System.out.println(x * i);
                return x*i;

                //printf(“%d \n ”,x*i);
            } else {
                while ((y * i) % x != 0)
                    i++;
                System.out.println(y * i);
                return y * i;
                //printf(“%d \n ”,y*i);
            }
        }
        return 0;
    }

下面的测试代码就针对着这么一个函数进行测试就行。

非参数化测试
非参数化测试就是，一个一个输入测试用例，一个一个给x，y进行赋值，和上一篇文章一样，不多说，直接贴代码

package com.company;

import org.junit.Test;

import static org.junit.Assert.*;
//非参数化测试
public class MainTest {
    Main main = new Main();

    @Test
    public void baihe0() {
        int result = main.baihe(12,11);
        assertEquals(132,result);
    }

    @Test
    public void baihe1() {
        int result = main.baihe(10,10);
        assertEquals(0,result);
    }

    @Test
    public void baihe2() {
        int result = main.baihe(11,11);
        assertEquals(11,result);
    }

    @Test
    public void baihe3() {
        int result = main.baihe(24,12);
        assertEquals(24,result);
    }

    @Test
    public void baihe4() {
        int result = main.baihe(11,12);
        assertEquals(132,result);
    }

    @Test
    public void baihe5() {
        int result = main.baihe(12,10);
        assertEquals(0,result);
    }

    @Test
    public void baihe6() {
        int result = main.baihe(10,12);
        assertEquals(0,result);
    }

    @Test
    public void baihe7() {
        int result = main.baihe(10,10);
        assertEquals(0,result);
    }

    @Test
    public void baihe8() {
        int result = main.baihe(24,12);
        assertEquals(24,result);
    }

    @Test
    public void baihe9() {
        int result = main.baihe(11,12);
        assertEquals(132,result);
    }

    @Test
    public void baihe10() {
        int result = main.baihe(12,24);
        assertEquals(24,result);
    }

    @Test
    public void baihe11() {
        int result = main.baihe(10,10);
        assertEquals(0,result);
    }

    @Test
    public void baihe12() {
        int result = main.baihe(12,11);
        assertEquals(132,result);
    }

    @Test
    public void baihe13() {
        int result = main.baihe(11,12);
        assertEquals(132,result);
    }

    @Test
    public void baihe14() {
        int result = main.baihe(24,12);
        assertEquals(24,result);
    }

    @Test
    public void baihe15() {
        int result = main.baihe(12,24);
        assertEquals(24,result);
    }



}

参数化测试
@RunWith, 当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器。

要进行参数化测试，需要在类上面指定如下的运行器：
　　@RunWith (Parameterized.class)

然后，在提供数据的方法上加上一个@Parameters注解，这个方法必须是静态static的，并且返回一个集合Collection。

在测试类的构造方法中为各个参数赋值，（构造方法是由JUnit调用的），最后编写测试类，它会根据参数的组数来运行测试多次。

注意：必须要为类的所有字段赋值，不管你是不是都用到！否则，Junit会出错。

package com.company;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

import static org.junit.Assert.*;
//参数化测试
//@RunWith, 当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器
@RunWith(Parameterized.class)//
public class MainTest2 {
    private Main main = new Main();
    private int param;
    private int result;
    private int x;
    private int y;
    private int expect;
	
	//这里的注解是添加参数
    @Parameterized.Parameters
    public static Collection data(){
        Object [][] object = {
                {12,11,132},{11,12,132},//语句覆盖
                {12,11,132},{11,12,132},{11,11,11},//判定覆盖
                {12,11,132},{10,10,0},{11,12,132},{11,11,11},{24,12,24},//条件覆盖
                {12,11,132},{10,10,0},{11,11,11},{24,12,24}, {11,12,132},//判定条件覆盖
                {12,11,132},{12,10,0},{10,12,0},{10,10,0},{24,12,24},{11,12,132},{12,24,24},//条件组合覆盖
                {10,10,0},{12,11,132},{11,12,132},{24,12,24},{12,24,24}//路径覆盖
        };
        return Arrays.asList(object);
    }

    public  MainTest2(int x,int y,int expect){
        this.x = x;
        this.y = y;
        this.expect = expect;
    }

    @Test
    public void baihe1(){
        int result = main.baihe(x,y);
        Assert.assertEquals(expect, result);
    }



}

测试代码写完了以后，选中非参数化测试和参数化测试，run一下这俩个测试类，可以发现，测试都通过了，下面是截图。

非参数化测试：

参数化测试：

参考了很多前辈的文档这才把这么简单的东西做出来，感谢曾经的前行者。下面是部分参考的博客

https://www.cnblogs.com/byron0918/p/4801152.html

https://www.cnblogs.com/Bonker/p/5619458.html

https://www.cnblogs.com/xingyunblog/p/10428178.html

ps：同时感谢小赵同学的合作。