JUnit源码分析(二)——观察者模式


    我们知道JUnit支持不同的使用方式:swt、swing的UI方式,甚至控制台方式,那么对于这些不同的UI我们如何提供统一的接口供它们获取测试过程的信息(比如出现的异常信息,测试成功,测试失败的代码行数等等)?我们试想一下这个场景,当一个error或者exception产生的时候,测试能够马上通知这些UI客户端:发生错误了,发生了什么错误,错误是什么等等。显而易见,这是一个订阅-发布机制应用的场景,应当使用观察者模式。那么什么是观察者模式呢?

观察者模式(Observer)

Observer是对象行为型模式之一

1.意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发现改变时,所有依赖于它的对象都得到通知并被自动更新

2.适用场景:
1)当一个抽象模型有两个方面,其中一个方面依赖于另一个方面,通过观察者模式将这两者封装在不同的独立对象当中,以使它们可以独立的变化和复用
2)当一个对象改变时,需要同时改变其他对象,并且不知道其他对象的具体数目
3)当一个对象需要引用其他对象,但是你又不想让这个对象与其他对象产生紧耦合的时候

3.UML图:
                 
   Subject及其子类维护一个观察者列表,当需要通知所有的Observer对象时调用Nitify方法遍历Observer集合,并调用它们的update方法更新。而具体的观察者实现Observer接口(或者抽象类),提供具体的更新行为。其实看这张图,与Bridge有几分相似,当然两者的意图和适用场景不同。

4.效果:
1)目标和观察者的抽象耦合,目标仅仅与抽象层次的简单接口Observer松耦合,而没有与具体的观察者紧耦合
2)支持广播通信
3)缺点是可能导致意外的更新,因为一个观察者并不知道其他观察者,它的更新行为也许将导致一连串不可预测的更新的行为

5.对于观察者实现需要注意的几个问题:
1)谁来触发更新?最好是由Subject通知观察者更新,而不是客户,因为客户可能忘记调用Notify
2)可以通过显式传参来指定感兴趣的更新
3)在发出通知前,确保Subject对象状态的一致性,也就是Notify操作应该在最后被调用
4)当Subject和Observer的依赖关系比较复杂的时候,可以通过一个更新管理器来管理它们之间的关系,这是与中介者模式的结合应用。


    讨论完观察者模式,那我们来看JUnit是怎么实现这个模式的。在junit.framework包中我们看到了一个Observer接口——TestListener,看看它的代码:
package  junit.framework;

/**
 * A Listener for test progress
 
*/
public   interface  TestListener {
   
/**
     * An error occurred.
     
*/
    
public   void  addError(Test test, Throwable t);
   
/**
     * A failure occurred.
     
*/
     
public   void  addFailure(Test test, Throwable t);  
   
/**
     * A test ended.
     
*/
     
public   void  endTest(Test test); 
   
/**
     * A test started.
     
*/
    
public   void  startTest(Test test);
}

    接口清晰易懂,就是一系列将测试过程的信息传递给观察者的操作。具体的子类将接受这些信息,并按照它们的方式显示给用户。
     比如,我们看看swing的UI中的TestRunner,它将这些信息显示在一个swing写的UI界面上:
     public   void  startTest(Test test) {
        showInfo(
" Running:  " + test);
    }

    public   void  addError(Test test, Throwable t) {
        fNumberOfErrors.setText(Integer.toString(fTestResult.errorCount()));
        appendFailure(
" Error " , test, t);
    }
    
public   void  addFailure(Test test, Throwable t) {
        fNumberOfFailures.setText(Integer.toString(fTestResult.failureCount()));
        appendFailure(
" Failure " , test, t);
    }
    public   void  endTest(Test test) {
        setLabelValue(fNumberOfRuns, fTestResult.runCount());
        fProgressIndicator.step(fTestResult.wasSuccessful());
    }

可以看到,它将错误信息,异常信息保存在List或者Vector集合内,然后显示在界面上:
private   void  showErrorTrace() {
        
int  index =  fFailureList.getSelectedIndex();
        
if  (index  ==   - 1 )
            
return ;
    
        Throwable t
=  (Throwable) fExceptions.elementAt(index);
        
if  (fTraceFrame  ==   null ) {
            fTraceFrame
=   new  TraceFrame();
            fTraceFrame.setLocation(
100 100 );
           }
        fTraceFrame.showTrace(t);
        fTraceFrame.setVisible(
true );
    }
    
private   void  showInfo(String message) {
        fStatusLine.setFont(PLAIN_FONT);
        fStatusLine.setForeground(Color.black);
        fStatusLine.setText(message);
    }
    
private   void  showStatus(String status) {
        fStatusLine.setFont(BOLD_FONT);
        fStatusLine.setForeground(Color.red);
        fStatusLine.setText(status);
    }

而Junit中的目标对象(Subject)就是TestResult对象,它有添加观察者的方法:

/**
     * Registers a TestListener
     
*/
    
public   synchronized   void  addListener(TestListener listener) {
        fListeners.addElement(listener);
    }

而通知观察者又是怎么做的呢?请看这几个方法,都是循环遍历观察者列表,并调用相应的更新方法:

/**
     * Adds an error to the list of errors. The passed in exception caused the
     * error.
     
*/
    
public   synchronized   void  addError(Test test, Throwable t) {
        fErrors.addElement(
new  TestFailure(test, t));
        
for  (Enumeration e  =  fListeners.elements(); e.hasMoreElements();) {
            ((TestListener) e.nextElement()).addError(test, t);
        }
    }

    
