亚洲kkk4444在线观看,亚洲第一成年网站视频,中国china体内裑精亚洲日本

关于TestNG

Thu, 05 Oct 2006 07:44:00 GMT

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


 
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插�g�Q�就��单多了�?b>

      下面来看一下，如何来实现测试的�Q�与JUnit4 差不多（怀疑，JUnit4是不是有抄袭TestNG的成分）�?br />    声明��试�Ҏ(gu��)��如下�Q?span style="font-size: 10.5pt; font-family: "Times New Roman";" lang="EN-US">

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

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

基本上都是采用java5的注释实现的�?br /> 与JUnit4 不同在于�Q�测试方法可以分�l�，它可以根据诸如运行时间这��L��特征来对��试分类�?br />

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

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

同JUnit4 一��P��同样支持Before,After�Ҏ(gu��)��Q�如同setUp 和tearDown,不过TestNG更�ؓ灉|��Q�支持各�U�签名方式，如private,protected�?br />

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

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

同样也支持BeforeClass 和AfterClass�Q�只执行一�ơ的�Ҏ(gu��)��Q�但是可以不需要��用static�{�֐�

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

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

不同于JUnit4�Q�TestNG提供了以下的�Ҏ(gu��)��：
依赖性测�?br /> JUnit 框架惌��到的一个目标就是测试隔��R��它的缺�Ҏ(gu��)��Q��h们很隄��定测试用例执行的��序�Q�而这对于��M��c�d��的依赖性测试都非常重要。开发者们使用了多�U�技术来解决�q�个问题�Q�例如，按字母顺序指定测试用例，或是更多��C��?fixture 来适当地解决问题�?br /> �?JUnit 不同�Q�TestNG 利用 Test 注释�? dependsOnMethods 属性来应对��试的依赖性问题。有了这个便利的�Ҏ(gu��)��，��可以轻松指定依赖方法。如以下定义�Q�testMethod2依赖于testMethod1�?br />

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

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

当然如果testMethod1��p�|的话�Q�默认testMethod2也不会执行，不过只需要设�|�alwaysRun = true�Q�则可以跌��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");
    }

��p�|和重�q�行
在大型测试套件中�Q�这�U�重新运行失败测试的能力昑־��ؓ方便。这�?TestNG 独有的一个特性。在 JUnit 4 中，如果��试套�g包括 1000 ��Ҏ(gu��)��试，其中 3 ��失败，很可能就会迫使�?zh��n)�重新�q�行整个��试套�g�Q�修攚w��误以后）。不用说�Q�这��L��工作可能会耗费几个��时�?

一�?TestNG 中出现失败，它就会创��Z��?XML 配置文�g�Q�对��p�|的测试加以说明。如果利用这个文件执�?TestNG �q�行�E�序�Q�TestNG ��?i>�?/i> �q�行��p�|的测试。所以，在前面的例子里，�(zh��n)�只需重新�q�行那三个失败的��试�Q�而不是整个测试套件。可以看��C��下的��p�|文�g�Q�一般命名�ؓtestng-failed.xml�Q�以后只需要运行此文�g��可以了�?/p>

参数化测�?br /> TestNG 中另一个有��的�Ҏ(gu��)��是参数化测�?/i>。在 JUnit 中，如果�(zh��n)�想改变某个受测�Ҏ(gu��)��的参数组�Q�就只能�l?i>每个 不同的参数组�~�写一个测试用例。多数情况下�Q�这不会带来太多�ȝ��。然而，我们有时会碰��C��些情况，对其中的业务逻辑�Q�需要运行的��试数目变化范围很大�?br /> 在这��L��情况下，使用 JUnit 的测试�h员往往会�{而��?FIT �q�样的框�Ӟ��因�ؓ�q�样��可以用表格数据驱动��试。但�?TestNG 提供了开��即用的�c�M��Ҏ(gu��)��。通过�?TestNG �?XML 配置文�g中放入参数化数据�Q�就可以对不同的数据集重用同一个测试用例，甚至有可能会得到不同的结果。这�U�技术完��地避免�?i>只能假定一切正常的��试�Q�或是没有对边界�q�行有效验证的情��c�?br />

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

在xml中设�|�相应的参数��|��可以攑օ�suite下面或者test下面�Q�如果同名，一般test下面的定义覆盖suite定义�?br />

高��参数化测�?br /> ��管从一�?XML 文�g中抽取数据会很方便，但偶��会有些��试需要有复杂�c�d��Q�这些类型无法用 String 或原语值来表示。TestNG 可以通过它的 @DataProvider 注释处理�q�样的情��c�?code>@DataProvider 注释可以方便地把复杂参数�c�d��映射到某个测试方法。例如，清单 7 中的 verifyHierarchy ��试中，我采用了重蝲�?buildHierarchy �Ҏ(gu��)��Q�它可接收一�?Class �c�d��的数�? 它断�a��Q�asserting�Q?code>Hierarchy �? getHierarchyClassNames() �Ҏ(gu��)��应该�q�回一个适当的字�W�串数组�Q?br />

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");		
 }
}

