用JUnit4进行单元测试

た入场券 2022-05-29 03:44 325阅读 0赞

# 1 基本概念 #

测试在软件生命周期中的重要性，不用我多说想必大家也都非常清楚。软件测试有很多分类，从测试的方法上可分为：黑盒测试、白盒测试、静态测试、动态测试等；从软件开发的过程分为：单元测试、集成测试、确认测试、验收、回归等。

在众多的分类中，与开发人员关系最紧密的莫过于单元测试了。像其他种类的测试基本上都是由专门的测试人员来完成，只有单元测试是完全由开发人员来完成的。那么今天我们就来说说什么是单元测试，为什么要进行单元测试，以及如更好的何进行单元测试。

## 1.1 什么是单元测试 ##

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。比如我们可以测试一个类，或者一个类中的一个方法。

## 1.2 为什么要进行单元测试 ##

为什么要进行单元测试？说白了就是单元测试有什么好处，其实测试的好处无非就是减少bug、提高代码质量、使代码易于维护等。单元测试有什么好处请看一下百度百科中归纳的四条：

1、它是一种验证行为。  
程序中的每一项功能都是测试来验证它的正确性。它为以后的开发提供支援。就算是开发后期，我们也可以轻松的增加功能或更改程序结构，而不用担心这个过程中会破坏重要的东西。而且它为代码的重构提供了保障。这样，我们就可以更自由的对程序进行改进。

2、它是一种设计行为。  
编写单元测试将使我们从调用者观察、思考。特别是先写测试（test-first），迫使我们把程序设计成易于调用和可测试的，即迫使我们解除软件中的耦合。

3、它是一种编写文档的行为。  
单元测试是一种无价的文档，它是展示函数或类如何使用的最佳文档。这份文档是可编译、可运行的，并且它保持最新，永远与代码同步。

4、它具有回归性。  
自动化的单元测试避免了代码出现回归，编写完成之后，可以随时随地的快速运行测试。

## 1.3 如何更好的进行单元测试 ##

在讨论如何更好的进行单元测试之前，先来看看我们以前是怎么测试代码的。

以前是这样测试程序的：

![复制代码][copycode.gif]

public int add(int x,int y) {
            return x + y;
        }
            
        public static void main(String args[]) {
            int z = new Junit().add(2, 3);
            System.out.println(z);
        }

![复制代码][copycode.gif]

如上面所示，在测试我们写好的一个方法时，通常是用一个main方法调用一下我们要测试的方法，然后将结果打印一下。现在看来这种方式已经非常out了，所以出现了很多单元测试的工具，如：JUnit、TestNG等。借助它们可以让我们的单元测试变得非常方便、高效。今天就说说如何利用JUnit进行单元测试。

[回到顶部][Link 1]

# 2 Junit4进行单元测试 #

用Junit进行单元测试很方便，尤其是Junit4引入了很多Annotation注解以后。

在测试之前首先要引入junit-4.10.jar

看测试的示例：

## 2.1 准备待测试类 ##

![复制代码][copycode.gif]

package junit;
    
    
    public class Calculator {
    
        public int add(int a, int b) {  
            return a + b;  
        }  
      
        public int minus(int a, int b) {  
            return a - b;  
        }  
      
        public int square(int n) {  
            return n * n;  
        }  
          
        //Bug : 死循环  
        public void squareRoot(int n) {  
            for(; ;)  
                ;  
        }  
          
        public int multiply(int a, int b) {  
            return a * b;  
        }  
      
        public int divide(int a, int b) throws Exception {  
            if (0 == b) {  
                throw new Exception("除数不能为零");  
            }  
            return a / b;  
        }  
    }

![复制代码][copycode.gif]

## 2.2 建立单元测试类 ##

建好以后在该项目的“src”目录上右击，选择new——》JUnit Test Case，然后按下图填写必要信息：

![755171-20161013091135468-136334299.png][]

说明：

1——填写单元测试类所在的包路径

2——填写测试类名称

3——会预先创建一些类，具体功能不清楚

4——选择要测试的类

点击“Next”，选择测试类中待测试的方法：

![755171-20161013091429953-282525714.png][]

点击“Finish”即可。剩下的步骤就是填充测试方法。上面只是说明测试类的构造过程。

