什么是单元测试
  我们在编写大型程序的时候,需要写成千上万个方法或函数,这些函数的功能可能很强大,但我们在程序中只用到该函数的一小部分功能,并且经过调试可以确定,这一小部分功能是正确的。但是,我们同时应该确保每一个函数都完全正确,因为如果我们今后如果对程序进行扩展,用到了某个函数的其他功能,而这个功能有bug的话,那绝对是一件非常郁闷的事情。所以说,每编写完一个函数之后,都应该对这个函数的方方面面进行测试,这样的测试我们称之为单元测试。传统的编程方式,进行单元测试是一件很麻烦的事情,你要重新写另外一个程序,在该程序中调用你需要测试的方法,并且仔细观察运行结果,看看是否有错。这样的话太过于麻烦了,本文简要介绍一下在Eclipse中使用JUnit4进行单元测试的方法。用更加通俗的话来描述单元测试就是:写了个类,要给别人用,会不会有bug?怎么办?测试一下。用main方法测试好不好?这种方法我们经常用,就是写一个方法实现一些功能,把方法的调用方式放在main函数中。这样的测试方式一个是使得main函数太过于混乱,再者测试过程需要人的仔细观察来辨别每个函数的功能实现,哪一个函数出错了,哪一个函数没有输出之类的问题层出不穷,单元测试就是来解决这些问题的。下面我会就单元测试的每一步给出详细的图解和描述。

第一部分

我们先创建一个Java Project,名字就叫做JUnit4,然后创建两个包com.itcast.junit4和com.itcast.junit4.test,如下图所示

java 正规单元测试 java的单元测试怎么写_java


其中com.itcast.junit4用于我们自己写的类和方法的存放,com.itcast.junit4.test用于我们完成单元测试

在com.itcast.junit4包中创建一个类叫做T(名字可以是任意的,这里是为了方便),在类中添加两个方法add和divide实现两个数的加法和除法运算

package com.itcast.junit4;
   
  public class T {
   
      public int add(int x,int y){
          return x+y;
      }
      public int divide(int x,int y){
          return x/y;
     }
     public static void main(String[] args) {
         int z=new T().add(3, 5);
         System.out.println(z);
     }
  
 }

我们传统测试的方法通常都是按上面的方式去看add函数是否可以实现我们想要的功能,把方法的调用放在main函数中。下面我们看一下单元测试到底是什么东西:

在com.itcast.junit4.test包中创建一个类,叫做TTest(单元测试命名规范:a) 类放在test包中;b) 类名用XXXTest结尾;c) 方法用testMethod命名;)

java 正规单元测试 java的单元测试怎么写_java 正规单元测试_02


【步骤提示】com.itcast.junit4.test包–>右键–>New–Junit Test Case,然后选择New Junit 4 test,那个Junit 3已经过时了。下面的一行Class under test,单击右侧的Browser,在弹出的输入框中输入我们想要测试的类名T,选中单击next出现了一个界面要我们选择需要测试的方法,我们这里选择add方法和divide;

java 正规单元测试 java的单元测试怎么写_java_03


java 正规单元测试 java的单元测试怎么写_junit_04


接着出现了下面的界面:

java 正规单元测试 java的单元测试怎么写_junit_05


这一步提示我们是否将我们需要的JUnit 4的相关包加入到我们项目的ClassPath路径下,点击OK就行,因为Eclipse中包含JUnit的jar包,我们暂且先用Eclipse自带的Junit4去测试,后面后将如何用我们自己下载的JUnit4 JAR包。

做完上面的步骤会创建一个这样的测试类

import static org.junit.Assert.*;
   
  import org.junit.Test;
   
  public class TTest {
   
      @Test
      public void testAdd() {
          fail("Not yet implemented");
     }
  
     @Test
     public void testDivide() {
         fail("Not yet implemented");
     }
  
 }

上面的org.junit.Assert.*;就是静态导入的我们实现单元测试要用到的一些方法;【注意】这是静态引入,可以把方法直接引入,org.junit.Assert是一个类,不是一个包,当然这些方法肯定都是静态方法了。出现的代码都是Assert类中的一些方法,"@Test”表明下面这个方法是一个测试方法,我们先删除自动生成的fail()函数的代码。添加以下代码:

public class TTest {
  
     @Test
     public void testAdd() {
         int z=new T().add(2, 4);
         //判断z==6,以往的assert
         assertEquals(6, z);
     }
  
    @Test
    public void testDivide() {
        //测试T类中的divide方法
        int z=new T().divide(8, 2);
        System.out.println(z);
    }
 
}

我们现在开始进行测试:要测试的方法–>右键–>Run As–>JUnit Test

java 正规单元测试 java的单元测试怎么写_junit_06


