单元测试中的伪对象

　　当他在准备态时，开发人员可以调用伪对象的方法。首先规定哪一个调用方法的行为需要被定义。然后开发人员可以使用行为定义的方法之一来定义行为。例如，看一下下面的Foo类：
　　//Foo.java     public class Foo {       public void dummy() throw ParseException {         ...       }       public String bar(int i) {         ...       }       public boolean isSame(String[] strs) {         ...       }       public void add(StringBuffer sb， String s) {         ...       }     }伪对象的行为可以按照下面的方式来定义：
　　//get mock control     MockControl control = MockControl.createControl(Foo.class);     //get mock object     Foo foo = (Foo)control.getMock();     //begin behavior definition     //specify which method invocation's behavior     //to be defined.     foo.bar(10);     //define the behavior -- return "ok" when the     //argument is 10     control.setReturnValue("ok");     ...     //end behavior definition     control.replay();     ...MockControl中超过50个方法是行为定义方法。他们可以如下分类。
　　o        setReturnValue()
　　这些方法被用来定义后的方法调用应该返回一个值作为参数。这儿有7个使用原始类型作业参数的`setReturnValue()方法，如setReturnValue(int i)或setReturnValue(float f)。setReturnValue(Object obj)被用来满足那些需要对象作为参数的方法。如果给定的值不匹配方法的返回值，则抛出AssertionFailedError异常。
　　当然也可以在行为中加入预期调用的次数。这称为调用次数限制。
　　MockControl control = ...       Foo foo = (Foo)control.getMock();       ...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called just once.       setReturnValue("ok"， 1);       ... 上面的代码段定义了bar(10)方法只能被调用一次。如果提供一个范围又会怎么样呢？
　　...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called at least once and at most 3       //times.       setReturnValue("ok"， 1， 3);       ...现在bar(10)被限制至少被调用一次多3次。更方便的是Range已经预定义了一些限制范围。
　　...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called at least once.       setReturnValue("ok"， Range.ONE_OR_MORE);       ...Range.ONE_OR_MORE是一个预定义的Range实例，这意味着方法应该被调用至少一次。如果setReturnValue()中没有定义调用次数限制，如setReturnValue("Hello")，Range.ONE_OR_MORE被认为是缺省值。还有两个预定义的Range实例，Range.ONE（一次）和Range.ZERO_OR_MORE（对调用次数没有限制）。
　　这儿还有一个特定的设置返回值的方法：setDefaultReturnValue()。他将代替方法的参数值作为返回值，缺省的调用次数限制为Range.ONE_OR_MORE。这被称为方法参数值敏感性。
　　...       foo.bar(10);       //define the behavior -- return "ok" when calling       //bar(int) despite the argument value.       setDefaultReturnValue("ok");       ...o        setThrowable
　　setThrowable(Throwable throwable)被用来定义方法调用异常抛出的行为。如果给定的throwable不匹配方法的异常定义，则AssertionFailedError会被抛出。调用次数的限制与方法参数值敏感性是一致的。
　　...       try {         foo.dummy();       } catch (Exception e) {         //skip       }       //define the behavior -- throw ParseException       //when call dummy(). And this method is expected       //to be called exactly once.       control.setThrowable(new ParseException(""， 0)， 1);       ...o        setVoidCallable()
　　setVoidCallable()被用于没有返回值的方法。调用次数的限制与方法参数值敏感性是一致的。
　　...       try {         foo.dummy();       } catch (Exception e) {         //skip       }       //define the behavior -- no return value       //when calling dummy(). And this method is expected       //to be called at least once.       control.setVoidCallable();       ...o        Set ArgumentsMatcher
　　在工作态时，MockControl会在伪对象的方法被调用时搜索预定义的行为。有三个因素会影响搜索的标准：方法标识，参数值和调用次数限制。第一和第三个因素是固定的。第二个因素可以通过参数值敏感性来忽略。更灵活的是，还可以自定义参数值匹配规则。setMatcher()可以通过ArgumentsMatcher在准备态时使用。
　　public interface ArgumentsMatcher {         public boolean matches(Object[] expected，                                Object[] actual);       }ArgumentsMatcher的方法matches()包含两个参数。一个是期望的参数值数组（如果参数值敏感特性应用时为NULL）。另一个是实际参数值数组。如果参数值匹配返回真。
　　...       foo.isSame(null);       //set the argument match rule -- always match       //no matter what parameter is given       control.setMatcher(MockControl.ALWAYS_MATCHER);       //define the behavior -- return true when call       //isSame(). And this method is expected       //to be called at least once.       control.setReturnValue(true， 1);       ...MockControl中有三个预定义的ArgumentsMatcher实例。MockControl.ALWAYS_MATCHER在匹配时始终返回真而不管给什么参数值。MockControl.EQUALS_MATCHER会为参数值数组的每一个元素调用equals()方法。MockControl.ARRAY_MATCHER与MockControl.EQUALS_MATCHER基本一致，除了他调用的是Arrays.equals()。当然，开发人员可以实现自己的ArgumentsMatcher。
　　然而自定义的ArgumentsMatcher有一个副作用是需要定义方法调用的输出参数值。
　　...       //just to demonstrate the function       //of out parameter value definition       foo.add(new String[]{null， null});       //set the argument match rule -- always       //match no matter what parameter given.       //Also defined the value of out param.       control.setMatcher(new ArgumentsMatcher() {         public boolean matches(Object[] expected，                                Object[] actual) {            ((StringBuffer)actual[0])                               .append(actual[1]);            return true;         }       });       //define the behavior of add().       //This method is expected to be called at       //least once.       control.setVoidCallable(true， 1);       ...setDefaultMatcher()设置MockControl的缺省ArgumentsMatcher实例。如果没有特定的ArgumentsMatcher，缺省的ArgumentsMatcher会被使用。这个方法应该在任何方法调用行为定义前被调用。否则，会抛出AssertionFailedError异常。
　　//get mock control       MockControl control = ...;       //get mock object       Foo foo = (Foo)control.getMock();       //set default ArgumentsMatcher       control.setDefaultMatcher(                      MockControl.ALWAYS_MATCHER);       //begin behavior definition       foo.bar(10);       control.setReturnValue("ok");       ...如果没有使用setDefaultMatcher()，MockControl.ARRAY_MATCHER是缺省的ArgumentsMatcher。
　　一个例子
　　下面是一个在单元测试中演示Mocquer用法的例子，假设存在一个类FTPConnector。
　　package org.jingle.mocquer.sample; import java.io.IOException; import java.net.SocketException; import org.apache.commons.net.ftp.FTPClient; public class FTPConnector {     //ftp server host name     String hostName;     //ftp server port number     int port;     //user name     String user;     //password     String pass;     public FTPConnector(String hostName，                         int port，                         String user，                         String pass) {         this.hostName = hostName;         this.port = port;         this.user = user;         this.pass = pass;     }     /**      * Connect to the ftp server.      * The max retry times is 3.      * @return true if suclearcase/" target="_blank" >cceed      */     public boolean connect() {         boolean ret = false;         FTPClient ftp = getFTPClient();         int times = 1;         while ((times <= 3) && !ret) {             try {                 ftp.connect(hostName， port);                 ret = ftp.login(user， pass);             } catch (SocketException e) {             } catch (IOException e) {             } finally {                 times++;             }         }         return ret;     }     /**      * get the FTPClient instance      * It seems that this method is a nonsense      * at first glance. Actually， this method      * is very important for unit test using      * mock technology.      * @return FTPClient instance      */     protected FTPClient getFTPClient() {         return new FTPClient();     } }connect()方法尝试连接FTP服务器并且登录。如果失败了，他可以尝试三次。如果操作成功返回真。否则返回假。这个类使用org.apache.commons.net.FTPClient来生成一个实际的连接。他有一个初看起来毫无用处的保护方法getFTPClient()。实际上这个方法对使用伪技术的单元测试是非常重要的。我会在稍后解释。
　　一个JUnit测试实例FTPConnectorTest被用来测试connect()方法的逻辑。因为我们想要将单元测试环境从其他因素中（如外部FTP服务器）分离出来，因此我们使用Mocquer来模拟FTPClient。
　　package org.jingle.mocquer.sample; import java.io.IOException; import org.apache.commons.net.ftp.FTPClient; import org.jingle.mocquer.MockControl; import junit.framework.TestCase; public class FTPConnectorTest extends TestCase {     /*      * @see TestCase#setUp()      */     protected void setUp() throws Exception {         super.setUp();     }     /*      * @see TestCase#tearDown()      */     protected void tearDown() throws Exception {         super.tearDown();     }     /**      * test FTPConnector.connect()      */     public final void testConnect() {         //get strict mock control         MockControl control =              MockControl.createStrictControl(                                 FTPClient.class);         //get mock object         //why final? try to remove it         final FTPClient ftp =                     (FTPClient)control.getMock();         //Test point 1         //begin behavior definition         try {             //specify the method invocation             ftp.connect("202.96.69.8"， 7010);             //specify the behavior             //throw IOException when call             //connect() with parameters             //"202.96.69.8" and 7010. This method             //should be called exactly three times             control.setThrowable(                             new IOException()， 3);             //change to working state             control.replay();         } catch (Exception e) {             fail("Unexpected exception: " + e);         }         //prepare the instance         //the overridden method is the bridge to         //introduce the mock object.         FTPConnector inst = new FTPConnector(                                   "202.96.69.8"，                                   7010，                                   "user"，                                   "pass") {             protected FTPClient getFTPClient() {                 //do you understand why declare                 //the ftp variable as final now?                 return ftp;             }         };         //in this case， the connect() should         //return false         assertFalse(inst.connect());         //change to checking state         control.verify();         //Test point 2         try {             //return to preparing state first             control.reset();             //behavior definition             ftp.connect("202.96.69.8"， 7010);             control.setThrowable(                            new IOException()， 2);             ftp.connect("202.96.69.8"， 7010);             control.setVoidCallable(1);             ftp.login("user"， "pass");             control.setReturnValue(true， 1);             control.replay();         } catch (Exception e) {             fail("Unexpected exception: " + e);         }         //in this case， the connect() should         //return true         assertTrue(inst.connect());         //verify again         control.verify();     } }这里创建了一个严格的MockObject。伪对象变量有一个final修饰符因为变量会在匿名内部类中使用，否则有产生编译错误。
　　在这个测试方法中包含两个测试点。第一个是什么时候FTPClient.connect()始终抛出异常，也是说FTPClient.connect()返回假。
　　try {     ftp.connect("202.96.69.8"， 7010);     control.setThrowable(new IOException()， 3);     control.replay(); } catch (Exception e) {     fail("Unexpected exception: " + e); }MockControl在调用伪对象connect()方法传入参数202.96.96.8作为主机地址及7010作为端口号时会抛出IOException异常。这个方法调用预期执行三次。在行为定义后，replay()改变伪对象状态为工作态。这里的try/catch块包裹着FTPClient.connect()的定义，因为他定义了抛出IOException异常。
　　FTPConnector inst = new FTPConnector("202.96.69.8"，                                      7010，                                      "user"，                                      "pass") {     protected FTPClient getFTPClient() {         return ftp;     } };上面的代码创建一个重写了getFTPClient()方法的FTPConnector实例。这样桥接了创建的伪对象给用来测试的目标。
　　assertFalse(inst.connect());
　　在这里预期connect()应该返回假。
　　control.verify();
　　后，改变伪对象到验证态。
　　第二个测试点是什么时候FTPClient.connect()前两次抛出异常而第三次会成功，这时FTPClient.login()当然也是成功的，这意味着FTPConnector.connect()会返回真。
　　这个测试点是在前一个测试点之后运行，因此需要将MockObject的状态通过reset()重新置为准备态。
　　总结
　　模拟技术将测试的对象从其他外部因素中分离出来。在JUnit框架中集成模拟技术使得单元测试更加简单和优雅。EasyMock是一个好的伪装工具，可以为特定接口创建伪对象。在Dunamis协助下，Mocquer扩展了EasyMock的功能，他可以为类创建伪对象。这篇文章简单介绍了Mocquer在单元测试中的使用。