告别祈祷式编程｜单元测试在项目里的正确落地姿势-阿里云开发者社区

前言

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是认为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。本文将带大家介绍几款主流的单元测试使用方法，希望可以帮到大家。

公众号：「浅羽的IT小屋」

1、为什么要使用单元测试？

「好处：」

可以使用单元测试来完成模块功能的一个测试
使用单元测试可以更好的完成模块的回归测试

「在开发中一般要进行如下测试：」

单元测试：一般情况下就是完成我们模块功能的一个检测
回归测试：当我们开发好一个功能之后，这个功能是否会影响其他已经开发好的这个功能
集成测试：简单的说就是项目开发完成的时候，这个所有功能是否完整，以及功能之间是否存在bug
公测：进行公测

2、Junit的使用

「简介：」

Junit是单元测试框架工具，在项目开发中是经常用到的，利用Junit4进行单元测试非常简单方便，所以熟悉Junit是很有必要的

「主要用法：」

@Before      //初始化数据用的
  @BeforeClass  //初始化数据用的(只是执行一次)
  @After       //对象销毁的时候用的
  @AfterClass   //对象销毁的时候用的(只是执行一次) 
  @Test(expected=xxx.class、timeout=5000) (测试：期望出现某一类异常)

3、Hamcrest的使用（Junit的一个补充）

「使用原因：」

使用过Junit的应该有体验：在实际开发中，一些基本的断言，如equal，null，true它们的可读性并不是很好。而且很多时候我们要比较对象、集合、Map等数据结构。这样我们要进行大段的字段获取再断言。或者干脆自己编写表达式并断言其结果
Junit4.4引入了Hamcrest框架，Hamcrest提供了一套匹配符，这些匹配符更接近自然语言，可读性高，更加灵活
需求：假设说加法的上面，加上一个不为null的一个断言，这个时候就出现了两个断言，这时候你就需要写两次，有没有办法只写一次呢？有

//使用这个Hamcrest来进行断言
//        Assert.assertThat(result, IsNull.notNullValue());
        // AllOf：所有的条件都要成立才表示校验成功
        // AnyOf：一个条件校验成功那么才表示的是校验成功
        // IsEqual：相等
        // IsInstanceOf：这个就表示判定的是对象是否是某一个类的对象
        // IsNot：不是某一个类的对象
        // IsNull：判断空值
        // StringEndWith：以什么结尾
        // StringStartsWith：这个表示的是以什么开始
        // SubStringMatcher：截取的字符串和谁匹配
//        Assert.assertThat(result, AllOf.allOf(IsNull.notNullValue(), IsEqual.equalTo(30)));
//       Assert.assertThat(result, AnyOf.anyOf(IsNull.notNullValue(), IsEqual.equalTo(30)));

「Unit4新断言-Hamcrest的常用方法：」

字符相关匹配符