/**
     * Adds a failure to the list of failures. The passed in exception caused
     * the failure.
     
*/
    
public   synchronized   void  addFailure(Test test, AssertionFailedError t) {
        fFailures.addElement(
new  TestFailure(test, t));
        
for  (Enumeration e  =  fListeners.elements(); e.hasMoreElements();) {
            ((TestListener) e.nextElement()).addFailure(test, t);
        }
    }

    
/**
     * Registers a TestListener
     
*/
    
public   synchronized   void  addListener(TestListener listener) {
        fListeners.addElement(listener);
    }

    
/**
     * Informs the result that a test was completed.
     
*/
    
public   synchronized   void  endTest(Test test) {
        
for  (Enumeration e  =  fListeners.elements(); e.hasMoreElements();) {
            ((TestListener) e.nextElement()).endTest(test);
        }
    }


使用这个模式后带来的好处:
1)上面提到的Subject与Observer的抽象耦合,使JUnit可以支持不同的使用方式
2)支持了广播通信,目标对象不关心有多少对象对自己注册,它只是通知注册的观察者

最后,我实现了一个简单的ConsoleRunner,在控制台执行JUnit,比如我们写了一个简单测试:
package  junit.samples;

import  junit.framework. * ;

/**
 * Some simple tests.
 * 
 
*/
public   class  SimpleTest  extends  TestCase {
    
protected   int  fValue1;

    
protected   int  fValue2;

    
public  SimpleTest(String name) {
        
super (name);
    }

    
public   void  setUp() {
        fValue1 
=   2 ;
        fValue2 
=   3 ;
    }

    
public   void  testAdd() {
        
double  result  =  fValue1  +  fValue2;
        
assert (result  ==   5 );
    }


    
public   void  testEquals() {
        assertEquals(
12 12 );
        assertEquals(
12L 12L );
        assertEquals(
new  Long( 12 ),  new  Long( 12 ));

        assertEquals(
" Size " 12 12 );
        assertEquals(
" Capacity " 12.0 11.99 0.01 );
    }
}

使用ConsoleRunner调用这个测试,代码很简单,不多做解释了:
package  net.rubyeye.junit.framework;

import  java.lang.reflect.Method;
import  java.util.ArrayList;
import  java.util.List;
import  java.util.Vector;

import  junit.framework.Test;
import  junit.framework.TestListener;
import  junit.framework.TestResult;
import  junit.samples.SimpleTest;
// 实现观察者接口
public   class  ConsoleRunner  implements  TestListener {

    
private  TestResult fTestResult;

    
private  Vector fExceptions;

    
private  Vector fFailedTests;

    
private  List fFailureList;

    
public  ConsoleRunner() {
        fExceptions 
=   new  Vector();
        fFailedTests 
=   new  Vector();
        fFailureList 
=   new  ArrayList();
    }

    
public   void  endTest(Test test) {
        System.out.println(
" 测试结束: " );
        String message 
=  test.toString();
        
if  (fTestResult.wasSuccessful())
            System.out.println(message 
+   "  测试成功! " );
        
else   if  (fTestResult.errorCount()  ==   1 )
            System.out.println(message 
+   "  had an error " );
        
else
            System.out.println(message 
+   "  had a failure " );

        
for  ( int  i  =   0 ; i  <  fFailureList.size(); i ++ ) {
            System.out.println(fFailureList.get(i));
        }
        
for  ( int  i  =   0 ; i  <  fFailedTests.size(); i ++ ) {
            System.out.println(fFailureList.get(i));
        }
        
for  ( int  i  =   0 ; i  <  fExceptions.size(); i ++ ) {
            System.out.println(fFailureList.get(i));
        }

        System.out.println(
" ------------------------ " );
    }

    
public   void  startTest(Test test) {
        System.out.println(
" 开始测试: "   +  test);
    }

    
public   static  TestResult createTestResult() {
        
return   new  TestResult();
    }

    
private  String truncateString(String s,  int  length) {
        
if  (s.length()  >  length)
            s 
=  s.substring( 0 , length)  +   " " ;
        
return  s;
    }

    
public   void  addError(Test test, Throwable t) {
        System.out.println(fTestResult.errorCount());
        appendFailure(
" Error " , test, t);
    }

    
public   void  addFailure(Test test, Throwable t) {
        System.out.println(fTestResult.failureCount());
        appendFailure(
" Failure " , test, t);
    }

    
private   void  appendFailure(String kind, Test test, Throwable t) {
        kind 
+=   " "   +  test;
        String msg 
=  t.getMessage();
        
if  (msg  !=   null ) {
            kind 
+=   " : "   +  truncateString(msg,  100 );
        }
        fFailureList.add(kind);
        fExceptions.addElement(t);
        fFailedTests.addElement(test);
    }

    
public   void  go(String args[]) {
        Method[] methods 
=  SimpleTest. class .getDeclaredMethods();

        
for  ( int  i  =   0 ; i  <  methods.length; i ++ ) {
            
// 取所有以test开头的方法
             if  (methods[i].getName().startsWith( " test " )) {
                Test test 
=   new  SimpleTest(methods[i].getName());
                fTestResult 
=  createTestResult();
                fTestResult.addListener(ConsoleRunner.
this );
                
// 执行测试
                test.run(fTestResult);
            }
        }

    }

    
public   static   void  main(String args[]) {
        
new  ConsoleRunner().go(args);
    }

}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值