前言
单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是认为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。本文将带大家介绍几款主流的单元测试使用方法，希望可以帮到大家。
公众号：「浅羽的IT小屋」
1、为什么要使用单元测试？
「好处：」
- 可以使用单元测试来完成模块功能的一个测试
- 使用单元测试可以更好的完成模块的回归测试
「在开发中一般要进行如下测试：」
- 单元测试：一般情况下就是完成我们模块功能的一个检测
- 回归测试：当我们开发好一个功能之后，这个功能是否会影响其他已经开发好的这个功能
- 集成测试：简单的说就是项目开发完成的时候，这个所有功能是否完整，以及功能之间是否存在bug
- 公测：进行公测
2、Junit的使用
「简介：」
- Junit是单元测试框架工具，在项目开发中是经常用到的，利用Junit4进行单元测试非常简单方便，所以熟悉Junit是很有必要的
「主要用法：」
代码语言：javascript复制 @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的使用
「使用场景：」
代码语言：javascript复制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());
}
}结语
本篇关于单元测试的主流框架以及工具的介绍就先到这里结束了，后续会出更多关于单元测试系列文章，谢谢大家支持！