使用上面的方法，建立CalculatorTest测试类：

![复制代码][copycode.gif]

package junit;
    
    
    import junit.framework.Assert;
    
    import org.junit.After;
    import org.junit.AfterClass;
    import org.junit.Before;
    import org.junit.BeforeClass;
    import org.junit.Ignore;
    import org.junit.Test;
    
    public class CalculatorTest {
    
    
        private Calculator cal = new Calculator();  
      
        @BeforeClass // 注意,这里必须是static...因为方法将在类被装载的时候就被调用(那时候还没创建实例)  
        public static void before()  
        {  
            System.out.println("global");  
        }  
      
        @AfterClass  
        public static void after() {  
            System.out.println("global destroy");  
        }  
      
        @Before  
        public void setUp() throws Exception {  
            System.out.println("一个测试开始。。");  
        }  
      
        @After  
        public void tearDown() throws Exception {  
            System.out.println("一个测试结束");  
        }  
      
        @Test  
        @Ignore  
        public void testAdd() {  
            int result = cal.add(1, 2);  
            Assert.assertEquals(3, result);  
        }  
      
        @Test  
        public void testMinus() {  
            int result = cal.minus(5, 2);  
            Assert.assertEquals(3, result);  
        }  
      
        @Test  
        public void testMultiply() {  
            int result = cal.multiply(4, 2);  
            Assert.assertEquals(8, result);  
        }  
      
        @Test(timeout = 1000) // 单位为毫秒  
        public void testSquareRoot() {  
            cal.squareRoot(4);  
        }  
      
        @Test(expected = Exception.class)  
        public void testDivide() throws Exception {  
            System.out.println("teddd");  
            cal.divide(4, 0);// 很简单的办法.......  
        }  
      
    //  @Test  
    //  public void testDivide() {  
    //      int result = 0;  
    //      try {  
    //          result = cal.divide(10, 5);  
    //      } catch (Exception e) {  
    //          e.printStackTrace();  
    //          Assert.fail();// 如果这行没有执行。说明这部分正确。  
    //      }  
    //      Assert.assertEquals(2, result);  
    //  }  
    }

![复制代码][copycode.gif]

在Eclipse里Run As -> JUnit Test，运行测试类，Eclipse的JUnit的View显示如：

![755171-20161013091928046-828805829.png][]

可以看到，CalculatorTest类中总共有5个测试用例，ignore了一个，3个测试用例通过，testSquareRoot测试不通过（因为超时），所以整个的测试结果飘红了。同时，控制台的输出结果为：

![755171-20161013092208781-1830270756.png][]

## 2.3 注解说明 ##

各种注解的说明：

![复制代码][copycode.gif]

@Test：
    表明该方法是一个测试方法
     
    @BeforeClass 和 @AfterClass：
    测试用例初始化时执行 @BeforeClass方法，当所有测试执行完毕之后，执行@AfterClass进行收尾工作。标注、@BeforeClass 和 @AfterClass的方法必须是static的，因为方法将在类被装载的时候就被调用，那时候还没创建测试对象实例。
     
    @Before： 
    使用了该元数据的方法在每个测试方法执行之前都要执行一次。
    @After： 
    使用了该元数据的方法在每个测试方法执行之后要执行一次。
     
    @Test(expected=*.class) ：
    通过@Test元数据中的expected属性验证是否抛出期望的异常，expected属性的值是一个异常的类型，如果抛出了期望的异常，则测试通过，否则不通过。
     
    @Test(timeout=xxx)：
    该元数据传入了一个时间（毫秒）给测试方法，如果测试方法在制定的时间之内没有运行完，则测试也失败。
     
    @Ignore： 
    该元数据标记的测试方法在测试中会被忽略。同时可以为该标签传递一个String的参数，来表明为什么会忽略这个测试方法。比如：@lgnore("该方法还没有实现")，在执行的时候，仅会报告该方法没有实现，而不会运行测试方法。
     在test方法内除了使用Assert的assertEquals()方法外，还能使用assertFalse()、assertTrue()、assertNull()、assertNotNull()、assertSame()、assertNotSame()等断言函数。而且如果使用的是Junit4，结合Hamcrest，使用 assertThat([value], [matcher statement])方法可以实现更灵活的断言判断（前提是引入hamcrest的jar包）。
    例如：
    // is匹配符表明如果前面待测的object等于后面给出的object，则测试通过 
    assertThat( testedObj, is( object) ); 
     
    // containsString匹配符表明如果测试的字符串包含指定的子字符串则测试通过
     assertThat( testedString, containsString( "developerWorks" ) );
     
    // greaterThan匹配符表明如果所测试的数值testedNumber大于16.0则测试通过
     assertThat( testedNumber, greaterThan(16.0) ); 
     
    // closeTo匹配符表明如果所测试的浮点型数testedDouble在20.0±0.5范围之内则测试通过 
    assertThat( testedDouble, closeTo( 20.0, 0.5 ) );
     
    //hasItem匹配符表明被测的迭代对象含有元素element项则测试通过assertThat(iterableObject, hasItem (element));