1、equalTo： 
     assertThat(testedValue, equalTo(expectedValue)); 
     断言被测的testedValue等于expectedValue，equalTo可以断言数值之间，字符串之间和对象之间是否相等，相当于Object的equals方法
 2、equalToIgnoringCase：
     assertThat(testedString, equalToIgnoringCase(expectedString));
      断言被测的字符串testedString在忽略大小写的情况下等于expectedString
 3、equalToIgnoringWhiteSpace：
      assertThat(testedString, equalToIgnoringWhiteSpace(expectedString);
      断言被测的字符串testedString在忽略头尾的任意个空格的情况下等于expectedString
 （注意：字符串中的空格不能被忽略）
 4、containsString：
      assertThat(testedString, containsString(subString) );
      断言被测的字符串testedString包含子字符串subString
 5、endsWith：
      assertThat(testedString, endsWith(suffix));
      断言被测的字符串testedString以子字符串suffix结尾
 6、startsWith：
      assertThat(testedString, startsWith(prefix));
      断言被测的字符串testedString以子字符串prefix开始

一般匹配符

1、nullValue()：
      assertThat(object,nullValue());
      断言被测object的值为null
 2、notNullValue()：
      assertThat(object,notNullValue());
      断言被测object的值不为null
 3、is：
      assertThat(testedString, is(equalTo(expectedValue)));
      断言被测的object等于后面给出匹配表达式
      1）is匹配符简写应用之一：
           assertThat(testedValue, is(expectedValue));
           is(equalTo(x))的简写，断言testedValue等于expectedValue
      2）is匹配符简写应用之二：
           assertThat(testedObject, is(Cheddar.class));
           is(instanceOf(SomeClass.class))的简写，断言testedObject为Cheddar的实例
 4、not：
      assertThat(testedString, not(expectedString));
      与is匹配符正好相反，断言被测的object不等于后面给出的object
 5、allOf：
      assertThat(testedNumber, allOf( greaterThan(8), lessThan(16) ) );
      断言符合所有条件，相当于“与”（&&）
 6、anyOf：
      assertThat(testedNumber, anyOf( greaterThan(16), lessThan(8) ) );
      断言符合条件之一，相当于“或”（||）

‍‍‍‍数值相关匹配符

‍‍‍‍  1、closeTo：
      assertThat(testedDouble, closeTo( 20.0, 0.5 ));
      断言被测的浮点型数testedDouble在20.0-0.5 ~ 20.0+0.5范围之内
 2、greaterThan：
      assertThat(testedNumber, greaterThan(16.0));
      断言被测的数值testedNumber大于16.0
 3、lessThan：
      assertThat(testedNumber, lessThan (16.0));
      断言被测的数值testedNumber小于16.0
 4、greaterThanOrEqualTo：
      assertThat(testedNumber, greaterThanOrEqualTo (16.0));
      断言被测的数值testedNumber大于等于16.0
 5、lessThanOrEqualTo：
      assertThat(testedNumber, lessThanOrEqualTo (16.0));
      断言被测的testedNumber小于等于16.0

集合相关匹配符

1、hasEntry：
      assertThat(mapObject, hasEntry("key", "value" ) );
      断言被测的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项
 2、hasItem：
      assertThat(iterableObject, hasItem (element));
      表明被测的迭代对象iterableObject含有元素element项则测试通过
 3、hasKey：
      assertThat(mapObject, hasKey ("key"));
      断言被测的Map对象mapObject含有键值“key”
 4、hasValue：
      assertThat(mapObject, hasValue(value));
      断言被测的Map对象mapObject含有元素值value

4、Suit的使用

「需求：」

现在有30个实体，每个DAO和每个Service都编写了测试用例。所以至少有60个测试类，当我们开发一个功能的时候，我们需要检测当前开发好的功能是否影响了其他已经开发好的功能，这个时候需要运行这60个测试用例，只有所有的测试用例都没有问题，才确定当前开发的功能对其他功能是没有影响的
这个时候就需要运用Suit，Suit的作用就是可以一次性的运行多个测试用例

@RunWith(Suite.class)   //表示的是使用什么类来运行
@Suite.SuiteClasses({TestCaltureB.class,TestCaltureA.class})  //这个表示的是要运行哪些类
public class TestCaltureAB {
}

5、Stub（装）的使用

「解决的问题：」

假设两个人做开发，一个人做的是DAO，另外一个人做的是Service，现在的问题是DAO层还没有来得及开发，只是有约束规范（只有接口没有实现），现在是Service层需要测试，那怎么办呢？
Stub的思想就是：自己编写DAO的实现类使用Map集合来模拟数据库的数据以及访问的这个过程，就叫做Stub

「具体使用：」

首先声明DAO的接口

public interface IUserDAO {
    /**
     * 通过id找用户
     * @param userId
     * @return
     */
    User getUserById(Serializable userId);
}

编写Service的实现类

public class UserService {
    public IUserDAO userDAO=null;
    public void setUserDAO(IUserDAO userDAO) {
        this.userDAO = userDAO;
    }
    /**
     * 通过id找用户
     * @param userId
     * @return
     */
    public User getUserById(Serializable userId){
        User user=userDAO.getUserById(userId);
        return user;
    }
}

编写Stub的DAO的实现类

public class UserDAOStub implements IUserDAO{
    //使用map集合来模拟我们的数据库
    private Map<Integer,User> users=new HashMap<>();
    public UserDAOStub() {
        for (int i=0;i< 10;i++){
            users.put(i+1,new User(i+1,i+1+"",i+1+""));
        }
    }
    @Override
    public User getUserById(Serializable userId) {
        return users.get(userId);
    }
}

编写测试的类

public class TestUserService {
    private UserService userService=null;
    private User exUser=null;
    @Before
    public void init(){
        userService=new UserService();
        exUser=new User();
        //期望返回的的这个用户对象
        exUser.setPassword("1");
        exUser.setUserId(1);
        exUser.setUserName("1");
        UserDAOStub userDAOStub = new UserDAOStub();
        userService.setUserDAO(userDAOStub);
    }
    @Test
    public void testGetUserById(){
        User user=userService.getUserById(1);
        //接下来就进行断言了
        Assert.assertEquals(exUser.getUserId(),user.getUserId());
        Assert.assertEquals(exUser.getPassword(),user.getPassword());
        Assert.assertEquals(exUser.getUserName(),user.getUserName());
    }
    @After
    public void close(){
        userService=null;
    }
}

6、dbunit的使用

「主要用途：」

dbunit是专门用来测试DAO层的，以后开发中DAO的测试就可以使用dbunit来进行

「使用流程：」

备份所有的表

private void backAllTable() throws SQLException, IOException, DataSetException {
        //第一步：获取连接上的dataSet对象
        IDataSet dataSet = conn.createDataSet();
        //第二步：将数据进行备份
        //使用属性来描述要备份的这个数据
//      FlatXmlDataSet.write(dataSet,new FileOutputStream(new File("G:/allTable.xml")));
        //使用节点来描述要备份的这个数据
        XmlDataSet.write(dataSet, new FileOutputStream(new File("G:/allTable1.xml")));
    }

备份一张表

/**
 * 备份一张表的数据
 */
private void backOneTable() throws DataSetException, IOException {
    //创建一个查询的DataSet对象
    QueryDataSet dataSet = new QueryDataSet(conn);
    //第二步：添加要备份的表名
    dataSet.addTable("t_user");
    //第三步：进行备份
    FlatXmlDataSet.write(dataSet, new FileOutputStream(new File("G:/allTable.xml")));
}

插入测试数据

/**
 * 插入准备好的数据到数据库
 */
private void insertDataTable() throws DatabaseUnitException, SQLException {
    //获取插入数据的DataSet对象
    IDataSet dataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(TestUserDAO.class.getClassLoader().getResourceAsStream("table.xml"))));
    DatabaseOperation.CLEAN_INSERT.execute(conn, dataSet);
}

