BlogJava-闲人野居-随笔分类-单元测试

关于TestNG

布衣郎 — Thu, 05 Oct 2006 07:44:00 GMT

       TestNG是一个不错的测试框架，尤其是用于模块测试，以及大范围的测试。相对于JUnit来说，更为灵活。随着JUnit4的推出，很多功能都与TestNG相似，但相对于JUnit4，TestNG还是有很多部分是有区别的。
      TestNG的IDE支持也不错，对于Eclipse,Idea,Ant都有很好的支持。
      先来看一看怎么使用TestNG，当然首先需要下载TestNG包。目前的版本为5.1，下载地址如下：
http://testng.org/doc/download.html ，也可以下载相应的Eclipse插件。
      运行TestNG，可以从命令行或者IDE，或者Ant中运行。
      命令行：
      java org.testng.TestNG -groups windows,linux -testclass org.test.MyTest
      对于大型的测试，需要定义一个xml文件，一般为testng.xml。


 
name="Suite1"    verbose="1" >
name="Nopackage" >

       name="NoPackageTest"  />



name="Regression1"   >

name="test.sample.ParameterSample"  />
name="test.sample.ParameterTest" />

     java org.testng.TestNG testng.xml
     当然如果使用Eclipse插件，就简单多了。

      下面来看一下，如何来实现测试的，与JUnit4 差不多（怀疑，JUnit4是不是有抄袭TestNG的成分）。
    声明测试方法如下：

  @Test
    public void testMethod1() {
        System.out.println("in testMethod1");
    }

@Test
    public void testMethod2() {
        System.out.println("in testMethod2");
    }

基本上都是采用java5的注释实现的。
与JUnit4 不同在于，测试方法可以分组，它可以根据诸如运行时间这样的特征来对测试分类。

  @Test(groups={"fun1","fun2"})
    public void testMethod1() {
        System.out.println("in testMethod1");
    }

@Test(groups={"fun1"})
    public void testMethod2() {
        System.out.println("in testMethod2");
    }

同JUnit4 一样，同样支持Before,After方法，如同setUp 和tearDown,不过TestNG更为灵活，支持各种签名方式，如private,protected。

    @BeforeMethod
    protected void beforeMethod() {
        System.out.println("in beforeMethod");
    }

    @AfterMethod
    protected void afterMethod() {
        System.out.println("in afterMethod");
    }

同样也支持BeforeClass 和AfterClass，只执行一次的方法，但是可以不需要使用static签名

    @BeforeClass
    protected void beforeClassMethod() {
        System.out.println("in beforeClassMethod");
    }

    @AfterClass
    protected void afterClassMethod() {
        System.out.println("in afterClassMethod");
    }

     不同于JUnit4，TestNG提供了以下的特性：
     依赖性测试
     JUnit 框架想达到的一个目标就是测试隔离。它的缺点是：人们很难确定测试用例执行的顺序，而这对于任何类型的依赖性测试都非常重要。开发者们使用了多种技术来解决这个问题，例如，按字母顺序指定测试用例，或是更多地依靠 fixture 来适当地解决问题。
      与 JUnit 不同，TestNG 利用 Test 注释的 dependsOnMethods 属性来应对测试的依赖性问题。有了这个便利的特性，就可以轻松指定依赖方法。如以下定义：testMethod2依赖于testMethod1。

    @Test
    public void testMethod1() {
        System.out.println("in testMethod1");
    }

    @Test(dependsOnMethods="testMethod1")
    public void testMethod2() {
        System.out.println("in testMethod2");
    }

当然如果testMethod1失败的话，默认testMethod2也不会执行，不过只需要设置alwaysRun = true，则可以跳过testMethod1

    @Test
    public void testMethod1() {
        System.out.println("in testMethod1");
        throw new RuntimeException("failed");
    }

    @Test(dependsOnMethods="testMethod1",alwaysRun = true)
    public void testMethod2() {
        System.out.println("in testMethod2");
    }

失败和重运行
在大型测试套件中，这种重新运行失败测试的能力显得尤为方便。这是 TestNG 独有的一个特性。在 JUnit 4 中，如果测试套件包括 1000 项测试，其中 3 项失败，很可能就会迫使您重新运行整个测试套件（修改错误以后）。不用说，这样的工作可能会耗费几个小时。

