`
thihy
  • 浏览: 69007 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java单元测试(Junit+Mock+代码覆盖率)

阅读更多

原文见此处

单元测试是编写测试代码,用来检测特定的、明确的、细颗粒的功能。单元测试并不一定保证程序功能是正确的,更不保证整体业务是准备的。

单元测试不仅仅用来保证当前代码的正确性,更重要的是用来保证代码修复改进重构之后的正确性。

一般来说,单元测试任务包括

  1. 接口功能测试:用来保证接口功能的正确性。
  2. 局部数据结构测试(不常用):用来保证接口中的数据结构是正确的
    1. 比如变量有无初始值
    2. 变量是否溢出
  3. 边界条件测试
    1. 变量没有赋值(即为NULL)
    2. 变量是数值(或字符)
      1. 主要边界:最小值,最大值,无穷大(对于DOUBLE等)
      2. 溢出边界(期望异常或拒绝服务):最小值-1,最大值+1
      3. 临近边界:最小值+1,最大值-1
    3. 变量是字符串
      1. 引用“字符变量”的边界
      2. 空字符串
      3. 对字符串长度应用“数值变量”的边界
    4. 变量是集合
      1. 空集合
      2. 对集合的大小应用“数值变量”的边界
      3. 调整次序:升序、降序
    5. 变量有规律
      1. 比如对于Math.sqrt,给出n^2-1,和n^2+1的边界
  4. 所有独立执行通路测试:保证每一条代码,每个分支都经过测试
    1. 代码覆盖率
      1. 语句覆盖:保证每一个语句都执行到了
      2. 判定覆盖(分支覆盖):保证每一个分支都执行到
      3. 条件覆盖:保证每一个条件都覆盖到true和false(即if、while中的条件语句)
      4. 路径覆盖:保证每一个路径都覆盖到
    2. 相关软件
      1. Cobertura:语句覆盖
      2. Emma: Eclipse插件Eclemma
  5. 各条错误处理通路测试:保证每一个异常都经过测试

JUNIT

JUnit是Java单元测试框架,已经在Eclipse中默认安装。目前主流的有JUnit3和JUnit4。JUnit3中,测试用例需要继承TestCase类。JUnit4中,测试用例无需继承TestCase类,只需要使用@Test等注解。

Junit3

先看一个Junit3的样例

// 测试java.lang.Math
// 必须继承TestCase
public class Junit3TestCase extends TestCase {
    public Junit3TestCase() {
        super();
    }
  
        // 传入测试用例名称
    public Junit3TestCase(String name) {
        super(name);
    }
 
        // 在每个Test运行之前运行
    @Override
    protected void setUp() throws Exception {
        System.out.println("Set up");
    }
        // 测试方法。
        // 方法名称必须以test开头,没有参数,无返回值,是公开的,可以抛出异常
        // 也即类似public void testXXX() throws Exception {}
    public void testMathPow() {
        System.out.println("Test Math.pow");
        Assert.assertEquals(4.0, Math.pow(2.0, 2.0));
    }
 
    public void testMathMin() {
        System.out.println("Test Math.min");
        Assert.assertEquals(2.0, Math.min(2.0, 4.0));
    }
 
        // 在每个Test运行之后运行
    @Override
    protected void tearDown() throws Exception {
        System.out.println("Tear down");
    }
}

 

 

如果采用默认的TestSuite,则测试方法必须是public void testXXX() [throws Exception] {}的形式,并且不能存在依赖关系,因为测试方法的调用顺序是不可预知的。
上例执行后,控制台会输出

Set up
Test Math.pow
Tear down
Set up
Test Math.min
Tear down

 

 

从中,可以猜测到,对于每个测试方法,调用的形式是:

testCase.setUp();
testCase.testXXX();
testCase.tearDown();   

 

 
运行测试方法

在Eclipse中,可以直接在类名或测试方法上右击,在弹出的右击菜单中选择Run As -> JUnit Test。
在Mvn中,可以直接通过mvn test命令运行测试用例。
也可以通过Java方式调用,创建一个TestCase实例,然后重载runTest()方法,在其方法内调用测试方法(可以多个)。

TestCase test = new Junit3TestCase("mathPow") {
        // 重载
    protected void runTest() throws Throwable {
        testMathPow();
    };
};
test.run();

 

 

更加便捷地,可以在创建TestCase实例时直接传入测试方法名称,JUnit会自动调用此测试方法,如

TestCase test = new Junit3TestCase("testMathPow");
test.run();

 

 
Junit TestSuite

TestSuite是测试用例套件,能够运行过个测试方法。如果不指定TestSuite,会创建一个默认的TestSuite。默认TestSuite会扫描当前内中的所有测试方法,然后运行。
如果不想采用默认的TestSuite,则可以自定义TestSuite。在TestCase中,可以通过静态方法suite()返回自定义的suite。

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
 
public class Junit3TestCase extends TestCase {
        //...
    public static Test suite() {
        System.out.println("create suite");
        TestSuite suite = new TestSuite();
        suite.addTest(new Junit3TestCase("testMathPow"));
        return suite;
    }
}

 

 

允许上述方法,控制台输出

写道
create suite
Set up
Test Math.pow
Tear down

 

 

并且只运行了testMathPow测试方法,而没有运行testMathMin测试方法。通过显式指定测试方法,可以控制测试执行的顺序。

也可以通过Java的方式创建TestSuite,然后调用TestCase,如

 

// 先创建TestSuite,再添加测试方法
TestSuite testSuite = new TestSuite();
testSuite.addTest(new Junit3TestCase("testMathPow"));
 
// 或者 传入Class,TestSuite会扫描其中的测试方法。
TestSuite testSuite = new TestSuite(Junit3TestCase.class,Junit3TestCase2.class,Junit3TestCase3.class);
 
// 运行testSuite
TestResult testResult = new TestResult();
testSuite.run(testResult);
 

 

 

testResult中保存了很多测试数据,包括运行测试方法数目(runCount)等。

JUnit4

与JUnit3不同,JUnit4通过注解的方式来识别测试方法。目前支持的主要注解有:

  • @BeforeClass 全局只会执行一次,而且是第一个运行
  • @Before 在测试方法运行之前运行
  • @Test 测试方法
  • @After 在测试方法运行之后允许
  • @AfterClass 全局只会执行一次,而且是最后一个运行
  • @Ignore 忽略此方法

下面举一个样例:

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
 
public class Junit4TestCase {
 
    @BeforeClass
    public static void setUpBeforeClass() {
        System.out.println("Set up before class");
    }
 
    @Before
    public void setUp() throws Exception {
        System.out.println("Set up");
    }
 
    @Test
    public void testMathPow() {
        System.out.println("Test Math.pow");
        Assert.assertEquals(4.0, Math.pow(2.0, 2.0), 0.0);
    }
 
    @Test
    public void testMathMin() {
        System.out.println("Test Math.min");
        Assert.assertEquals(2.0, Math.min(2.0, 4.0), 0.0);
    }
 
        // 期望此方法抛出NullPointerException异常
    @Test(expected = NullPointerException.class)
    public void testException() {
        System.out.println("Test exception");
        Object obj = null;
        obj.toString();
    }
 
        // 忽略此测试方法
    @Ignore
    @Test
    public void testMathMax() {
          Assert.fail("没有实现");
    }
        // 使用“假设”来忽略测试方法
    @Test
    public void testAssume(){
        System.out.println("Test assume");
                // 当假设失败时,则会停止运行,但这并不会意味测试方法失败。
        Assume.assumeTrue(false);
        Assert.fail("没有实现");
    }
 
    @After
    public void tearDown() throws Exception {
        System.out.println("Tear down");
    }
 
    @AfterClass
    public static void tearDownAfterClass() {
        System.out.println("Tear down After class");
    }
 
}

 

 

如果细心的话,会发现Junit3的package是junit.framework,而Junit4是org.junit
执行此用例后,控制台会输出

写道
Set up before class
Set up
Test Math.pow
Tear down
Set up
Test Math.min
Tear down
Set up
Test exception
Tear down
Set up
Test assume
Tear down
Tear down After class

 

 

可以看到,执行次序是@BeforeClass -> @Before -> @Test -> @After -> @Before -> @Test -> @After -> @AfterClass@Ignore会被忽略。

运行测试方法

与Junit3类似,可以在Eclipse中运行,也可以通过mvn test命令运行。

Assert

Junit3和Junit4都提供了一个Assert类(虽然package不同,但是大致差不多)。Assert类中定义了很多静态方法来进行断言。列表如下:

  • assertTrue(String message, boolean condition) 要求condition == true
  • assertFalse(String message, boolean condition) 要求condition == false
  • fail(String message) 必然失败,同样要求代码不可达
  • assertEquals(String message, XXX expected,XXX actual) 要求expected.equals(actual)
  • assertArrayEquals(String message, XXX[] expecteds,XXX [] actuals) 要求expected.equalsArray(actual)
  • assertNotNull(String message, Object object) 要求object!=null
  • assertNull(String message, Object object) 要求object==null
  • assertSame(String message, Object expected, Object actual) 要求expected == actual
  • assertNotSame(String message, Object unexpected,Object actual) 要求expected != actual
  • assertThat(String reason, T actual, Matcher matcher) 要求matcher.matches(actual) == true

Mock/Stub

Mock和Stub是两种测试代码功能的方法。Mock测重于对功能的模拟。Stub测重于对功能的测试重现。比如对于List接口,Mock会直接对List进行模拟,而Stub会新建一个实现了List的TestList,在其中编写测试的代码。
强烈建议优先选择Mock方式,因为Mock方式下,模拟代码与测试代码放在一起,易读性好,而且扩展性、灵活性都比Stub好。
比较流行的Mock有:

其中EasyMock和Mockito对于Java接口使用接口代理的方式来模拟,对于Java类使用继承的方式来模拟(也即会创建一个新的Class类)。Mockito支持spy方式,可以对实例进行模拟。但它们都不能对静态方法和final类进行模拟,powermock通过修改字节码来支持了此功能。

EasyMock

IBM上有几篇介绍EasyMock使用方法和原理的文章:EasyMock 使用方法与原理剖析使用 EasyMock 更轻松地进行测试
EasyMock把测试过程分为三步:录制、运行测试代码、验证期望。
录制过程大概就是:期望method(params)执行times次(默认一次),返回result(可选),抛出exception异常(可选)。
验证期望过程将会检查方法的调用次数。
一个简单的样例是:

 

@Test
public void testListInEasyMock() {
    List list = EasyMock.createMock(List.class);
    // 录制过程
 
    // 期望方法list.set(0,1)执行2次,返回null,不抛出异常
    expect1: EasyMock.expect(list.set(0, 1)).andReturn(null).times(2);
    // 期望方法list.set(0,1)执行1次,返回null,不抛出异常
    expect2: EasyMock.expect(list.set(0, 1)).andReturn(1);
 
    // 执行测试代码
    EasyMock.replay(list);
        // 执行list.set(0,1),匹配expect1期望,会返回null
    Assert.assertNull(list.set(0, 1));
        // 执行list.set(0,1),匹配expect1(因为expect1期望执行此方法2次),会返回null
    Assert.assertNull(list.set(0, 1));
        // 执行list.set(0,1),匹配expect2,会返回1
    Assert.assertEquals(1, list.set(0, 1));
 
    // 验证期望
    EasyMock.verify(list);
}
 

 

 

EasyMock还支持严格的检查,要求执行的方法次序与期望的完全一致。

Mockito

Mockito是Google Code上的一个开源项目,Api相对于EasyMock更好友好。与EasyMock不同的是,Mockito没有录制过程,只需要在“运行测试代码”之前对接口进行Stub,也即设置方法的返回值或抛出的异常,然后直接运行测试代码,运行期间调用Mock的方法,会返回预先设置的返回值或抛出异常,最后再对测试代码进行验证。可以查看此文章了解两者的不同。
官方提供了很多样例,基本上包括了所有功能,可以去看看
这里从官方样例中摘录几个典型的:

  • 验证调用行为
    import static org.mockito.Mockito.*;
     
    //创建Mock
    List mockedList = mock(List.class);
     
    //使用Mock对象
    mockedList.add("one");
    mockedList.clear();
     
    //验证行为
    verify(mockedList).add("one");
    verify(mockedList).clear();
     
     
  • 对Mock对象进行Stub
    //也可以Mock具体的类,而不仅仅是接口
    LinkedList mockedList = mock(LinkedList.class);
     
    //Stub
    when(mockedList.get(0)).thenReturn("first"); // 设置返回值
    when(mockedList.get(1)).thenThrow(new RuntimeException()); // 抛出异常
     
    //第一个会打印 "first"
    System.out.println(mockedList.get(0));
     
    //接下来会抛出runtime异常
    System.out.println(mockedList.get(1));
     
    //接下来会打印"null",这是因为没有stub get(999)
    System.out.println(mockedList.get(999));
      
    // 可以选择性地验证行为,比如只关心是否调用过get(0),而不关心是否调用过get(1)
    verify(mockedList).get(0);
     
     

代码覆盖率

比较流行的工具是Emma和Jacoco,Ecliplse插件有eclemma。eclemma2.0之前采用的是Emma,之后采用的是Jacoco。这里主要介绍一下Jacoco。Eclmama由于是Eclipse插件,所以非常易用,就不多做介绍了。

Jacoco

Jacoco可以嵌入到Ant、Maven中,也可以使用Java Agent技术监控任意Java程序,也可以使用Java Api来定制功能。
Jacoco会监控JVM中的调用,生成监控结果(默认保存在jacoco.exec文件中),然后分析此结果,配合源代码生成覆盖率报告。需要注意的是:监控和分析这两步,必须使用相同的Class文件,否则由于Class不同,而无法定位到具体的方法,导致覆盖率均为0%。

Java Agent嵌入

首先,需要下载jacocoagent.jar文件,然后在Java程序启动参数后面加上 -javaagent:[yourpath/]jacocoagent.jar=[option1]=[value1],[option2]=[value2],具体的options可以在此页面找到。默认会在JVM关闭时(注意不能是kill -9),输出监控结果到jacoco.exec文件中,也可以通过socket来实时地输出监控报告(可以在Example代码中找到简单实现)。

Java Report

可以使用Ant、Mvn或Eclipse来分析jacoco.exec文件,也可以通过API来分析。

public void createReport() throws Exception {
            // 读取监控结果
    final FileInputStream fis = new FileInputStream(new File("jacoco.exec"));
    final ExecutionDataReader executionDataReader = new ExecutionDataReader(fis);
            // 执行数据信息
    ExecutionDataStore executionDataStore = new ExecutionDataStore();
            // 会话信息
    SessionInfoStore sessionInfoStore = new SessionInfoStore();
 
    executionDataReader.setExecutionDataVisitor(executionDataStore);
    executionDataReader.setSessionInfoVisitor(sessionInfoStore);
 
    while (executionDataReader.read()) {
    }
 
    fis.close();
             
            // 分析结构
            final CoverageBuilder coverageBuilder = new CoverageBuilder();
    final Analyzer analyzer = new Analyzer(executionDataStore, coverageBuilder);
 
            // 传入监控时的Class文件目录,注意必须与监控时的一样
    File classesDirectory = new File("classes");
    analyzer.analyzeAll(classesDirectory);
 
    IBundleCoverage bundleCoverage = coverageBuilder.getBundle("Title");
            // 输出报告
        File reportDirectory = new File("report"); // 报告所在的目录
    final HTMLFormatter htmlFormatter = new HTMLFormatter();  // HTML格式
    final IReportVisitor visitor = htmlFormatter.createVisitor(new FileMultiReportOutput(reportDirectory));
            // 必须先调用visitInfo
    visitor.visitInfo(sessionInfoStore.getInfos(), executionDataStore.getContents());
    File sourceDirectory = new File("src"); // 源代码目录
            // 遍历所有的源代码
            // 如果不执行此过程,则在报告中只能看到方法名,但是无法查看具体的覆盖(因为没有源代码页面)
    visitor.visitBundle(bundleCoverage, new DirectorySourceFileLocator(sourceDirectory, "utf-8", 4));
            // 执行完毕
    visitor.visitEnd();
}

 

 
2
1
分享到:
评论
4 楼 wanghui5493701 2013-06-07  
thihy 写道
wanghui5493701 写道
能否交流下

OK~。

你也需要做JUnit测试?
3 楼 thihy 2013-06-05  
wanghui5493701 写道
能否交流下

OK~。
2 楼 wanghui5493701 2013-06-05  
能否交流下
1 楼 wanghui5493701 2013-06-05  

相关推荐

    深入学习Java单元测试(Junit+Mock+代码覆盖率)

    深入学习Java单元测试(Junit+Mock+代码覆盖率) Java单元测试是软件测试的一种,旨在验证软件的正确性和可靠性。单元测试是编写测试代码,用来检测特定的、明确的、细颗粒的功能。单元测试并不一定保证程序功能是...

    单元测试案例junit +spring mvc +springboot

    使用JaCoCo或Cobertura等工具,可以度量代码覆盖率,确保测试覆盖到足够的代码行和分支,提高测试质量。 7. 持续集成与自动化测试 将单元测试集成到持续集成/持续部署(CI/CD)流程中,如Jenkins、GitLab CI/CD或...

    测试+JUnit+单元测试+学习阶段

    JUnit作为Java领域最流行的单元测试框架,是开发者必备的工具之一。本学习阶段将带你深入理解和掌握JUnit的使用,以及如何通过单元测试来提升代码质量。 首先,我们需要了解什么是单元测试。单元测试是对软件中的...

    junit4 jar包 Java单元测试框架绿色免费版.zip

    JUnit4是Java编程语言中最广泛使用的单元测试框架之一,它为开发者提供了一种...不过,在企业级项目中,可能还需要考虑与持续集成工具(如Jenkins)、代码覆盖率工具(如JaCoCo)等进行集成,以实现更全面的测试流程。

    junit单元测试及Mock应用,超详细的PPT实战应用

    总结来说,本文档提供的内容涵盖了单元测试的基本概念、Mock技术的运用、JUnit框架的详细讲解,以及Mockito、MockMVC和Mock.js等工具的使用。通过这些知识,开发者可以构建更健壮的测试体系,提升代码质量和软件工程...

    Junit+EasyMock单元测试的jar包

    Junit支持参数化测试、异常测试、定时测试等,大大提高了测试的灵活性和覆盖率。在Junit中,可以使用setUp()和tearDown()方法设置测试前后的环境,或者使用@Before和@After注解来实现相同的功能。 EasyMock则是一个...

    SSM中进行单元测试Junit4+spring-test所需jar包

    7. **测试覆盖率**:考虑使用代码覆盖率工具(如JaCoCo或Cobertura)来检查测试覆盖了多少代码,以确保测试的全面性。 8. **集成测试**:除了单元测试,你还可以使用`@WebAppConfiguration`和`@...

    java单元测试.rar

    JaCoCo是一个常用的Java代码覆盖率工具,可以帮助开发者了解哪些代码段未被测试到。 7. 测试驱动开发(TDD):这是一种编程实践,提倡先写测试,再编写实现代码。这样可以确保代码一开始就满足需求,并且易于维护。...

    spring MVC junit 单元测试(controller)

    JUnit是Java中最常用的单元测试框架,它提供了编写和运行可重复测试的便利工具。在Spring MVC中,我们可以利用Spring的TestContext框架和MockMVC库来模拟HTTP请求,对Controller进行隔离测试。 进行Spring MVC ...

    java单元测试demo

    总结来说,这个"java单元测试demo"是关于如何使用JUnit进行接口的功能测试,通过编写测试用例、设置断言以及可能的模拟技术,确保接口的输入和输出符合预期,从而提升代码质量和可维护性。通过运行测试并查看结果,...

    java程序员白盒单元测试必备技能 -- Junit4

    Java程序员在进行软件开发时,单元测试是必不可少的一环,以确保代码的正确性和稳定性。Junit4作为Java领域中最常用的单元测试框架,是每个Java开发者必须掌握的技能之一。这篇压缩包文件中的"Junit4教程.doc"文档,...

    Java单元测试Java单元测试Java单元测试Java单元测试

    Java单元测试是软件开发过程中的重要环节,它主要用于验证代码的独立模块是否按照预期工作。在Java编程中,单元测试确保了每一小部分代码(如方法或类)都能单独、正确地执行,从而提高整体软件质量,降低维护成本。...

    junit mock

    总结来说,JUnit作为Java单元测试的核心工具,结合Mock Objects技术,可以有效地测试和验证代码的正确性。遵循良好的测试实践,如细粒度测试、测试隔离和自动化测试运行,将有助于构建健壮、可靠的软件系统。

    单元测试利器JUnit4

    JUnit4作为Java平台上最流行的单元测试框架,极大地简化了测试代码的编写和执行。本篇将深入探讨JUnit4的相关知识点,帮助你更好地掌握这个强大的工具。 1. JUnit4简介: JUnit4是由Ernst Kuhr和Kent Beck开发的...

    单元测试 单元测试 java

    JUnit是Java领域最广泛使用的单元测试框架,它提供了丰富的注解、断言和测试结构,使得测试代码编写简洁且易于理解。以下是一些关于单元测试和JUnit的重要知识点: 1. **测试驱动开发(TDD)** - TDD是一种软件开发...

    java 单元测试

    JaCoCo和Cobertura是Java的代码覆盖率工具,可以帮助开发者了解哪些代码段还未被测试覆盖。 8. **持续集成**:在实际项目中,单元测试通常是自动化构建和持续集成的一部分。工具如Jenkins、Travis CI或GitLab CI/CD...

    软件测试 JUnit NUnit测试 C# java

    JUnit和NUnit是两种流行的单元测试框架,分别用于Java和C#编程语言。本篇将深入探讨这些关键知识点及其在实际开发中的应用。 首先,软件测试是软件开发过程中的一个核心部分,其主要目的是找出并修复程序中的错误、...

    java单元测试之道

    在Java开发过程中,单元测试是不可或缺的一环,它能够确保代码的质量、提高开发效率,并且在维护和重构时提供安全保障。单元测试之道在于理解和掌握如何有效地编写和组织这些测试,以便它们能有效地服务于整个项目...

Global site tag (gtag.js) - Google Analytics