Comment limiter les méthodes @test en classe TestNG sans changer dans le fichier testng.xml

Question

Je veux exécuter une seule méthode @test d'une classe qui a plusieurs méthodes de @test

est Ci-dessous l'exemple de code ce que j'ai écrit , mais son fonctionnement toutes les méthodes dans la classe ADC TestNG testng = new TestNG(); Classe [] classes = new Classe [] {ABC.class};

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

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

Quelqu'un peut-il me dire si ce code pose problème?

Answer 1

Voici un exemple complet qui vous permettra de choisir des méthodes à la main à partir d'une classe spécifique (ou) à partir d'une ou plusieurs classes qui résident dans un paquet donné.

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")); 
     } 
    } 
}