junit测试用例和测试套件的简单使用

 

JUnit - 概述

所谓单元测试是测试应用程序的功能是否能够按需要正常运行，并且确保是在开发人员的水平上，单元测试生成图片。单元测试是一个对单一实体（类或方法）的测试。单元测试是每个软件公司提高产品质量、满足客户需求的重要环节。

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

JUnit 促进了“先测试后编码”的理念，强调建立测试数据的一段代码，可以先测试，然后再应用。这个方法就好比“测试一点，编码一点，测试一点，编码一点……”，增加了程序员的产量和程序的稳定性，可以减少程序员的压力和花费在排错上的时间。

特点：

• JUnit 是一个开放的资源框架，用于编写和运行测试。 
• 提供注释来识别测试方法。 
• 提供断言来测试预期结果。 
• 提供测试运行来运行测试。 
• JUnit 测试允许你编写代码更快，并能提高质量。 
• JUnit 优雅简洁。没那么复杂，花费时间较少。
• JUnit 测试可以自动运行并且检查自身结果并提供即时反馈。所以也没有必要人工梳理测试结果的报告。
• JUnit 测试可以被组织为测试套件，包含测试用例，甚至其他的测试套件。
• JUnit 在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。

测试用例：

1.新建NumberMethods类，里面写好方法：

package demo;
/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午4:16:49
 *@version 1.0
 */

public class NumberMethods {
    
    public int getCount(int i,int j){
        return i+j;
    }
    public int getSuntract(int i,int j){
        return i-j;
    }
    public float getDivision(int i,int j){
        return i/j;
    }
    public float getPlus(int i,int j){
        return i*j;
    }
}

2.新建NumberTest测试类，用于测试:

新建操作如下

 

正在测试的类 打自己的类名

选择下一步，选中类中要测试的方法

然后会生成每个方法的默认测试方法，里面默认写了一个类似报错的方法fail()，重写每个方法：

package demo;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午4:21:31
 *@version 1.0
 */

public class NumberTest {
    static NumberMethods num=null;
    
    @BeforeClass
    public static void initclass(){
        System.out.println("@BeforeClass");
        num=new NumberMethods();
    }
    
    @AfterClass
    public static void afterclass(){
        System.out.println("@AfterClass");
        num=new NumberMethods();
    }
    
    @Before
    public void init(){
        System.out.println("@Before");
    }
    
    @After
    public void after(){
        System.out.println("@After");
    }
    @Test
    public void testGetCount() {
        NumberMethods number=new NumberMethods();
        int a=number.getCount(2, 4);
        assertEquals("计算错误", 6, a);
        System.out.println("测试加法通过");
    }

    @Test
    public void testGetSuntract() {
        System.out.println("测试减法通过");
    }

    @Test
    public void testGetDivision() {
        System.out.println("测试除法通过");
    }

    @Test
    public void testGetPlus() {
        System.out.println("测试乘法通过");
    }

}

鼠标右键>运行方式>junit测试

@BeforeClass用于初始化，只执行一次，由于其是在jvm还没加载类之前执行，所以初始化的资源必须为静态。
@AfterClass用于类后执行，只执行一次。

 @Before每个方法之前执行

@After每个方法之后执行

测试套件：

在实际项目中，随着项目进度的开展，单元测试类会越来越多，可是直到现在我们还只会一个一个的单独运行测试类，这在实际项目实践中肯定是不可行的。为了解决这个问题，JUnit 提供了一种批量运行测试类的方法，叫做测试套件。

这样，每次需要验证系统功能正确性时，只执行一个或几个测试套件便可以了。测试套件的写法非常简单，我们需要遵循以下规则：

1.  创建一个空类作为测试套件的入口。

2.  使用注解 org.junit.runner.RunWith 和 org.junit.runners.Suite.SuiteClasses 修饰这个空类。

3.  将 org.junit.runners.Suite 作为参数传入注解 RunWith，以提示 JUnit 为此类使用套件运行器执行。

4.  将需要放入此测试套件的测试类组成数组作为注解 SuiteClasses 的参数。

5.  保证这个空类使用 public 修饰，而且存在公开的不带有任何参数的构造函数。

 

新建JunitTestOne测试类：

package test;


import org.junit.Assert;
import org.junit.Test;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午3:56:17
 *@version 1.0
 */

public class JunitTestOne {

    @Test
    public void test() {
        System.out.println("测试一。。。");  
        Assert.assertTrue(true);  
    }

}

新建JunitTestTwo测试类：

package test;


import org.junit.Assert;
import org.junit.Test;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午3:58:56
 *@version 1.0
 */

public class JunitTestTwo {

    @Test
    public void test() {
         System.out.println("测试二。。。");  
         Assert.assertTrue(true);  
    }

}

新建测试套件类:

package test;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午4:00:06
 *@version 1.0
 */

@RunWith(Suite.class)
@SuiteClasses({ JunitTestOne.class,JunitTestTwo.class })
public class AllTests {

}

 测试通过，控制台输出：

 

上例代码中，我将2个测试类放入了测试套件AllTests中，在 Eclipse 中运行测试套件，可以看到2个测试类被调用执行了。测试套件中不仅可以包含基本的测试类，而且可以包含其它的测试套件，这样可以很方便的分层管理不同模块的单元测试代码。

注意：一定要保证测试套件之间没有循环包含关系，否则无尽的循环就会出现在我们的面前。

 

 

 

 

下面写一个例子

新建AllTestsTwo测试类，包含测试类JunitTestOne、JunitTestTwo、AllTests：

package test;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午4:07:08
 *@version 1.0
 */

@RunWith(Suite.class)
@SuiteClasses({ AllTests.class, JunitTestOne.class, JunitTestTwo.class })
public class AllTestsTwo {

}

再给AllTests测试类@SuiteClasses中添加AllTestsTwo：

package test;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

/**类描述：
 *@author: zk
 *@date： 日期：2018-6-6 时间：下午4:00:06
 *@version 1.0
 */

@RunWith(Suite.class)
@SuiteClasses({ AllTestsTwo.class,  JunitTestOne.class,JunitTestTwo.class })
public class AllTests {

}

然后执行AllTests的junit测试：

报错，原因就是AllTests测试的AllTestsTwo包含对AllTests的测试。