TestNG: Comment puis-je exécuter le même cas de test plusieurs fois?

Vous ne pouvez pas le faire à partir du xml, mais dans l'annotation @Test - vous pouvez ajouter un attribut invocationCount avec le nombre de fois où vous voulez l'exécuter. Il en ressortirait que ces nombreux tests fonctionnent dans le rapport.

par exemple.

@Test(invocationCount = 10)
public void testCount() {..}

Vous avez manqué accolade fermante à la fin, donc une petite correction.

TestNg a une méthode. Vous pouvez utiliser cette méthode et exécuter votre cas de test plusieurs fois:

@Test(invocationCount = 100)

public void testCount() {

}

Aucune réponse jusqu'à présent vraiment donner à l'utilisateur la capacité de l'invocation compter de la testng fichier, qui est ce qui a été demandé. Cette solution s'emboîte dans la solution DataProvider de gaurav25.

class TestClass() {
    int invocationCount;

    @Parameters({ "invocationCount" })
    @BeginClass
    void BeginClass( @Optional("1") String invocationCount) {
        this.invocationCount = Ingeter.parse(invocationCount)
    }

    // It will return a 2D array of size 3x1
    @DataProvider(name="URLprovider")
    private Object[][] getURLs() {
        ArrayList<Object []> obj = new ArrayList<>(3 * this.invocationCount);

        for(int iCount = 0; iCount < this.invocationCount; ++iCount) {
            list.add( new Object[] {"https://www.google.co.in/"} );
            list.add( new Object[] {"http://www.gmail.com/"} );
            list.add( new Object[] {"http://stackoverflow.com/"} );
        }

        return list.toArray();
    }

    /* Since Data provider for this test method returns 2D array of size
     (3*invocationCount)x1, this test method will run 3*invocationCount 
     times **automatically** with 1 parameter every time. */
    @Test(dataProvider="URLprovider")
    private void notePrice(String url) {
        driver.get(url);
        System.out.println(driver.getTitle());  
    }
}

Maintenant, vous pouvez modifier le nombre de jeux de test qui sont exécutés à travers la fonction test avec ce testng.fichier xml:

<suite name="ESFService" verbose="1" parallel="methods" thread-count="1" data-provider-thread-count="10" >
    <test name="Basic">
        <classes>
            <class name="TestClass">
                <parameter name="invocationCount" value="5"/>
            </class>
        </classes>
    </test>
</suite>

Vous ne pouvez pas le faire à partir du xml, mais il peut être réalisé en utilisant l'annotation @DataProvider dans TestNG.

Voici un exemple de code:

/* Since Data provider for this test method returns 2D array of size 3x1, 
this test method will run 3 times **automatically** with 1 parameter every time. */
@Test(dataProvider="URLprovider")
private void notePrice(String url) {
    driver.get(url);
    System.out.println(driver.getTitle());  
}

// It will return a 2D array of size 3x1
@DataProvider(name="URLprovider")
private Object[][] getURLs() {
  return new Object[][] {
    {"https://www.google.co.in/"},
    {"http://www.gmail.com/"},
    {"http://stackoverflow.com/"}
  };
}

je sais assez tard à la partie, mais si votre but est d'atteindre le rapport pour chaque course, alors vous pouvez essayer TestNG Listener IAnnotationTransformer

Extrait de code

public class Count implements IAnnotationTransformer {

    @Override
    public void transform(ITestAnnotation annotation, Class testClass, Constructor testConstructor, Method testMethod) {
        // TODO Auto-generated method stub
        annotation.setInvocationCount(numberOfTimesTOExecute);
    }

fragment de code xml

<listeners>
<listener class-name="multiple.Count"></listener>

vous pouvez ajouter plusieurs tests dans testngSuite et exécuter. Dans tous les tests, les noms de classes doivent être les mêmes afin d'exécuter le même script plusieurs fois.

si cela ne vous dérange pas D'utiliser Sprint, vous pouvez créer cette classe:

package somePackage;

import org.junit.Ignore;
import org.junit.runner.Description;
import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;
import org.springframework.test.annotation.Repeat;

public class ExtendedRunner extends BlockJUnit4ClassRunner {

    public ExtendedRunner(Class<?> klass) throws InitializationError {
        super(klass);
    }

    @Override
    protected Description describeChild(FrameworkMethod method) {
        if (method.getAnnotation(Repeat.class) != null
                && method.getAnnotation(Ignore.class) == null) {
            return describeRepeatTest(method);
        }
        return super.describeChild(method);
    }

    private Description describeRepeatTest(FrameworkMethod method) {
        int times = method.getAnnotation(Repeat.class).value();

        Description description = Description.createSuiteDescription(
            testName(method) + " [" + times + " times]",
            method.getAnnotations());

        for (int i = 1; i <= times; i++) {
            description.addChild(Description.createTestDescription(
                getTestClass().getJavaClass(), "[" + i + "] "
                        + testName(method)));
        }
        return description;
    }

    @Override
    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
        Description description = describeChild(method);

        if (method.getAnnotation(Repeat.class) != null
                && method.getAnnotation(Ignore.class) == null) {
            runRepeatedly(methodBlock(method), description, notifier);
        }
        super.runChild(method, notifier);
    }

    private void runRepeatedly(Statement statement, Description description,
            RunNotifier notifier) {
        for (Description desc : description.getChildren()) {
            runLeaf(statement, desc, notifier);
        }
    }

}

Puis dans le test réel:

package somePackage;

import *.ExtendedRunner;

import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.springframework.test.annotation.Repeat;

@Ignore
@RunWith(ExtendedRunner.class)
public class RepeatedTest{
    @Repeat(value N)
    public void testToBeRepeated() {

    }
}

où N est le nombre de fois que vous voulez que le test se répète.

public class ProcessTest implements ITest {

protected ProcessData processData;

@Test
public void executeServiceTest() {
    System.out.println(this.processData.toString());
}

@Factory(dataProvider = "processDataList")
public RiskServiceTest(ProcessData processData) {
    this.processData = processData;
}

@DataProvider(name = "processDataList", parallel=true)
public static Object[] getProcessDataList() {

    Object[] serviceProcessDataList = new Object[10];

for(int i=0; i<=serviceProcessDataList.length; i++){
    ProcessData processData = new ProcessData();
    serviceProcessDataList[i] = processData
}


    return serviceProcessDataList;
}

@Override
public String getTestName() {

    return this.processData.getName();
}

}

en utilisant @Factory et @DataProvider annotation de TestNG vous pouvez exécuter le même test-case plusieurs fois avec des données différentes.