一旦 TestNG 中出现失败，它就会创建一个 XML 配置文件，对失败的测试加以说明。如果利用这个文件执行 TestNG 运行程序，TestNG 就只运行失败的测试。所以，在前面的例子里，您只需重新运行那三个失败的测试，而不是整个测试套件。可以看到以下的失败文件，一般命名为testng-failed.xml，以后只需要运行此文件就可以了。

    参数化测试
    TestNG 中另一个有趣的特性是参数化测试。在 JUnit 中，如果您想改变某个受测方法的参数组，就只能给每个不同的参数组编写一个测试用例。多数情况下，这不会带来太多麻烦。然而，我们有时会碰到一些情况，对其中的业务逻辑，需要运行的测试数目变化范围很大。
    在这样的情况下，使用 JUnit 的测试人员往往会转而使用 FIT 这样的框架，因为这样就可以用表格数据驱动测试。但是 TestNG 提供了开箱即用的类似特性。通过在 TestNG 的 XML 配置文件中放入参数化数据，就可以对不同的数据集重用同一个测试用例，甚至有可能会得到不同的结果。这种技术完美地避免了只能假定一切正常的测试，或是没有对边界进行有效验证的情况。

   @Parameters( { "first-name"
    })
    @Test(groups = { "param"
    })
    public void testParm(String firstName) {
        System.out.println("invoked testString:" + firstName);
        assertEquals(firstName, "Test");
    }

在xml中设置相应的参数值，可以放入suite下面或者test下面，如果同名，一般test下面的定义覆盖suite定义。

高级参数化测试
尽管从一个 XML 文件中抽取数据会很方便，但偶尔会有些测试需要有复杂类型，这些类型无法用 String 或原语值来表示。TestNG 可以通过它的 @DataProvider 注释处理这样的情况。@DataProvider 注释可以方便地把复杂参数类型映射到某个测试方法。例如，清单 7 中的 verifyHierarchy 测试中，我采用了重载的 buildHierarchy 方法，它可接收一个 Class 类型的数据, 它断言（asserting）Hierarchy 的 getHierarchyClassNames() 方法应该返回一个适当的字符串数组：

package test.com.acme.da.ng;

import java.util.Vector;

import static org.testng.Assert.assertEquals;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import com.acme.da.hierarchy.Hierarchy;
import com.acme.da.hierarchy.HierarchyBuilder;

public class HierarchyTest {

@DataProvider(name = "class-hierarchies")
 public Object[][] dataValues(){
  return new Object[][]{
   {Vector.class, new String[] {"java.util.AbstractList", 
     "java.util.AbstractCollection"}},
   {String.class, new String[] {}}
  };
 }

@Test(dataProvider = "class-hierarchies")
 public void verifyHierarchy(Class clzz, String[] names) 
  throws Exception{
    Hierarchy hier = HierarchyBuilder.buildHierarchy(clzz);
    assertEquals(hier.getHierarchyClassNames(), names, 
	  "values were not equal");		
 }
}

当然还有一些其他的特性，就不一一详细说明了，有兴趣可以参考相应的testNG文档。
JUnit 4 和 TestNG 在表面上是相似的。然而，设计 JUnit 的目的是为了分析代码单元，而 TestNG 的预期用途则针对高级测试。对于大型测试套件，我们不希望在某一项测试失败时就得重新运行数千项测试，TestNG 的灵活性在这里尤为有用。这两个框架都有自己的优势，您可以随意同时使用它们。

布衣郎 2006-10-05 15:44 发表评论

Junit 4新的特性

布衣郎 — Tue, 03 Oct 2006 02:36:00 GMT

    JUnit 4 已经出来很久了，基本上很多ide都开始支持，当然为了兼容性，一直不太敢用。以前都是懒得写单元测试，大多数的时候都是 System.out.print。不过现在已经是测试驱动的时代了，为了保持一个良好的习惯，还是需要好好的写写单元测试。断言远比 System.out.print有用。
    看了几篇文章之后，对JUnit4已经有了基本的概念了。其实很多特性，testNg都已经实现了，挺讨厌testNg的xml文件，不过testNg的灵活性还是强大，对于大面积的组件测试比较适合。
    JUnit 4应该说是使用新的架构写的，使用了很多java5的新特性。
    一个最关键的改变，测试类，可以不用继承那该死的TestCase了.测试类，可以更加灵活，方法的定义不需要在前面增加test了。
    对于测试类来说，只需要做以下简单的动作：
    增加一个@Test，用于标注相应的测试方法。使用Assert类，来进行断言。

import org.junit.Assert;