测试

@Test
public void testFindUserById() throws SQLException, IOException, DatabaseUnitException {
     backOneTable();
     insertDataTable();
    // 编写测试代码的地方
    User acUser=userDAO.findUserById(78);  //实际返回的用户对象
    //下一步：进行断言
    Assert.assertEquals(exUser.getUserId(),acUser.getUserId());
    Assert.assertEquals(exUser.getUserName(),acUser.getUserName());
    Assert.assertEquals(exUser.getPassword(),acUser.getPassword());
    //还原数据库的数据
    resumeTable();
}

还原这个数据

/**
 * 还原数据库的数据
 */
private void resumeTable() throws IOException, DatabaseUnitException, SQLException {
    //备份数据的DataSet对象
    IDataSet dataSet=new FlatXmlDataSet(new InputSource(new FileInputStream(new File("G:/allTable.xml"))));
    DatabaseOperation.CLEAN_INSERT.execute(conn,dataSet);
}

整体代码如下：

package com.qy.dbunit;
import com.qy.utils.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.dbunit.DatabaseUnitException;
import org.dbunit.database.AmbiguousTableNameException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlProducer;
import org.dbunit.dataset.xml.XmlDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.xml.sax.InputSource;
import java.io.*;
import java.sql.SQLException;
/**
 * @Auther: qianyu
 * @Date: 2020/11/17 10:02
 * @Description:
 */
