Java(40).JAVA结合testng断言verify(断言失败不中断继续执行)

已知前提

1、Java语言编写的接口自动化框架

2、新增角色接口有5个用例，一个方法传参数5个，需要执行5次操作

3、使用的是testng的断言

import org.testng.Assert;

Assert.assertEquals(code, expectData,"角色添加接口");

问题描述：

TestNg，调试新增接口，执行到第3个用例时遇到Assert断言失败，剩下的2个用例不再执行

错误如下：

java.lang.AssertionError: 角色添加接口 expected [0] but found [600110]

Expected :0

Actual   :600110

解决方法：

原理：

1.自已构造一个断言类，把Assert.assertEquals给try catch住。

2.利用testng的监听类在测试方法运行结束后进行分析。

断言类：

package com.ciphergateway.asserts;


import java.util.ArrayList;
import java.util.List;
import org.testng.Assert;
/**
 * Description: Assertion工具类
 *
 * @author HMF
 * @date Created on 2021/09/18
 */
public class Assertion {

    public static boolean flag = true;

    public static List<Error> errors = new ArrayList<Error>();
    /**
     　　* String对比
     　　* @param actual
     　　* @param expected
     　　*/
    public static void verifyEquals(Object actual, Object expected){
        try{
            Assert.assertEquals(actual, expected);
        }catch(Error e){
            errors.add(e);
            flag = false;
        }
    }
    /**
     * String对比+msg
     　　* @param actual
     　　* @param expected
     　　* @param message
     　　*/
    public static void verifyEquals(Object actual, Object expected, String message){
        try{
            Assert.assertEquals(actual, expected, message);
        }catch(Error e){
            errors.add(e);
            flag = false;
        }
    }

    /**
     　　* 判断是否为空
     　　* @param actual
     　　* @param message
     　　*/
    public static void assertNull(Object actual, String message){
        try{
            Assert.assertNull(actual,message);
        }catch(Error e){
            errors.add(e);
            flag=false;
        }
    }
}

监听类：

package com.ciphergateway.asserts;

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

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

public class AssertionListener 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;
    }
}

测试类：

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

@Listeners({com.ciphergateway.asserts.AssertionListener.class})
public class roleTest {
    @Test(description = "testAssert0")
    public void testAssert0(){
        Assertion.verifyEquals(2, 3, "比较两个数是否相等：");
        Assertion.verifyEquals(1, 2, "比较两个数是否相等：");
    }
    @Test(description = "add_role")
    @Step("addRole")
    public void a1_addRole() throws Exception {
        //code,expectData为参数
        Assertion.verifyEquals(code, expectData,"新增角色接口");
    }
}

测试结果：

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

 

 但我这遇到问题，该监听器如果配置到testng.xml有时监听不到，需要直接配置到类里。(因testng.xml配此监听器有时能够监听到报出异常，有时直接过，变成PASS，容易误导)