当然�q�有一些其他的�Ҏ(gu��)��，��׃��一一详细说明了，有兴��可以参考相应的testNG文档�?br /> JUnit 4 �?TestNG 在表面上是相似的。然而，设计 JUnit 的目的是��Z��分析代码单元�Q��?TestNG 的预期用途则针对高�񔋹�试。对于大型测试套�Ӟ��我们不希望在某一��Ҏ(gu��)��试失败时��得重新�q�行数千��Ҏ(gu��)��试，TestNG 的灵�z�L��在�q�里��ؓ有用。这两个框架都有自己的优势，�(zh��n)�可以随意同时��用它们�?

布衣�?/a> 2006-10-05 15:44 发表评论

Tue, 03 Oct 2006 02:36:00 GMT

JUnit 4 已经出来很久了，基本上很多ide都开始支持，当然��Z��兼容性，一直不太敢用。以前都是懒得写单元��试�Q�大多数的时候都�? System.out.print。不�q�现在已�l�是��试驱动的时代了�Q��ؓ了保持一个良好的习惯�Q�还是需要好好的写写单元��试。断�a��q�比 System.out.print有用�?br /> 看了几篇文章之后�Q�对JUnit4已经有了基本的概念了。其实很多特性，testNg都已�l�实��C��Q�挺讨厌testNg的xml文�g�Q�不�q�testNg的灵�z�L��还是强大，对于大面�U�的�l��g��试比较适合�?br /> JUnit 4应该说是使用新的架构写的�Q��用了很多java5的新�Ҏ(gu��)��?br /> 一个最关键的改变，��试�c�，可以不用�l�承那该�ȝ��TestCase�?��试�c�，可以更加灉|��Q�方法的定义不需要在前面增加test了�?br /> 对于��试�c�L��_��只需要做以下��单的动作�Q?br /> 增加一个@Test�Q�用于标注相应的��试�Ҏ(gu��)��。��用Assert�c�，来进行断�a��?br />

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来说�Q�以后可以不用再�l�承�q�两个方法了。可以��用自定义的方法，只需要在前面增加@Before 和@After 注释卛_��?br />

@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();

}

�q�且可以注释多个�Ҏ(gu��)��?br />
当然JUnit4 也引入了一�?span lang="EN-US"> JUnit 3 中没有的新特性：�c�范围的 setUp() �?tearDown() �Ҏ(gu��)��。�Q何用 @BeforeClass 注释的方法都��在该类中的��试�Ҏ(gu��)��q�行之前刚好�q�行一�ơ，而�Q何用 @AfterClass 注释的方法都��在该类中的所有测试都�q�行之后刚好�q�行一�ơ�?br /> �?如，假设�c�M��的每个测试都使用一个数据库�q�接、一个网�l�连接、一个非常大的数据结构，或者还有一些对于初始化和事情安排来说比较昂�늚�其他资源。不要在�? 个测试之前都重新创徏它，�(zh��n)�可以创建它一�ơ，�q�还原它一�ơ。该�Ҏ(gu��)��得有些测试案例运行�v来快得多�?br />

// 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);

}

异常��试�?span lang="EN-US"> JUnit 4 中的最大改�q�。旧式的异常��试是在抛出异常的代码中攑օ� try 块，然后�?try 块的末尾加入一�?fail() 语句�?br />该方法不仅难看，而且试图挑战代码覆盖工具�Q�因��Z��测试是通过�q�是��p�|�Q��L��一些代码不被执行�?/span>�?span lang="EN-US"> JUnit 4 中，�(zh��n)�现在可以编写抛出异常的代码�Q��ƈ使用注释来声明该异常是预期的�Q?

@Test(expected=ArithmeticException.class)

public void divideByZero() {

int n = 2 / 0;

}

如果该异常没有抛出（或者抛��Z��一个不同的异常�Q�，那么��试��将��p�|。但是如果�?zh��n)�惌��试异常的详�l�消息或其他属性，则仍焉��要��用旧式的 try-catch 样式�?br /> ��试性能是单元测试最为痛苦的斚w��之一�?span lang="EN-US">JUnit 4 没有完全解决�q�个问题�Q�但是它对这个问题有所帮助。测试可以用一个超时参数来注释。如果测试运行的旉��过指定的毫�U�数�Q�则��试��p�|�?/span>

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

doc.query("http://*");

}