public class AdditionTest {

private int x = 1;

private int y = 1;

@Test public void addition() {

int z = x + y;

Assert.assertEquals(2, z);

}

当然可以使用java 5的static import 功能

import static org.junit.Assert.*;

public class AdditionTest {

private int x = 1;

private int y = 1;

@Test public void addition() {

int z = x + y;

assertEquals(2, z);

}

对于setUp 和tearDown来说，以后可以不用再继承这两个方法了。可以使用自定义的方法，只需要在前面增加@Before 和@After 注释即可。

@Before protected void initialize() {

System.setErr(new PrintStream(new ByteArrayOutputStream()));

inputDir = new File("data");

inputDir = new File(inputDir, "xslt");

inputDir = new File(inputDir, "input");

}

@After protected void disposeDocument() {

doc = null;

System.gc();

}

并且可以注释多个方法。

当然JUnit4 也引入了一个 JUnit 3 中没有的新特性：类范围的 setUp() 和 tearDown() 方法。任何用 @BeforeClass 注释的方法都将在该类中的测试方法运行之前刚好运行一次，而任何用 @AfterClass 注释的方法都将在该类中的所有测试都运行之后刚好运行一次。
例如，假设类中的每个测试都使用一个数据库连接、一个网络连接、一个非常大的数据结构，或者还有一些对于初始化和事情安排来说比较昂贵的其他资源。不要在每个测试之前都重新创建它，您可以创建它一次，并还原它一次。该方法将使得有些测试案例运行起来快得多。

// This class tests a lot of error conditions, which

// Xalan annoyingly logs to System.err. This hides System.err

// before each test and restores it after each test.

private PrintStream systemErr;

@BeforeClass protected void redirectStderr() {

systemErr = System.err; // Hold on to the original value

System.setErr(new PrintStream(new ByteArrayOutputStream()));

}

@AfterClass protected void tearDown() {

// restore the original value

System.setErr(systemErr);

}

异常测试是 JUnit 4 中的最大改进。旧式的异常测试是在抛出异常的代码中放入 try 块，然后在 try 块的末尾加入一个 fail() 语句。
该方法不仅难看，而且试图挑战代码覆盖工具，因为不管测试是通过还是失败，总有一些代码不被执行。在 JUnit 4 中，您现在可以编写抛出异常的代码，并使用注释来声明该异常是预期的：

@Test(expected=ArithmeticException.class)

public void divideByZero() {

int n = 2 / 0;

}

如果该异常没有抛出（或者抛出了一个不同的异常），那么测试就将失败。但是如果您想要测试异常的详细消息或其他属性，则仍然需要使用旧式的 try-catch 样式。
测试性能是单元测试最为痛苦的方面之一。JUnit 4 没有完全解决这个问题，但是它对这个问题有所帮助。测试可以用一个超时参数来注释。如果测试运行的时间超过指定的毫秒数，则测试失败。

@Test(timeout=500) public void retrieveAllElementsInDocument() {

doc.query("//*");

}

基本的特性就这么多，这些功能其实都可以在testNg中找到。不过JUnit还是不错的，对于单元测试来说，这是首选的。

当然为了兼容性，为了使 JUnit 4 测试可以运行在 JUnit 3 环境中，可以将它们包装在 JUnit4TestAdapter 中。将下面的方法添加到您的 JUnit 4 测试类中应该就足够了：

public static junit.framework.Test suite() {

return new JUnit4TestAdapter(AssertionTest.class);

}

布衣郎 2006-10-03 10:36 发表评论

EasyMock 2 使用指南

布衣郎 — Wed, 20 Sep 2006 12:38:00 GMT

关于单元测试，模拟对象一直是不可缺少的，尤其对于复杂的应用来说。
       这么多的模拟对象框架中，个人觉得比较好用的当属EasyMock了。当然JMock也不错。
       下面简单介绍一下EasyMock 。（基本翻译EasyMock的文档，可能有些地方不是很恰当）

       EasyMock 2 主要用于给指定的接口提供模拟对象。

模拟对象只是模拟领域代码直接的部分行为，能检测是否他们如定义中的被使用。使用 Mock 对象，来模拟合作接口，有助于隔离测试相应的领域类。

创建和维持 Mock 对象经常是繁琐的任务，并且可能会引入错误。 EasyMock 2 动态产生 Mock 对象，不需要创建，并且不会产生代码。

有利的方面：

不需要手工写类来处理 mock 对象。

支持安全的重构 Mock 对象：测试代码不会在运行期打断当重新命名方法或者更改方法参数。

支持返回值和例外。

支持检察方法调用次序，对于一个或者多个 Mock 对象。

不利的方面： 2.0 仅使用于 java 2 版本 5.0 或者以上


