Java单元测试
单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是人为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。
可以说，单元测试（模块测试）是开发者编写的一小段代码，用于检验被测代码的一个很小的、很明确的功能是否正确。通常而言，一个单元测试是用于判断某个特定条件（或者场景）下某个特定函数的行为。可见，单元测试是由程序员自己来完成，最终受益的也是程序员自己。可以这么说，程序员有责任编写功能代码，同时也就有责任为自己的代码编写单元测试。执行单元测试，就是为了证明这段代码的行为和我们期望的一致。
对于程序员来说，如果养成了对自己写的代码进行单元测试的习惯，不但可以写出高质量的代码，而且还能提高编程水平。
接下来主要介绍Junit3，Junit4单元测试方案，以及mock测试框架，Spring单元测试框架。我们先来看Junit3单元测试方案，代码如下：
package com.itszt.domain;
import java.util.Date;
/**
* 单元测试用的实体类
*/
public class Order {
private int orderId;//订单order的id
private Date orderTime;//下订单时间
public Order(int orderId, Date orderTime) {
this.orderId = orderId;
this.orderTime = orderTime;
}
@Override
public String toString() {
return "Order{" +
"orderId=" + orderId +
", orderTime=" + orderTime +
'}';
}
public Order() {
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public Date getOrderTime() {
return orderTime;
}
public void setOrderTime(Date orderTime) {
this.orderTime = orderTime;
}
}
-------------------------------------------------------------
package com.itszt.dao;
import com.itszt.domain.Order;
import java.util.*;
/**
* 测试单元,操作订单的类
*/
public class OrderDao {
private static int moneyNum=100;
private static Map<String,List<Order>> allOrders=new HashMap<>();
private static int id=1;
static {
List<Order> orders=new ArrayList<>();
orders.add(new Order(id++,new Date()));
orders.add(new Order(id++,new Date()));
orders.add(new Order(id++,new Date()));
allOrders.put("张三",orders);//属于张三的订单
}
public int queryOrderCount(String username){
//用户所下订单的数量
return allOrders.get(username).size();
}
public List<Order> queryOrders(String username){
//用户下过的订单
return allOrders.get(username);
}
public int queryMoney(){
return moneyNum;
}
public void addMoney(int num){
moneyNum=moneyNum+num;
}
public void dropMoney(int num){
moneyNum=moneyNum-num;
}
}
------------------------------------------------------
package test1;
import com.itszt.dao.OrderDao;
import com.itszt.domain.Order;
import junit.framework.TestCase;
import java.util.List;
/**
* Junit3,创建单元测试用例
* 注:Junit4用注解完成
*/
public class TestOrderDao extends TestCase{
private OrderDao orderDao;
private static int num=0;
@Override
public void setUp() throws Exception {
System.out.println((++num)+"--------========================");
// setUp:在每个测试方法前都会执行，做通用初始化
// super.setUp();
orderDao=new OrderDao();
System.out.println("test1.TestOrderDao.setUp");
}
@Override
public void tearDown() throws Exception {
// super.tearDown();
System.out.println("test1.TestOrderDao.tearDown");
}
public void testQueryMoney(){
System.out.println("test1.TestOrderDao.testQueryMoney");
int queryMoney = orderDao.queryMoney();
System.out.println("queryMoney = " + queryMoney);
//传入一个期望值,再传入一个真实值,看两者是否相等
assertEquals(100,queryMoney);
}
public void testAddMoney(){
System.out.println("test1.TestOrderDao.testAddMoney");
orderDao.addMoney(100);
int queryMoney = orderDao.queryMoney();
System.out.println("queryMoney = " + queryMoney);
assertEquals(200,queryMoney);
}
public void testDropMoney(){
System.out.println("TestOrderDao.testDropMoney");
orderDao.dropMoney(35);
int queryMoney = orderDao.queryMoney();
System.out.println("queryMoney = " + queryMoney);
assertEquals(165,queryMoney);
}
public void testQueryOrderCount(){
System.out.println("TestOrderDao.testQueryOrderCount");
int orderCount = orderDao.queryOrderCount("张三");
System.out.println("orderCount = " + orderCount);
assertEquals(3,orderCount);
}
public void testQueryOrders(){
System.out.println("TestOrderDao.testQueryOrders");
List<Order> orderList = orderDao.queryOrders("张三");
System.out.println("orderList = " + orderList);
assertEquals(orderList,orderList);
}
}
-------------------------------------------------------
package test1;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
*单元测试套件,运行测试用例
*/
public class TestAll extends TestCase{
public static Test suite(){
TestSuite testSuite=new TestSuite();
testSuite.addTestSuite(TestOrderDao.class);
return testSuite;
}
}
上述代码执行结果如下：
1--------========================
test1.TestOrderDao.setUp
TestOrderDao.testQueryOrders
orderList = [Order{orderId=1, orderTime=Wed Mar 21 14:43:51 CST 2018}, Order{orderId=2, orderTime=Wed Mar 21 14:43:51 CST 2018}, Order{orderId=3, orderTime=Wed Mar 21 14:43:51 CST 2018}]
test1.TestOrderDao.tearDown
2--------========================
test1.TestOrderDao.setUp
test1.TestOrderDao.testQueryMoney
queryMoney = 100
test1.TestOrderDao.tearDown
3--------========================
test1.TestOrderDao.setUp
test1.TestOrderDao.testAddMoney
queryMoney = 200
test1.TestOrderDao.tearDown
4--------========================
test1.TestOrderDao.setUp
TestOrderDao.testDropMoney
queryMoney = 165
test1.TestOrderDao.tearDown
5--------========================
test1.TestOrderDao.setUp
TestOrderDao.testQueryOrderCount
orderCount = 3
test1.TestOrderDao.tearDown
总的来说，在使用Junit3单元测试时，步骤如下：
先导入相关jar包；
新建单元测试用例，如：public class TestUserDao extends TestCase；
其中，setUp:在每个测试方法前都会执行，做通用初始化；
tearDown:在每个测试方法后都会执行，做通用资源释放。
写测试方案：其实就是一堆方法，这些方法通常以test开头即可；
怎么判断功能是否正常：基于Assert 断言完成；
测试结果通常是3种： 1.成功 2.失败 3.异常报错
单元测试套件：一次执行多个测试类
上面用的是Junit3测试方案，Junit4与Junit3不同的是，采用了注解方式，从而使得测试代码更为简洁。我们接下来看Junit4测试方案：
package com.itszt.dao;
/**
* 测试单元
*/
public class UserDao {
private static int moneyNum=100;
public int queryMoney(){
System.out.println(10/0);//模拟出现异常
return moneyNum;
}
public void addMoney(int num){
moneyNum+=num;
}
public void dropMoney(int num){
moneyNum-=num;
}
}
----------------------------------------------------------
package test2;
import com.itszt.dao.UserDao;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* 测试用例,通过注解声明
*/
public class TestUserDao {
private UserDao userDao;
@Before
public void init(){
userDao=new UserDao();
System.out.println("TestUserDao.init");
}
@After
public void tearDown(){
System.out.println("TestUserDao.tearDown");
}
@Test
public void testQueryMoney(){
System.out.println("TestUserDao.testQueryMoney "+userDao.hashCode());
int money = userDao.queryMoney();
Assert.assertEquals(100,money);
}
@Test
public void testAddMoney(){
System.out.println("TestUserDao.testAddMoney "+userDao.hashCode());
userDao.addMoney(300);
int money = userDao.queryMoney();
Assert.assertEquals(400,money);
}
}
----------------------------------------------------
package test2;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
/**
* 测试套件
* 测试用例多于一个时,中间以英文逗号分割
*/
@Suite.SuiteClasses({TestUserDao.class})
@RunWith(Suite.class)
public class TestAll {
}
上述代码执行结果如下：
TestUserDao.init
TestUserDao.testQueryMoney 25282035
TestUserDao.tearDown
java.lang.ArithmeticException: / by zero
at com.itszt.dao.UserDao.queryMoney(UserDao.java:9)
at test2.TestUserDao.testQueryMoney(TestUserDao.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runners.Suite.runChild(Suite.java:128)
at org.junit.runners.Suite.runChild(Suite.java:27)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:51)
at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:237)
at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
TestUserDao.init
TestUserDao.testAddMoney 4959864
TestUserDao.tearDown
java.lang.ArithmeticException: / by zero
at com.itszt.dao.UserDao.queryMoney(UserDao.java:9)
at test2.TestUserDao.testAddMoney(TestUserDao.java:35)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runners.Suite.runChild(Suite.java:128)
at org.junit.runners.Suite.runChild(Suite.java:27)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:51)
at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:237)
at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
可见，代码出现异常后，单元测试随之会给出相应的异常提示。
我们接下来用mock方法执行单元测试。首先，我们要在项目中添加easymock-3.4.jar包的依赖。测试代码如下：
package com.itszt.domain;
/**
* 测试用的实体类
*/
public class Org {
private String orgName,orgLoaction,orgType;
public Org(String orgName, String orgLoaction, String orgType) {
this.orgName = orgName;
this.orgLoaction = orgLoaction;
this.orgType = orgType;
}
public Org() {
}
public String getOrgName() {
return orgName;
}
public void setOrgName(String orgName) {
this.orgName = orgName;
}
public String getOrgLoaction() {
return orgLoaction;
}
public void setOrgLoaction(String orgLoaction) {
this.orgLoaction = orgLoaction;
}
public String getOrgType() {
return orgType;
}
public void setOrgType(String orgType) {
this.orgType = orgType;
}
@Override
public String toString() {
return "Org{" +
"orgName='" + orgName + '\'' +
", orgLoaction='" + orgLoaction + '\'' +
", orgType='" + orgType + '\'' +
'}';
}
}
----------------------------------------------------
package com.itszt.dao;
import com.itszt.domain.Org;
/**
* 操作Org对象的接口
*/
public interface OrgDao {
//1.查重
public Org queryOrgByName(String orgName);
}
--------------------------------------------------------
package com.itszt.service;
/**
* 操作Org业务的接口
*/
public interface OrgService {
public boolean regOrg(String orgName,String orgLoaction,String orgType);
}
----------------------------------------------------------
package com.itszt.service;
import com.itszt.dao.OrgDao;
import com.itszt.domain.Org;
/**
* OrgService的实现类
*/
public class OrgServiceImpl implements OrgService {
private OrgDao orgDao;
public void setOrgDao(OrgDao orgDao) {
this.orgDao = orgDao;
}
@Override
public boolean regOrg(String orgName, String orgLoaction, String orgType) {
Org org = orgDao.queryOrgByName(orgName);
if (org == null) {
System.out.println(orgName+"不存在,可以执行插入动作。");
} else {
System.out.println(orgName+"已存在,不能再插入");
return false;
}
return true;
}
}
-------------------------------------------------------
package test4;
import com.itszt.dao.OrgDao;
import com.itszt.domain.Org;
import com.itszt.service.OrgServiceImpl;
import org.easymock.EasyMock;
import org.junit.Assert;
import org.junit.Test;
/**
* 用mock方案实现单元测试
*/
public class TestOrgService {
@Test
public void testRegOrg(){
OrgServiceImpl orgService=new OrgServiceImpl();
//用mock模拟一个UserDao的实现类
OrgDao orgDao = EasyMock.createMock(OrgDao.class);
orgService.setOrgDao(orgDao);
//待测试的一个实体类
Org org = new Org("曹操公司", "许昌", "魏国");
//当orgDao调用queryOrgByName方法，并且传入参数为"曹操公司"时，则返回org对象，该模拟对象orgDao可使用次数为10
//传入期望值,实际结果为Org对象或null
EasyMock.expect(orgDao.queryOrgByName("曹操公司")).andReturn(org).times(10);
EasyMock.expect(orgDao.queryOrgByName("刘备公司")).andReturn(null).times(10);
//让我们模拟的特性生效
EasyMock.replay(orgDao);
boolean boo1 = orgService.regOrg("曹操公司", "许昌", "魏国");
Assert.assertFalse(boo1);
boolean boo2 = orgService.regOrg("刘备公司", "成都", "蜀汉");
Assert.assertTrue(boo2);
}
}
上述代码执行如下：
曹操公司已存在,不能再插入
刘备公司不存在,可以执行插入动作。
我们接下来再写一个基于mock的单元测试方案：
package com.itszt.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
/**
* 测试单元
*/
public class UserController {
public void showUser(HttpServletRequest request, HttpSession session) {
String username = request.getParameter("username");
System.out.println("简单使用一下---username = " + username);
String userpwd = request.getAttribute("userpwd").toString();
System.out.println("简单使用一下---userpwd = " + userpwd);
String userNow = session.getAttribute("userNow").toString();
System.out.println("简单使用一下---userNow = " + userNow);
}
}
-------------------------------------------------
package test3;
import com.itszt.controller.UserController;
import org.easymock.EasyMock;
import org.junit.Test;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
/**
* mock单元测试方案
*/
public class TestUserController {
@Test
public void testShow(){
UserController userController=new UserController();
HttpServletRequest request = EasyMock.createMock(HttpServletRequest.class);
HttpSession session = EasyMock.createMock(HttpSession.class);
String username="小明";
String userpwd="123456";
String userNow=username;
EasyMock.expect(request.getParameter("username")).andReturn(username).times(1);
EasyMock.expect(request.getAttribute("userpwd")).andReturn(userpwd).once();
EasyMock.expect(session.getAttribute("userNow")).andReturn("正在登录的是："+userNow).once();
EasyMock.replay(request);
EasyMock.replay(session);
userController.showUser(request,session);
}
}
上述代码执行结果如下：
简单使用一下---username = 小明
简单使用一下---userpwd = 123456
简单使用一下---userNow = 正在登录的是：小明
最后，我们在使用Spring框架时，Spring也为我们提供了单元测试方案。在使用时，我们需要添加Spring框架中相应的jar包（spring-test-4.3.11.RELEASE.jar）依赖。
由于我们在案例中使用了注解，所以在spring-config.xml配置文件中要添加注解支持，配置如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--添加注解支持-->
<context:annotation-config></context:annotation-config>
<context:component-scan base-package="test4"></context:component-scan>
</beans>
接下来是基于Spring框架的单元测试代码：
package test4;
import org.springframework.stereotype.Component;
/**
* 测试单元
*/
@Component
public class UserService {
public int queryScore(){
System.out.println("100就对了");
return 100;
}
}
---------------------------------------------------
package test4;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* 测试用例与套件
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:config/spring-config.xml")
public class TestUserService {
@Autowired
private UserService userService;
@Before
public void before(){
System.out.println("运行前测试....");
}
@After
public void after(){
System.out.println("运行完成后测试...");
}
@Test
public void testQueryScore(){
System.out.println("TestUserService.testQueryScore");
int queryScore = userService.queryScore();
org.junit.Assert.assertEquals(100,100);
}
}
上述代码运行如下：
运行前测试....
TestUserService.testQueryScore
100就对了
运行完成后测试...
2244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
