如何在不更改TestNG.xml文件的情况下限制TestNG类中的@Test方法

我只想从具有多个@test方法的类中执行一个@test方法

下面是我编写的示例代码，但它运行ADC类中的所有方法 TestNG TestNG=新的TestNG（）； 类[]类=新类[]{ABC.Class}

    List<String> myList = new ArrayList<String>();
    myList.add("xyz");

    testng.setTestClasses(classes);
    testng.setTestNames(myList);
    testng.run();

List myList=new ArrayList（）；
myList.add（“xyz”）；
testng.setTestClasses（类）；
testng.setTestNames（myList）；
testng.run（）；

---

有人能告诉我这段代码有什么问题吗？

这里有一个完整的示例，它可以让您从特定类（或）从驻留在给定包中的一个或多个类中手动选择方法

import org.testng.TestNG;
import org.testng.internal.ClassHelper;
import org.testng.internal.PackageUtils;
import org.testng.xml.XmlClass;
import org.testng.xml.XmlInclude;
import org.testng.xml.XmlSuite;
import org.testng.xml.XmlTest;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class TestRunner {


    /**
     * This method accepts two parameters both via JVM arguments.
     * <ul>
     * <li>type - Specified as -Dtype. It can either begin with "package:" (or) it can begin with "class:"</li>.
     * <li>methodname - Specified as -Dmethodname. Represents the method name which is to be filtered.</li>
     * </ul>
     */
    public static void main(String[] args) throws IOException {
        List<String> empty = Collections.emptyList();
        String filter = System.getProperty("type", "package:com.rationaleemotions.stackoverflow.qn45436872");
        String name = System.getProperty("methodname", "SomeTest");
        FilterType type = FilterType.parse(filter);
        String filterValue = filter.split(":")[1];
        final Set<Method> methods = new HashSet<>();
        Predicate<String> notObjectClass = (String className) -> !className.equals(Object.class.getName());
        switch (type) {
            case PACKAGE:
                String[] classes = PackageUtils.findClassesInPackage(filterValue, empty, empty);
                if (name.equals("*")) {
                    //The value "*" indicates that all methods are to be included.
                    Arrays.stream(classes).filter(notObjectClass).forEach(clazz -> {
                        Class<?> clz = ClassHelper.forName(clazz);
                        methods.addAll(ClassHelper.getAvailableMethods(clz));
                    });
                } else {
                    Arrays.stream(classes).filter(notObjectClass).forEach(clazz -> {
                        Class<?> clz = ClassHelper.forName(clazz);
                        Set<Method> filteredMethods = methodsMatchingName(clz, name);
                        methods.addAll(filteredMethods);
                    });
                }
                break;
            case CLASS:
            default:
                Class<?> clazz = ClassHelper.forName(filterValue);
                if (name.equals("*")) {
                    //The value "*" indicates that all methods are to be included.
                    methods.addAll(ClassHelper.getAvailableMethods(clazz));
                } else {
                    Set<Method> filteredMethods = methodsMatchingName(clazz, name);
                    methods.addAll(filteredMethods);
                }

        }

        Map<Class<?>, List<Method>> map = methods.stream().collect(Collectors.groupingBy(Method::getDeclaringClass));
        TestNG testNG = new TestNG();
        XmlSuite xmlSuite = new XmlSuite();
        xmlSuite.setName("sample_suite");
        XmlTest xmlTest = new XmlTest(xmlSuite);
        xmlTest.setName("sample_test");


        List<XmlClass> xmlClasses = new ArrayList<>();

        map.entrySet().stream()
                .filter(classListEntry -> !classListEntry.getKey().equals(Object.class))
                .forEach(entry -> {
                    XmlClass xmlClass = new XmlClass(entry.getKey());
                    entry.getValue().forEach(m -> xmlClass.getIncludedMethods().add(new XmlInclude(m.getName())));
                    xmlClasses.add(xmlClass);
                });
        xmlTest.setClasses(xmlClasses);
        testNG.setXmlSuites(Collections.singletonList(xmlSuite));
        System.err.println("The suite file that will be used");
        System.err.println(xmlSuite.toXml());
        testNG.run();
    }

    private static Set<Method> methodsMatchingName(Class<?> clazz, String name) {
        return ClassHelper.getAvailableMethods(clazz)
                .stream()
                .filter(m -> m.getName().equals(name))
                .collect(Collectors.toSet());
    }

    private enum FilterType {
        CLASS("class:"),
        PACKAGE("package:");

        FilterType(String type) {
            this.type = type;
        }

        private String type;

        public static FilterType parse(String type) {
            if (type == null || type.trim().isEmpty()) {
                throw new IllegalArgumentException("Type cannot be null (or) empty.");
            }
            return Arrays.stream(values())
                    .filter(each -> type.startsWith(each.type))
                    .findFirst().orElseThrow(() ->
                            new IllegalArgumentException("Unknown type specified"));
        }
    }
}

import org.testng.testng；
导入org.testng.internal.ClassHelper；
导入org.testng.internal.PackageUtils；
导入org.testng.xml.XmlClass；
导入org.testng.xml.xmlclude；
导入org.testng.xml.XmlSuite；
导入org.testng.xml.XmlTest；
导入java.io.IOException；
导入java.lang.reflect.Method；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
导入java.util.function.Predicate；
导入java.util.stream.collector；
公共类测试运行程序{
/**
*此方法通过JVM参数接受两个参数。
*

*
类型-指定为-Dtype。它可以以“package:”（或者）以“class:”
开头。
*
methodname-指定为-Dmethodname。表示要筛选的方法名称
*
*/
公共静态void main（字符串[]args）引发IOException{
List empty=Collections.emptyList（）；
字符串过滤器=System.getProperty（“类型”，“包：com.rationalemotions.stackoverflow.qn45436872”）；
字符串名称=System.getProperty（“methodname”、“SomeTest”）；
FilterType类型=FilterType.parse（过滤器）；
字符串filterValue=filter.split（“：”[1]；
final Set methods=new HashSet（）；
谓词NOTbjectClass=（字符串className）->！className.equals（Object.class.getName（））；
开关（类型）{
包装箱：
String[]classes=PackageUtils.findclassensinpackage（filterValue，empty，empty）；
if（名称等于（“*”）{
//值“*”表示要包括所有方法。
Arrays.stream（classes）.filter（notObjectClass）.forEach（clazz->{
Class clz=ClassHelper.forName（clazz）；
addAll（ClassHelper.getAvailableMethods（clz））；
});
}否则{
Arrays.stream（classes）.filter（notObjectClass）.forEach（clazz->{
Class clz=ClassHelper.forName（clazz）；
设置filteredMethods=methodsMatchingName（clz，名称）；
方法：addAll（filteredMethods）；
});
}
打破
案例类别：
违约：
Class clazz=ClassHelper.forName（filterValue）；
if（名称等于（“*”）{
//值“*”表示要包括所有方法。
addAll（ClassHelper.getAvailableMethods（clazz））；
}否则{
设置filteredMethods=methodsMatchinname（clazz，name）；
方法：addAll（filteredMethods）；
}
}
地图