如果你想两个方法一块测试,则Run As–>选择Run Configurations:按图中选择相应的选项,然后点击Run

java 正规单元测试 java的单元测试怎么写_Test_07


点击run会出现下面的结果:

java 正规单元测试 java的单元测试怎么写_java 正规单元测试_08


绿条显示两个方法的功能没有错误,有这样的调试准则:keep the bar green,to keep the code clean,绿色代表测试成功,其中Error:程序出错 Failures:测试失败

Error:是程序有问题,比如我们在testAdd方法中加上这一句:int a=8/0;再次测试这个方法则会出现一个Error

public void testAdd() {
        int z=new T().add(2, 4);
        //判断z==6,以往的assert
        assertEquals(6, z);
        int a=8/0;
}

java 正规单元测试 java的单元测试怎么写_junit_09


可以看到最下方提示我们,我们写的方法中出现了除数为0的情况

Failures:测试失败,比如我们在方法改成下面的形式:

public void testAdd() {
        int z=new T().add(2, 4);
        //判断z==6,以往的assert
        assertEquals(6, z);
        assertTrue(z<3);
//        int a=8/0;
}

再次测试一下我们的方法:则会出现调试失败的情况

java 正规单元测试 java的单元测试怎么写_java 正规单元测试_10

第二部分

通过上面的学习我们已经了解基本的单元测试的步骤,我们查看一下JUnit API可以看到org.junit.Assert类有很多类似于assertEquals(6, z);assertTrue(z<3);之类的方法的使用;

java 正规单元测试 java的单元测试怎么写_java 正规单元测试_11


我们可以看到有很多方法都是以重载的形式出现的,比如我们前面的例子,在testAdd()方法中添加assertTrue(“z too small”,z>10);前面的字符串用于在我们测试失败的情况下给我们提示:因为8<10,所以会在测试失败的情况下给我们提示"z too small";

重磅出击:assertThat

assertThat(来自hamcrest包,所以我们需要下载hamcrest这个包,这里共享给大家,里面有很多我们平时都可以用到的JAR包和文件,地址:链接:http://pan.baidu.com/s/1sl02DOD 密码:ci5m): assertThat(actual, matcher);的出现可以替代其他所有的assert。放弃旧的断言,使用hamcrest断言。其中actual参数是实际的值,matcher可以是一个匹配器。在以后的项目开发中我们就可以使用assertThat代替前面出现的类如assertEquals(6, z); assertTrue(z<3);方法。

首先第一步,我们想使用assertThat,需要添加两个jar包hamcrest-core-1.2和hamcrest-library-1.2,这两个包都在我的共享里了,想在把这两个包添加进我们的Java Project中JUnit4 Test–>右键–>Build Path–>Add External Archives,将这两个Jar加进去

java 正规单元测试 java的单元测试怎么写_java 正规单元测试_12


添加以后:我们就可以使用assertThat了

java 正规单元测试 java的单元测试怎么写_单元测试_13


我们把testAdd()方法改成下面的形式:

@Test
    public void testAdd() {
        int z=new T().add(2, 4);
        assertThat(z, is(8));
        //判断z==6,以往的assert
//        assertEquals(6, z);
//        assertTrue(z<3);
//        int a=8/0;
    }

代码中的is()方法是在import static org.hamcrest.Matchers(这个类在我们加进来的hamcrest-core-1.2.jar内)类的一个方法我们需要将其静态引入,所以在最上面要加上下面这一句,应该就可以了;

import static org.hamcrest.Matchers.*;

但是,测试又出现了这样的错误:

java 正规单元测试 java的单元测试怎么写_单元测试_14


我们可以看到Failure Trace第一行什么ClassLoader的错误,这是因为我们在这里用了两种包,一个是hamcrest包,一个是JUnit4的包,这两个包它们的ClassLoader用的不是一个(不清楚啥是ClassLoader,不要紧,先学会怎么解决,以后再研究)。解决方法很简单:在我们的JUnit4项目中–>右键JUnit->Build Path–>Remove from Build Path即可,如图所示:

java 正规单元测试 java的单元测试怎么写_java_15


然后我们自己将JUnit包引入进来(Junit也在我的分享文件中)JUnit4 Test–>右键–>Build Path–>Add External Archives,选择我们JUnit包中的junit-4.10,如下图所示:

java 正规单元测试 java的单元测试怎么写_单元测试_16


ok!测试成功!

assert的使用是测试代码更加自然(诸如这样的理解:z is 8),自己可以体会一下,下面给出一些实例,大家可以自己动手试一下

示例
a)assertThat( n, allOf( greaterThan(1), lessThan(15) ) );
assertThat( n, anyOf( greaterThan(16), lessThan(8) ) );
assertThat( n, anything() );
assertThat( str, is( "bjsxt" ) );
assertThat( str, not( "bjxxt" ) );
 
