TestNG断言失败后，程序可继续执行

testng在程序执行的时候，如果断言失败，程序也会停止。
下面通过重写相关方法，让断言失败程序也可以继续执行。

1、重写断言方法

package configSelenium.Assert;

import org.testng.Assert;
import java.util.ArrayList;
import java.util.List;

/**
 * @author wangyan
 * @date 2019-02-23  下午 12:27
 *
 */
public class Assertion  {
    public static boolean flag=true;
    public static List<Error> errors=new ArrayList<>();

    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);
        }catch(Error e){
          errors.add(e);
          flag=false;
        }

    }
    public static void verifyNulls(Object actual,String message){
        try{
            Assert.assertNull(actual,message);
        }catch(Error e){
          errors.add(e);
          flag=false;
        }
    }

}

很多断言的方法，按照上面的方法重写即可。

2、创建监听的类

package configSelenium.Assert;

import org.testng.ITestResult;
import org.testng.TestListenerAdapter;

import java.util.ArrayList;
import java.util.List;

/**
 * @author wangyan
 * @date 2019-02-23  下午 12:49
 */
public class AssertListener extends TestListenerAdapter {

    @Override
    public void onTestStart(ITestResult result){
        Assertion.flag=true;
        Assertion.errors.clear();

    }

    @Override
    public void onTestFailure(ITestResult tr){
        this.handleAssertion(tr);
    }



    @Override
    public void onTestSkipped(ITestResult tr){
        this.handleAssertion(tr);
    }

    @Override
    public void onTestSuccess(ITestResult tr){
        this.handleAssertion(tr);
    }


    private  int index=0;

    private void handleAssertion(ITestResult tr){
        if(!Assertion.flag){
            Throwable throwable = tr.getThrowable();
            if(throwable==null){
                throwable = new Throwable();
            }
            StackTraceElement[] traces = throwable.getStackTrace();
            StackTraceElement[] alltrace = new StackTraceElement[0];
            for (Error e : Assertion.errors) {
                StackTraceElement[] errorTraces = e.getStackTrace();
                StackTraceElement[] et = this.getKeyStackTrace(tr, errorTraces);
                StackTraceElement[] message = new StackTraceElement[]{new StackTraceElement("message : "+e.getMessage()+" in method : ", tr.getMethod().getMethodName(), tr.getTestClass().getRealClass().getSimpleName(), index)};
                index = 0;
                alltrace = this.merge(alltrace, message);
                alltrace = this.merge(alltrace, et);
            }
            if(traces!=null){
                traces = this.getKeyStackTrace(tr, traces);
                alltrace = this.merge(alltrace, traces);
            }


            throwable.setStackTrace(alltrace);
            tr.setThrowable(throwable);
            Assertion.flag = true;
            Assertion.errors.clear();
            tr.setStatus(ITestResult.FAILURE);
        }

    }
    private StackTraceElement[] getKeyStackTrace(ITestResult tr, StackTraceElement[] stackTraceElements){
        List<StackTraceElement> ets = new ArrayList<StackTraceElement>();
        for (StackTraceElement stackTraceElement : stackTraceElements) {
            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;
    }


    private StackTraceElement[] merge(StackTraceElement[] traces1, StackTraceElement[] traces2){
        StackTraceElement[] ste = new StackTraceElement[traces1.length+traces2.length];
        for (int i = 0; i < traces1.length; i++) {
            ste[i] = traces1[i];
        }
        for (int i = 0; i < traces2.length; i++) {
            ste[traces1.length+i] = traces2[i];
        }
        return ste;
    }


}

3、写一个测试类，验证一下

package configSelenium.Assert;

import org.testng.Assert;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

/**
 * @author wangyan
 * @date 2019-02-23  下午 01:47
 */
@Listeners(configSelenium.Assert.AssertListener.class)
public class TestCase {

    @Test
    public void Case1(){

        System.out.println("=========Case1=======");
        Assert.assertEquals(1, 1," is not equal");
    }

    @Test
    public void Case2(){
        System.out.println("=========Case2=======");
        Assertion.verifyEquals(1, 2,"is not equal ");



    }

    @Test
    public void Case3(){
        System.out.println("=========Case3=======");
        Assertion.verifyEquals(1, 3);

    }

}

测试结果如图：

当然也可以采用在testng.xml文件中配置监听

<listeners>
		<listener class-name="configSelenium.Assert.AssertListener"></listener>
</listeners>