public class TestUserDAO {
    //维护的是用户的DAO的对象
    private UserDAO userDAO=null;
    //实例化dbunit中的这个数据库的连接
    private DatabaseConnection conn = null;
    //期望返回的用户对象值
    private User exUser=null;
    @Before
    public void init() throws Exception {
        conn = new DatabaseConnection(JdbcUtils.getConnection());
        exUser=new User();
        exUser.setUserId(78);
        exUser.setUserName("78");
        exUser.setPassword("78");
        userDAO=new UserDAO();
    }
    /**
     * 第一步：对数据库的数据进行备份
     * 备份一张表的数据
     * 备份整个数据库中的数据
     * 第二步：插入提前准备好的测试数据
     * 第三步：测试
     * 第四步：将数据库的数据清空
     * 第五步:还原数据库的数据
     */
    @Test
    public void testFindUserById() throws SQLException, IOException, DatabaseUnitException {
         backOneTable();
         insertDataTable();
        // 编写测试代码的地方
        User acUser=userDAO.findUserById(78);  //实际返回的用户对象
        //下一步：进行断言
        Assert.assertEquals(exUser.getUserId(),acUser.getUserId());
        Assert.assertEquals(exUser.getUserName(),acUser.getUserName());
        Assert.assertEquals(exUser.getPassword(),acUser.getPassword());
        //还原数据库的数据
        resumeTable();
    }
    /**
     * 还原数据库的数据
     */
    private void resumeTable() throws IOException, DatabaseUnitException, SQLException {
        //备份数据的DataSet对象
        IDataSet dataSet=new FlatXmlDataSet(new InputSource(new FileInputStream(new File("G:/allTable.xml"))));
        DatabaseOperation.CLEAN_INSERT.execute(conn,dataSet);
    }
    /**
     * 插入准备好的数据到数据库
     */
    private void insertDataTable() throws DatabaseUnitException, SQLException {
        //获取插入数据的DataSet对象
        IDataSet dataSet = new FlatXmlDataSet(new FlatXmlProducer(new InputSource(TestUserDAO.class.getClassLoader().getResourceAsStream("table.xml"))));
        DatabaseOperation.CLEAN_INSERT.execute(conn, dataSet);
    }
    /**
     * 备份数据库中所有表中的数据
     */
    private void backAllTable() throws SQLException, IOException, DataSetException {
        //第一步：获取连接上的dataSet对象
        IDataSet dataSet = conn.createDataSet();
        //第二步：将数据进行备份
        //使用属性来描述要备份的这个数据
//      FlatXmlDataSet.write(dataSet,new FileOutputStream(new File("G:/allTable.xml")));
        //使用节点来描述要备份的这个数据
        XmlDataSet.write(dataSet, new FileOutputStream(new File("G:/allTable1.xml")));
    }
    /**
     * 备份一张表的数据
     */
    private void backOneTable() throws DataSetException, IOException {
        //创建一个查询的DataSet对象
        QueryDataSet dataSet = new QueryDataSet(conn);
        //第二步：添加要备份的表名
        dataSet.addTable("t_user");
        //第三步：进行备份
        FlatXmlDataSet.write(dataSet, new FileOutputStream(new File("G:/allTable.xml")));
    }
}

编写测试的基类

package com.qy.base;
import org.apache.commons.dbutils.QueryRunner;
import org.dbunit.DatabaseUnitException;
import org.dbunit.database.AmbiguousTableNameException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.xml.sax.InputSource;
import java.io.*;
import java.sql.Connection;
import java.sql.SQLException;
/**
 * @Auther: qianyu
 * @Date: 2020/11/17 10:58
 * @Description:
 */
public class AbstractDbunitTestCase implements Serializable{
    //dbunit的这个连接
    private DatabaseConnection conn=null;
    //传入测试数据的dataSet对象
    private IDataSet dataSetTest=null;
    //创建一个临时文件
    private File temFile=null;
    public AbstractDbunitTestCase(Connection connection,IDataSet dataSetTest) throws DatabaseUnitException {
        conn=new DatabaseConnection(connection);
        this.dataSetTest=dataSetTest;
    }
    /**
     * 备份多张表的数据
     * @param tabNames
     */
    public void backManyTable(String ... tabNames) throws DataSetException, IOException {
        QueryDataSet queryDataSet=new QueryDataSet(conn);
        for (int i=0;i<tabNames.length;i++){
            queryDataSet.addTable(tabNames[i]);
        }
        temFile=File.createTempFile("table",".xml");
        //进行备份
        FlatXmlDataSet.write(queryDataSet,new FileOutputStream(temFile));
    }
    /**
     * 备份一张表
     * @param tableName
     */
    public void backOneTable(String tableName) throws IOException, DataSetException {
       backManyTable(tableName);
    }
    /**
     * 插入测试数据
     */
    public void insertTestData() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(conn,dataSetTest);
    }
    /**
     * 还原这个表的数据
     */
    public void resumeTable() throws IOException, DatabaseUnitException, SQLException {
        IDataSet dataSet=new FlatXmlDataSet(new InputSource(new FileInputStream(temFile)));
        DatabaseOperation.CLEAN_INSERT.execute(conn,dataSet);
    }
}