![复制代码][copycode.gif]

![755171-20161013092747828-1039065273.png][]

引入hamcrest-core-1.3.jar和hamcrest-library-1.3.jar

常用hamcrest断言的使用说明：

![复制代码][copycode.gif]

数值类型
    //n大于1并且小于15，则测试通过
    assertThat( n, allOf( greaterThan(1), lessThan(15) ) );
    //n大于16或小于8，则测试通过
    assertThat( n, anyOf( greaterThan(16), lessThan(8) ) );
    //n为任何值，都测试通过
    assertThat( n, anything() );
    //d与3.0的差在±0.3之间，则测试通过
    assertThat( d, closeTo( 3.0, 0.3 ) );
    //d大于等于5.0，则测试通过
    assertThat( d, greaterThanOrEqualTo (5.0) );
    //d小于等于16.0，则测试通过
    assertThat( d, lessThanOrEqualTo (16.0) );
    
    字符类型
    //str的值为“tgb”，则测试通过
    assertThat( str, is( "tgb" ) );
    //str的值不是“tgb”，则测试通过
    assertThat( str, not( "tgb" ) );
    //str的值包含“tgb”，则测试通过
    assertThat( str, containsString( "tgb" ) );
    //str以“tgb”结尾，则测试通过
    assertThat( str, endsWith("tgb" ) ); 
    //str以“tgb”开头，则测试通过
    assertThat( str, startsWith( "tgb" ) ); 
    //str忽略大小写后，值为“tgb”，则测试通过
    assertThat( str, equalToIgnoringCase( "tgb" ) ); 
    //str忽略空格后，值为“tgb”，则测试通过
    assertThat( str, equalToIgnoringWhiteSpace( "tgb" ) );
    //n与nExpected相等，则测试通过（对象之间）
    assertThat( n, equalTo( nExpected ) ); 
    
    collection类型
    //map中包含key和value为“tgb”的键值对，则测试通过
    assertThat( map, hasEntry( "tgb", "tgb" ) );
    //list中包含“tgb”元素，则测试通过
    assertThat( iterable, hasItem ( "tgb" ) );
    //map中包含key为“tgb”的元素，则测试通过
    assertThat( map, hasKey ( "tgb" ) );
    //map中包含value为“tgb”的元素，则测试通过
    assertThat( map, hasValue ( "tgb" ) );

![复制代码][copycode.gif]

## 2.4 进阶 ##

上面的Caculator待测试类里，现在我如果想给square方法多弄几个测试用例，按照上面的方法，我应该写好几个@Test方法来测试，或者每次测完再改一下输入的值和期望得到的值，好麻烦。JUnit提供如下的测试：

![复制代码][copycode.gif]

package hamcrest;
    
    import java.util.Arrays;
    import java.util.Collection;
    
    import junit.Calculator;
    import junit.framework.Assert;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    import org.junit.runners.Parameterized.Parameters;
    
    @RunWith(Parameterized.class)  
    public class CalculatorTest2{  
      
        private Calculator cal = new Calculator();  
        private int param;  
        private int result;  
      
        //构造函数，对变量进行初始化  
        //定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。  
        public CalculatorTest2(int param, int result) {  
               this.param = param;  
               this.result = result;  
        }  
          
        @Parameters  
        public static Collection data(){  
            return Arrays.asList(new Object[][]{  
                {
        2, 4},  
                {
        0, 0},  
                {
        -3, 9},  
          });  
        }  
      
        @Test  
        public void squareTest() {  
            int temp = cal.square(param);  
            Assert.assertEquals(result, temp);  
        }  
    }