    以一个例子来说明如何使用EasyMock:
   假设有一个合作接口Collaborator：

package org.easymock.samples;
 
public interface Collaborator {
    void documentAdded(String title);
    void documentChanged(String title);
    void documentRemoved(String title);
    byte voteForRemoval(String title);
    byte[] voteForRemovals(String[] title);
}

我们主要的测试类为：

package org.easymock.samples;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class ClassUnderTest {
    private Set listeners = new HashSet();
    private Map documents = new HashMap();
    public void addListener(Collaborator listener) {
        listeners.add(listener);
    }
    public void addDocument(String title, byte[] document) {
        boolean documentChange = documents.containsKey(title);
        documents.put(title, document);
        if (documentChange) {
            notifyListenersDocumentChanged(title);
        } else {
            notifyListenersDocumentAdded(title);
        }
    }
    public boolean removeDocument(String title) {
        if (!documents.containsKey(title)) {
            return true;
        }
        if (!listenersAllowRemoval(title)) {
            return false;
        }
        documents.remove(title);
        notifyListenersDocumentRemoved(title);
        return true;
    }
    public boolean removeDocuments(String[] titles) {
        if (!listenersAllowRemovals(titles)) {
            return false;
        }
        for (String title : titles) {
            documents.remove(title);
            notifyListenersDocumentRemoved(title);
        }
        return true;
    }
    private void notifyListenersDocumentAdded(String title) {
        for (Collaborator listener : listeners) {
            listener.documentAdded(title);
        }
    }
    private void notifyListenersDocumentChanged(String title) {
        for (Collaborator listener : listeners) {
            listener.documentChanged(title);
        }
    }
    private void notifyListenersDocumentRemoved(String title) {
        for (Collaborator listener : listeners) {
            listener.documentRemoved(title);
        }
    }
    private boolean listenersAllowRemoval(String title) {
        int result = 0;
        for (Collaborator listener : listeners) {
            result += listener.voteForRemoval(title);
        }
        return result > 0;
    }
    private boolean listenersAllowRemovals(String[] titles) {
        int result = 0;
        for (Collaborator listener : listeners) {
            result += listener.voteForRemovals(titles);
        }
        return result > 0;
    }
}

第一个Mock 对象

我们将创建test case 并且围绕此理解相关的EasyMock 包的功能。第一个测试方法，用于检测是否删除一个不存在的文档，不会发通知给合作类。

package org.easymock.samples;
 
import junit.framework.TestCase;
 
public class ExampleTest extends TestCase {
 
    private ClassUnderTest classUnderTest;
    private Collaborator mock;
 
    protected void setUp() {
        classUnderTest = new ClassUnderTest();
        classUnderTest.addListener(mock);
    }
 
    public void testRemoveNonExistingDocument() {    
        // This call should not lead to any notification
        // of the Mock Object: 
        classUnderTest.removeDocument("Does not exist");
    }
}

对于多数测试类，使用EasyMock 2,我们只需要静态引入org.easymock.EasyMock的方法。

 import static org.easymock.EasyMock.*;
import junit.framework.TestCase;
 
public class ExampleTest extends TestCase {
 
    private ClassUnderTest classUnderTest;
    private Collaborator mock;
    
}

为了取得Mock 对象，需要：

l 创建Mock 对象从需要模拟的接口

l 记录期待的行为

l 转换到Mock对象，replay状态。

例如：

 protected void setUp() {
        mock = createMock(Collaborator.class); // 1
        classUnderTest = new ClassUnderTest();
        classUnderTest.addListener(mock);
    }

 public void testRemoveNonExistingDocument() {
        // 2 (we do not expect anything)
        replay(mock); // 3
        classUnderTest.removeDocument("Does not exist");
    }

在执行第三步后，mock 为Collaborator接口的Mock对象，并且期待没有什么调用。这就意味着，如果我们改变ClassUnderTest去调用此接口的任何方法，则Mock对象会抛出AssertionError：

