*/
     public void testConnectionProxyStart() {
         int minConnections = 0;
         int maxConnections = 0;
         assertNotNull(cacheImpl);
         try      {
             minConnections = Integer.parseInt(PropertyManager.getProperty
             ("DefaultConnectionProxy.minConnections"));
             maxConnections = Integer.parseInt(PropertyManager.getProperty
             ("DefaultConnectionProxy.maxConnections"));
         } catch (Exception e) {
             // ignore the exception
         }
         assertEquals(cacheImpl.getMinLimit()， minConnections);
         assertEquals(cacheImpl.getMaxLimit()， maxConnections);
         assertEquals(cacheImpl.getCacheSize()， minConnections);
     }
     /** 对示例一中的对象进行获取数据库连接的测试，看看是否可以获取有效的数据库连接，
并且看看获取连接后，连接池的状态是否按照既定的策略进行变化。由于 assert 方法抛出的是
 error 对象，因此尽可能把 assert 方法放置到方法的后集体进行测试，这样在方法内打开的
资源，才能有效的被正确关闭。
     */
     public void testGetConnection() {
         int cacheSize = cacheImpl.getCacheSize();
         int activeSize = cacheImpl.getActiveSize();
         int cacheSizeAfter = 0;
         int activeSizeAfter = 0;
         con = conProxy.getConnection();
         if (con != null) {
             activeSizeAfter = cacheImpl.getActiveSize();
             cacheSizeAfter = cacheImpl.getCacheSize();
           
             try      {
                 con.close();
             } catch (SQLException e) {
             }
         } else {
             assertNotNull(con);
         }
         /* 如果连接池中的实际使用连接数小于缓存连接数，检查获取的新的数据连接是否
从缓存中获取，反之连接池是否建立新的连接
         */
         if (cacheSize > activeSize)      {
             assertEquals(activeSize + 1， activeSizeAfter);
             assertEquals(cacheSize， cacheSizeAfter);
         } else {
             assertEquals(activeSize + 1， cacheSizeAfter);
         }
     }
     /** 对示例一中的对象进行数据库连接释放的测试，看看连接释放后，连接池的
状态是否按照既定的策略进行变化。由于 assert 方法抛出的是 error 对象，因此尽可
能把 assert 方法放置到方法的后集体进行测试，这样在方法内打开的
资源，才能有效的被正确关闭。
     */
     public void testConnectionClose() {
         int minConnections = cacheImpl.getMinLimit();
         int cacheSize = 0;
         int activeSize = 0;
         int cacheSizeAfter = 0;
         int activeSizeAfter = 0;
         con = conProxy.getConnection();
         if (con != null) {
             cacheSize = cacheImpl.getCacheSize();
             activeSize = cacheImpl.getActiveSize();
             try      {
                 con.close();
             } catch (SQLException e) {
             }
             activeSizeAfter = cacheImpl.getActiveSize();
             cacheSizeAfter = cacheImpl.getCacheSize();
         } else {
             assertNotNull(con);
         }
         assertEquals(activeSize， activeSizeAfter + 1);
         /* 如果连接池中的缓存连接数大于少缓存连接数，检查释放数据连接后是否
缓存连接数比之前减少了一个，反之缓存连接数是否保持为少缓存连接数
         */
         if (cacheSize > minConnections)      {
             assertEquals(cacheSize， cacheSizeAfter + 1);
         } else {
             assertEquals(cacheSize， minConnections);
         }
     }
   
 /** 释放建立测试起始环境时的资源。
     */
 protected void tearDown() {
         cacheImpl = null;
         conProxy.destroy();
     }
     public DefaultConnectionProxyTest(String name) {
         super(name);
     }
 /** 你可以简单的运行这个类从而对类中所包含的测试单元进行测试。
     */
     public static void main(String args[]) {
         junit.textui.TestRunner.run(DefaultConnectionProxyTest.class);
     }
 }

当单元测试完成后，我们可以用 Junit 提供的 TestSuite 对象对测试单元进行组织，你可以决定测试的顺序，然后运行你的测试。

4. 如何维护单元测试

通过上面的描述，我们对如何确定和编写测试有了基本的了解，但是需求总是变化的，因此我们的单元测试也会根据需求的变化不断的演变。如果我们决定修改类的行为规则，可以明确的是，我们当然会对针对这个类的测试单元进行修改，以适应变化。但是如果对这个类仅有调用关系的类的行为定义没有变化则相应的单元测试仍然是可靠和充分的，同时如果包含行为变化的类的对象的状态定义与其没有直接的关系，测试单元仍然起效。这种结果也是封装原则的优势体现。