![复制代码][copycode.gif]

Eclipse里JUnit的运行结果显示为：

![755171-20161013093238343-789194529.png][]

测试通过了，CalculatorTest2类里的parameter是每次的测试输入，result就是测试的结果。所有的测试输入和期望结果都在@Parameters标注的data函数的返回的Collection集合里，2的期望得到的平方结果值是4，0期望得到0，-3期望得到9。

把测试代码提交给JUnit框架后，框架如何来运行代码呢?答案就是——Runner。在JUnit中有很多个 Runner，他们负责调用测试代码，每一个Runner都有各自的特殊功能，要根据需要选择不同的Runner来运行测试代码。JUnit中有一个默认Runner，如果没有指定，那么系统自动使用默认 Runner来运行你的代码。这里参数化测试就没有再用默认的Runner了。

再看看打包测试测例子：

![复制代码][copycode.gif]

package hamcrest;
    
    import junit.CalculatorTest;
    
    import org.junit.runner.RunWith;
    import org.junit.runners.Suite;
    
    
    /** 
     * 大家可以看到，这个功能也需要使用一个特殊的Runner， 
     * 因此我们需要向@RunWith标注传递一个参数Suite.class。 
     * 同时，我们还需要另外一个标注@Suite.SuiteClasses， 
     * 来表明这个类是一个打包测试类。我们把需要打包的类作为参数传递给该标注就可以了。 
     * 有了这两个标注之后，就已经完整的表达了所有的含义，因此下面的类已经无关紧要， 
     * 随便起一个类名，内容全部为空既可 
     * 
     */  
    @RunWith(Suite.class)  
    @Suite.SuiteClasses({ CalculatorTest.class, CalculatorTest2.class })  
    public class AllCalculatorTests {  
      
    }

![复制代码][copycode.gif]

测试结果：

![755171-20161013093402796-1209526482.png][]

这个测试类包含了上面的CalculatorTest.class和CalculatorTest2.class里面所有的测试函数，它的目的就是进行打包所有的测试。

##  断言 ##

所有的断言都包含在Assert类中

public class Assert extends java.lang.Object

这个类提供了很多有用的断言方法来编写测试用例。只有失败的断言才会被记录。Assert 类中的一些有用的方法列式如下：

1 void assertEquals(boolean expected, boolean actual)  
检查两个变量或者等式是否平衡  
2 void assertTrue(boolean expected, boolean actual)  
检查条件为真  
3 void assertFalse(boolean condition)  
检查条件为假  
4 void assertNotNull(Object object)  
检查对象不为空  
5 void assertNull(Object object)  
检查对象为空  
6 void assertSame(boolean condition)  
assertSame() 方法检查两个相关对象是否指向同一个对象  
7 void assertNotSame(boolean condition)  
assertNotSame() 方法检查两个相关对象是否不指向同一个对象  
8 void assertArrayEquals(expectedArray, resultArray)  
assertArrayEquals() 方法检查两个数组是否相等

[copycode.gif]: /images/20220529/cc116201519f4651b2e410f6577d17d9.png
[Link 1]: http://www.cnblogs.com/lixuwu/p/5954828.html#_labelTop
[755171-20161013091135468-136334299.png]: /images/20220529/c563291947ff4f14b6490d70e3774937.png
[755171-20161013091429953-282525714.png]: /images/20220529/fec2d38645e14df19f09f3af2c7920fb.png
[755171-20161013091928046-828805829.png]: /images/20220529/6920e4592ecb4712a585e96e2f3933f2.png
[755171-20161013092208781-1830270756.png]: /images/20220529/9c2f1709744c461ea8ba26f6eb381969.png
[755171-20161013092747828-1039065273.png]: /images/20220529/8772a6304b7140e69e2b041874e925b3.png
[755171-20161013093238343-789194529.png]: /images/20220529/9b88e335f8294b35bd20fd51be001ed4.png
[755171-20161013093402796-1209526482.png]: /images/20220529/6a485acb54b544b1b66a87d283d83d9a.png