使用基类来完成测试

package com.qy.dbunit;
import com.qy.base.AbstractDbunitTestCase;
import com.qy.utils.JdbcUtils;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.xml.sax.InputSource;
import java.sql.SQLException;
/**
 * @Auther: qianyu
 * @Date: 2020/11/17 11:12
 * @Description:
 */
public class TestUserDAO1 extends AbstractDbunitTestCase {
    private UserDAO userDAO=null;
    //期望返回的用户对象值
    private User exUser=null;
    public TestUserDAO1() throws Exception {
        super(JdbcUtils.getConnection(),new FlatXmlDataSet(new InputSource(TestUserDAO1.class.getClassLoader().getResourceAsStream("table.xml"))));
    }
    @Before
    public void init() throws Exception {
        exUser=new User();
        exUser.setUserId(78);
        exUser.setUserName("78");
        exUser.setPassword("79");
        userDAO=new UserDAO();
        backOneTable("t_user");
        insertTestData();
    }
    @Test
    public void testFindUserById() throws SQLException {
        // 编写测试代码的地方
        User acUser=userDAO.findUserById(78);  //实际返回的用户对象
        //下一步：进行断言
        Assert.assertEquals(exUser.getUserId(),acUser.getUserId());
        Assert.assertEquals(exUser.getUserName(),acUser.getUserName());
        Assert.assertEquals(exUser.getPassword(),acUser.getPassword());
    }
    @After
    public void destory() throws Exception {
       resumeTable();
    }
}

7、EasyMock的使用

「使用场景：」

dbunit是专门用来测试DAO层的
EasyMock是专门用来测试Service层的
DAO层的测试的重点：数据的准确性
Service层测试的重点是DAO的调用次数、DAO层的调用的顺序
EasyMocK的适用场景：就是当Service开发好之后 DAO层还没有来得及开发的时候 Service层需要测试

第一个案例

public class TestUserService {
    private UserService userService=null;
    private User exUser=null;
    @Before
    public void init(){
        userService=new UserService();
        exUser=new User();
        exUser.setUserId(1);
        exUser.setUserName("浅羽");
        exUser.setPassword("123");
    }
    /**
     * 有返回值的情况
     */
    @Test
    public void testFindUserById(){
        //第一步：使用EasyMock生成接口的实现类
        IUserDAO userDAO=EasyMock.createMock(IUserDAO.class);
        //第二步：进行记录
        //下面表示的意思是调用了上面对象的哪一个方法传递，某一个值的时候 希望的返回值是什么?
        EasyMock.expect(userDAO.findUserById(1)).andReturn(exUser);
        EasyMock.expect(userDAO.findUserById(1)).andReturn(exUser);
        //第三步：进行replay(使能：使上面的设置生效)
        EasyMock.replay(userDAO);
        //第四步：进行设置
        userService.setUserDAO(userDAO);
        //第五步：进行测试
        userService.findUserById(1);
        //第六步：进行校验
        EasyMock.verify(userDAO);
    }
    /**
     * 没有返回值的情况
     */
    @Test
    public void testSave(){
        IUserDAO userDAO=EasyMock.createMock(IUserDAO.class);
        //没有返回值的情况
        //第一步：调用(记录中的调用)
        userDAO.save();
        //第二步：告诉他没有返回值
        EasyMock.expectLastCall();
        //第一步：调用(记录中的调用)
        userDAO.save();
        //第二步：告诉他没有返回值
        EasyMock.expectLastCall();
        //第一步：调用(记录中的调用)
        userDAO.save();
        //第二步：告诉他没有返回值
        EasyMock.expectLastCall();
        //使能
        EasyMock.replay(userDAO);
        //设置
        userService.setUserDAO(userDAO);
        //调用
        userService.save();
        //校验
        EasyMock.verify(userDAO);
    }
    /**
     * 测试有参数和没有参数混用的情况
     * 注意：即时改变了顺序 只要你记录了都不会报错(非严格意义上的Mock)
     *
     */
    @Test
    public void testDelete(){
        IUserDAO userDAO=EasyMock.createMock(IUserDAO.class);
        //进行记录
        //记录第一个调用
        EasyMock.expect(userDAO.findUserById(1)).andReturn(exUser);
        //记录第二个调用
        userDAO.delete();
        EasyMock.expectLastCall();
        //第三个：使能
        EasyMock.replay(userDAO);
        //设置
        userService.setUserDAO(userDAO);
        //调用
        userService.delete(1);
        //校验
        EasyMock.verify(userDAO);
    }
    /**
     * 这个玩的是有严格顺序的Mock
     * 严格意义上的Mock对调用的顺序都有联系
     */
    @Test
    public void testDelete1(){
        IUserDAO userDAO=EasyMock.createStrictMock(IUserDAO.class);
        //进行记录
        //记录第一个调用
        EasyMock.expect(userDAO.findUserById(1)).andReturn(exUser);
        //记录第二个调用
        userDAO.delete();
        EasyMock.expectLastCall();
        //第三个：使能
        EasyMock.replay(userDAO);
        //设置
        userService.setUserDAO(userDAO);
        //调用
        userService.delete(1);
        //校验
        EasyMock.verify(userDAO);
    }
}