b)assertThat( str, containsString( "bjsxt" ) );
assertThat( str, endsWith("bjsxt" ) );
assertThat( str, startsWith( "bjsxt" ) );
assertThat( n, equalTo( nExpected ) );
assertThat( str, equalToIgnoringCase( "bjsxt" ) );
assertThat( str, equalToIgnoringWhiteSpace( "bjsxt" ) );
 
c)assertThat( d, closeTo( 3.0, 0.3 ) );
assertThat( d, greaterThan(3.0) );
assertThat( d, lessThan (10.0) );
assertThat( d, greaterThanOrEqualTo (5.0) );
assertThat( d, lessThanOrEqualTo (16.0) );
 
d)assertThat( map, hasEntry( "bjsxt", "bjsxt" ) );
assertThat( iterable, hasItem ( "bjsxt" ) );
assertThat( map, hasKey ( "bjsxt" ) );
assertThat( map, hasValue ( "bjsxt" ) );

第三部分 JUnit4 Annotation

几种常见的注释形式:

@Test: 测试方法
 a) (expected=XXException.class)
  
 b) (timeout=xxx)
  
 @Ignore: 被忽略的测试方法
 @Before: 每一个测试方法之前运行
 @After: 每一个测试方法之后运行
 @BeforeClass: 所有测试开始之前运行
@AfterClass: 所有测试结束之后运行

我们分别进行解释

1)@Test,前面已经说明了,@Test注解表明下面的方法是一个测试方法,a), b)两种形式,比如@Test(expected=java.lang.ArithmeticException.class,timeout=100)a是在测试出现异常的情况下告知我们出现的异常信息,类似与try-catch中的e.printstacktrace() 方法,比较简单。b中的timeout=100,运行时间限制在100ms以内(通常在测试代码运行效率时这样设置)

2)@ignore: 被忽略的测试方法(就是测试的时候跳过ignor标记的模块或方法)
有时候某些方法还不具备测试的条件,暂时还不能测试或者某些方法已经不需要再做测试了,这就可以进行忽略的操作了。
有时方法的测试条件还没满足,整个项目还差一个模块,则可以采用该方法假定测试条件成立。

3)@after和@before

我们把代码改成这个样子:为方便起见先把那个divide方法删掉

public class TTest {
    @Before
    public void before() {
        System.out.println("befor");
    }
 
    @Test
    public void testAdd() {
        int z = new T().add(2, 4);
        assertThat(z, is(8));
        // 判断z==6,以往的assert
        // assertEquals(6, z);
        // assertTrue(z<3);
        // int a=8/0;
    }
 
    @After
    public void after() {
        System.out.println("after");
    }
 
}

当然需要在上面需要添加这两句:

import org.junit.After;
import org.junit.Before;

测试一下我们的testAdd()方法,控制台输出:

befor
after

说明@Before在每一个测试方法(@Test方法)之前运行 @After:在每一个测试方法之后运行。它们两个的应用场合: 有些方法需要执行的时候需要一些先决条件,比如打开某文件、获取资源,搭建环境,执行完之后需要关闭文件、释放资源、卸载环境这就需要before和after操作。

4)@BeforeClass;@AfterClass,它们两个都是静态的方法。我们继续改写代码:

public class TTest {
    @BeforeClass
    public static void beforeClass(){
        System.out.println("before class..");
    }
    @Before
    public void before() {
        System.out.println("befor");
    }
 
    @Test
    public void testAdd() {
        int z = new T().add(2, 4);
        assertThat(z, is(6));
        // 判断z==6,以往的assert
        // assertEquals(6, z);
        // assertTrue(z<3);
        // int a=8/0;
    }
 
    @After
    public void after() {
        System.out.println("after");
    }
    @AfterClass
    public static void afterClass(){
        System.out.println("after class..");
    }
 
}

当然也要加上:

import org.junit.BeforeClass;
import org.junit.AfterClass;

输出结果:

before class..
befor
after
after class..

这就说明了@BeforeClass 所有测试开始之前运行;@AfterClass: 所有测试结束之后运行【一定要注意】这两个方法都是静态方法,想想也应该明白类一加载就执行这两个方法,此时还没有创建任何对象,能执行的肯定就是静态方法了。

总结:

用了一天的时间学习了一下JUnit单元测试,其实还有很多东西没有看到,但对于单元测试的步骤和套路也算了解了一些,写在这里也方便自己以后的查阅和复习,待以后用到更深入的时候再更新一些单元测试在Spring/Mock中的应用,有错误的地方欢迎大家指出,再次谢谢大家的阅读!