 java.lang.AssertionError: 
  Unexpected method call documentRemoved("Does not exist"):
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentRemoved(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentRemoved(ClassUnderTest.java:74)
    at org.easymock.samples.ClassUnderTest.removeDocument(ClassUnderTest.java:33)
    at org.easymock.samples.ExampleTest.testRemoveNonExistingDocument(ExampleTest.java:24)
    ...

增加行为

让我们开始第二个测试。如果document被classUnderTest增加，我们期待调用
mock.documentAdded()在Mock对象使用document的标题作为参数：

  public void testAddDocument() {
        mock.documentAdded("New Document"); // 2
        replay(mock); // 3
        classUnderTest.addDocument("New Document", new byte[0]); 
    }

如果classUnderTest.addDocument("New Document", new byte[0])调用期待的方法，使用错误的参数，Mock对象会抛出AssertionError:

 java.lang.AssertionError: 
  Unexpected method call documentAdded("Wrong title"):
    documentAdded("New Document"): expected: 1, actual: 0
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentAdded(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentAdded(ClassUnderTest.java:61)
    at org.easymock.samples.ClassUnderTest.addDocument(ClassUnderTest.java:28)
    at org.easymock.samples.ExampleTest.testAddDocument(ExampleTest.java:30)
    ...

同样，如果调用多次此方法，则也会抛出例外：

 java.lang.AssertionError: 
  Unexpected method call documentAdded("New Document"):
    documentAdded("New Document"): expected: 1, actual: 1 (+1)
    at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:29)
    at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:44)
    at $Proxy0.documentAdded(Unknown Source)
    at org.easymock.samples.ClassUnderTest.notifyListenersDocumentAdded(ClassUnderTest.java:62)
    at org.easymock.samples.ClassUnderTest.addDocument(ClassUnderTest.java:29)
    at org.easymock.samples.ExampleTest.testAddDocument(ExampleTest.java:30)
    ...

验证行为

当我们指定行为后，我们将验证实际发生的。当前的测试将会判断是否Mock对象会真实调用。可以调用verify(mock)来山正是否指定的行为被调用。

 public void testAddDocument() {
        mock.documentAdded("New Document"); // 2 
        replay(mock); // 3
        classUnderTest.addDocument("New Document", new byte[0]);
        verify(mock);
    }

如果失败，则抛出AssertionError

期待明显数量的调用

到现在，我们的测试只是调用一个简单的方法。下一个测试将会检测是否已经存在document导致mock.documentChanged()调用。为了确认，调用三次

 public void testAddAndChangeDocument() {
        mock.documentAdded("Document");
        mock.documentChanged("Document");
        mock.documentChanged("Document");
        mock.documentChanged("Document");
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        verify(mock);
    }

为了避免重复的mock.documentChanged("Document"),EasyMock提供一个快捷方式。可以通过调用方法expectLastCall().times(int times)来指定最后一次调用的次数。

  public void testAddAndChangeDocument() {
        mock.documentAdded("Document");
        mock.documentChanged("Document");
        expectLastCall().times(3);
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        classUnderTest.addDocument("Document", new byte[0]);
        verify(mock);
    }

指定返回值

对于指定返回值，我们通过封装expect(T value)返回的对象并且指定返回的值，使用方法andReturn(Object returnValue)于expect(T value).返回的对象。

例如：

 public void testVoteForRemoval() {
        mock.documentAdded("Document");   // expect document addition
        // expect to be asked to vote for document removal, and vote for it
        expect(mock.voteForRemoval("Document")).andReturn((byte) 42);
        mock.documentRemoved("Document"); // expect document removal
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        assertTrue(classUnderTest.removeDocument("Document"));
        verify(mock);
    } 
 
    public void testVoteAgainstRemoval() {
        mock.documentAdded("Document");   // expect document addition
        // expect to be asked to vote for document removal, and vote against it
        expect(mock.voteForRemoval("Document")).andReturn((byte) -42);
        replay(mock);
        classUnderTest.addDocument("Document", new byte[0]);
        assertFalse(classUnderTest.removeDocument("Document"));
        verify(mock);
    }

取代expect(T value)调用，可以通过expectLastCall().来代替

 expect(mock.voteForRemoval("Document")).andReturn((byte) 42);

等同于

 mock.voteForRemoval("Document");
expectLastCall().andReturn((byte) 42);

处理例外

对于指定的例外(更确切的:Throwables)被抛出，由expectLastCall()和expect(T value)返回的对象，提供了方法andThrow(Throwable throwable)。方法不得不被调用记录状态，在调用Mock对象后，对于此指定了要抛出的Throwable。

基本的方法，已经说完了，当然这不能完全说明EasyMock的使用。更多的因素请参考EasyMock的文档
http://www.easymock.org/Documentation.html

布衣郎 2006-09-20 20:38 发表评论