关于这个的高级应用

public class TestABService {
    private ABService abService=null;
    @Before
    public void init(){
        abService=new ABService();
    }
    /**
     * 测试顺序的问题
     */
    @Test
    public void testMM(){
        //创建实现类
        A a=EasyMock.createStrictMock(A.class);
        B b=EasyMock.createStrictMock(B.class);
        //进行记录
        a.a();
        EasyMock.expectLastCall();
        a.b();
        EasyMock.expectLastCall();
        b.c();
        EasyMock.expectLastCall();
        b.d();
        EasyMock.expectLastCall();
        //使能
        EasyMock.replay(a,b);
        //设置
        abService.setA(a);
        abService.setB(b);
        //调用
        abService.mm();
        //进行认证
        EasyMock.verify(a,b);
    }
    @Test
    public void testMMM(){
        IMocksControl strictControl = EasyMock.createStrictControl();
        A a=strictControl.createMock(A.class);
        B b=strictControl.createMock(B.class);
        //进行记录
        a.a();
        EasyMock.expectLastCall();
        a.b();
        EasyMock.expectLastCall();
        b.c();
        EasyMock.expectLastCall();
        b.d();
        EasyMock.expectLastCall();
        //使能
        strictControl.replay();
        //设置
        abService.setA(a);
        abService.setB(b);
        //调用
        abService.mm();
        //进行认证
        strictControl.verify();
    }
    @Test
    public void testMM1(){
        IMocksControl strictControl = EasyMock.createStrictControl();
        A a=strictControl.createMock(A.class);
        B b=strictControl.createMock(B.class);
        //进行记录
        a.a();
        EasyMock.expectLastCall();
        a.b();
        EasyMock.expectLastCall();
        b.c();
        EasyMock.expectLastCall();
        b.d();
        EasyMock.expectLastCall();
        //使能
        strictControl.replay();
        //设置
        abService.setA(a);
        abService.setB(b);
        //调用
        abService.mm();
        //进行认证
        strictControl.verify();
    }
}

8、SpringTest的使用

「简介：」

整合了Junit4框架，来做单元测试

「具体使用：」

编写基类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:bean-base.xml"})
public class AbstractSpringTestCase {
}

测试

public class TestUserDAO extends AbstractSpringTestCase {
    @Autowired
   private UserDAO userDAO;
    private User exUser=null;
    @Before
    public void init(){
       exUser=new User(1,"浅羽","123");
    }
    @Test
    public void testFindUserById(){
         User acUser= userDAO.findUserById(1);
         //断言
        //下一步：进行断言
        Assert.assertEquals(exUser.getUserId(),acUser.getUserId());
        Assert.assertEquals(exUser.getUserName(),acUser.getUserName());
        Assert.assertEquals(exUser.getPassword(),acUser.getPassword());
    }
}