selenium之如何监听断言

一.概述

     测试用的执行通过与否，需要对比期望结果和实际结果的值，因此在自动化测试中我们需要进行断言来获得执行的结果，

那么如果在执行的过程中有异常，该怎么办呢，我们是否要查看异常信息呢，于是乎如何得到我们所需要的异常信息成为

我们需要思考的问题，该怎么解决呢，其实so eazy!tesgNG的测试用例监听器可以帮助我们解决这个问题。

二.监听断言类AssertionListener

public class AsserttionListener extends TestListenerAdapter{
    
    private Log log=new Log(this.getClass());

    @Override
    public void onTestStart(ITestResult result) {
        // TODO Auto-generated method stub
        Assertion.begin();
    }

    @Override
    public void onTestFailure(ITestResult tr) {
        // TODO Auto-generated method stub
        this.handleAssertion(tr);
    }

    @Override
    public void onTestSkipped(ITestResult tr) {
        // TODO Auto-generated method stub
        this.handleAssertion(tr);
    }

    @Override
    public void onTestSuccess(ITestResult tr) {
        // TODO Auto-generated method stub
        this.handleAssertion(tr);
    }
    
    private int index;
    
    private boolean isNew=false;
    
    /**
     * 得到测试类所需的测试异常信息
     * @param tr
     */
    private void handleAssertion(ITestResult tr){
        Throwable throwable=tr.getThrowable();
        if(!Assertion.flag||throwable!=null){
            if(throwable==null){
                throwable=new Throwable();
                isNew=true;
            }
            StackTraceElement[] alltrace=new StackTraceElement[0];
            for (Error e : Assertion.errors) {
                alltrace=this.getAllStackTraceElement(tr, e, null, alltrace);
            }
            if(!isNew){
                alltrace=this.getAllStackTraceElement(tr, null, throwable, alltrace);
            }else{
                isNew=false;
            }
            throwable.setStackTrace(alltrace);
            tr.setThrowable(throwable);
            Assertion.flag=true;
            Assertion.errors.clear();
            tr.setStatus(ITestResult.FAILURE);
        }
    }

    /**
     * 得到测试类需要的StackTraceElement数组
     * @param tr
     * @param e
     * @param throwable
     * @param alltrace
     * @return
     */
    private StackTraceElement[] getAllStackTraceElement(ITestResult tr,Error e,Throwable throwable,StackTraceElement[] alltrace){
        StackTraceElement[] traces=(e==null?throwable.getStackTrace():e.getStackTrace());
        StackTraceElement[] et=this.getKeyStackTrace(tr, traces);
        String msg=(e==null?throwable.getMessage():e.getMessage());
        StackTraceElement[] message=new StackTraceElement[]{new StackTraceElement("message : "+msg+" in method : ",tr.getMethod().getMethodName(),tr.getTestClass().getRealClass().getSimpleName(),index)};
        index=0;
        alltrace=this.merge(alltrace, et);
        alltrace=this.merge(alltrace, message);
        return alltrace;
    }
    
    /**
     * 根据测试类名获得该测试类的StackTraceElement数组
     * @param tr
     * @param stackTraceElements
     * @return
     */
    private StackTraceElement[] getKeyStackTrace(ITestResult tr,StackTraceElement[] stackTraceElements){
        List<StackTraceElement> ets=new ArrayList<StackTraceElement>();
        for (StackTraceElement stackTraceElement : ets) {
            if(stackTraceElement.getClassName().equals(tr.getTestClass().getName())){
                ets.add(stackTraceElement);
                index=stackTraceElement.getLineNumber();
            }
        }
        StackTraceElement[] et=new StackTraceElement[ets.size()];
        for (int i = 0; i < et.length; i++) {
            et[i]=ets.get(i);
        }
        return et;
    }
    
    /**
     * 合并两个StackTraceElement数组
     * @param trace1
     * @param trace2
     * @return
     */
    private StackTraceElement[] merge(StackTraceElement[] trace1,StackTraceElement[] trace2){
        StackTraceElement[] ste=new StackTraceElement[trace1.length+trace2.length];
        for (int i = 0; i < trace1.length; i++) {
            ste[i]=trace1[i];
        }
        for (int i = 0; i < trace2.length; i++) {
            ste[trace1.length+i]=trace2[i];
        }
        return ste;
    }

public class Assertion {
    
    public static Log log=new Log(Assertion.class);
    
    public static boolean flag=true;
    
    public static List<Error> errors=new ArrayList<Error>();
    
    public static void begin(){
        flag=true;
    }
    
    public static void end(){
        Assert.assertTrue(flag);
    }
    
    public static void verifyEquals(Object actual, Object expected){
        try{
            Assert.assertEquals(actual, expected);
        }catch(Error e){
            errors.add(e);
            flag = false;
        }
    }
    
    public static void verifyEquals(Object actual, Object expected, String message){
        try{
            Assert.assertEquals(actual, expected, message);
            log.info("方法验证成功!");
        }catch(Error e){
            errors.add(e);
            flag = false;
            log.info("方法验证失败!");
        }
    }

}