基本的特性就�q�么多，�q�些功能其实都可以在testNg中找到。不�q�JUnit�q�是不错的，对于单元��试来说�Q�这是首选的�?br />
当然��Z��兼容性，��Z��?span lang="EN-US"> JUnit 4 ��试可以�q�行�?span lang="EN-US"> JUnit 3 环境中，可以��它们包装在 JUnit4TestAdapter 中。将下面的方法添加到�(zh��n)�的 JUnit 4 ��试�c�M��应该��p��够了�Q?

public static junit.framework.Test suite() {

return new JUnit4TestAdapter(AssertionTest.class);

}

布衣�?/a> 2006-10-03 10:36 发表评论

EasyMock 2 使用指南

Wed, 20 Sep 2006 12:38:00 GMT

关于单元��试�Q�模拟对象一直是不可�~�少的，��其对于复杂的应用来说�?br />       �q�么多的模拟对象框架中，个�h觉得比较好用的当属EasyMock了。当然JMock也不错�?br />       下面��单介�l�一下EasyMock 。（基本��译EasyMock的文档，可能有些地方不是很恰当）

       EasyMock 2 主要用于�l�指定的接口提供模拟对象�?/span>

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

创徏和维�?/span> Mock 对象�l�常是繁琐的��d��Q��ƈ且可能会引入错误�?/span> EasyMock 2 动态��?/span> Mock 对象�Q�不需要创建，�q�且不会产生代码�?/span>

有利的方面：

不需要手工写�c�L��处理 mock 对象�?/span>

支持安全的重�?/span> Mock 对象�Q�测试代码不会在�q�行期打断当重新命名�Ҏ(gu��)��或者更�Ҏ(gu��)��法参数�?/span>

支持�q�回值和例外�?/span>

支持��察方法调用次序，对于一个或者多�?/span> Mock 对象�?/span>

不利的方面： 2.0 仅��用于 java 2 版本 5.0 或者以�?/font>


    以一个例子来说明如何使用EasyMock:
   假设有一个合作接�?span style="font-size: 10.5pt; color: black;" lang="EN-US">Collaborator�Q?br />

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;
    }
}

�W�一�?/span>Mock 对象

我们��创�?/span>test case �q�且围绕此理解相关的EasyMock 包的功能。第一个测试方法，用于��是否删除一个不存在的文档，不会发通知�l�合作类�?br />

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");
    }
}

对于多数��试�c�，使用EasyMock 2,我们只需要静态引�?/span>org.easymock.EasyMock的方法�?/span>

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

��Z��取得Mock 对象�Q�需要：

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

l 记录期待的行�?/span>

l 转换�?/span>Mock对象�Q?/span>replay状态�?/span>

例如�Q?/span>

 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 �?/span>Collaborator接口�?/span>Mock对象�Q��ƈ且期待没有什么调用。这��意味着�Q�如果我们改�?/span>ClassUnderTest去调用此接口的�Q何方法，�?/span>Mock对象会抛�?/span>AssertionError�Q?/span>

 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)
    ...

增加行�ؓ

让我们开始第二个��试。如�?/span>document�?/span>classUnderTest增加�Q�我们期待调�?/span>
mock.documentAdded()�?span lang="EN-US">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对象会抛�?span lang="EN-US">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)
    ...

同样�Q�如果调用多�ơ此�Ҏ(gu��)��Q�则也会抛出例外�Q?/span>

 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)
    ...

验证行�ؓ

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

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

如果��p�|�Q�则抛出AssertionError

期待明显数量的调�?/span>

到现在，我们的测试只是调用一个简单的�Ҏ(gu��)��。下一个测试将会检��是否已�l�存�?/span>document��D��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);
    }

��Z��避免重复�?/span>mock.documentChanged("Document"),EasyMock提供一个快��h��式。可以通过调用�Ҏ(gu��)��expectLastCall().times(int times)来指定最后一�ơ调用的�ơ数�?/span>

  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);
    }

指定�q�回�?/span>

对于指定�q�回��|��我们通过��装expect(T value)�q�回的对象�ƈ且指定返回的��|��使用�Ҏ(gu��)��andReturn(Object returnValue)�?span lang="EN-US">expect(T value).�q�回的对象�?/span>

例如�Q?/span>

 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)调用�Q�可以通过expectLastCall().来代�?/span>

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

�{�同�?/span>

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

处理例外

对于指定的例�?/span>(更确切的:Throwables)被抛出，�?/span>expectLastCall()�?span lang="EN-US">expect(T value)�q�回的对象，提供了方�?/span>andThrow(Throwable throwable)。方法不得不被调用记录状态，在调�?span lang="EN-US">Mock对象后，对于此指定了要抛出的Throwable�?span lang="EN-US">

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

布衣�?/a> 2006-09-20 20:38 发表评论