it-swarm.com.de

Unterschied zwischen BeforeClass und BeforeTest in TestNG

As we know from official TestNG documentation:

@BeforeClass: Die annotierte Methode wird ausgeführt, bevor die erste Testmethode in der aktuellen Klasse aufgerufen wird.

@BeforeTest: Die annotierte Methode wird ausgeführt, bevor eine Testmethode ausgeführt wird, die zu den Klassen im <test>-Tag gehört.

Die beiden oben genannten Testnotationen sehen in der Funktionalität ähnlich aus. Es sollte jedoch ein eindeutiger Unterschied in der Funktion bestehen. Kann jemand das bitte betonen? 

20
Prashanth Sams

SeleniumAbstractTest.class

public abstract class SeleniumAbstractTest {

  @BeforeSuite
  public void beforeSuite() {
    System.out.println("BeforeSuite");
  }

  @BeforeTest
  public void beforeTest() {
    System.out.println("BeforeTest");
  }

  @BeforeClass
  public void beforeClass() {
    System.out.println("BeforeClass");
  }

  @BeforeMethod
  public void beforeMethod() {
    System.out.println("BeforeMethod");
  }

  @AfterMethod
  public void afterMethod() {
    System.out.println("AfterMethod");
  }

  @AfterClass
  public void afterClass() {
    System.out.println("AfterClass");
  }

  @AfterTest
  public void afterTest() {
    System.out.println("AfterTest");
  }

  @AfterSuite
  public void afterSuite() {
    System.out.println("AfterSuite");
  }

}

MyTestClass1.class

public class MyTestClass1 extends SeleniumAbstractTest {

  @Test
  public void myTestMethod1() {
    System.out.println("myTestMethod1");
  }

  @Test
  public void myTestMethod2() {
    System.out.println("myTestMethod2");
  }
}

MyTestClass2.class

public class MyTestClass2 extends SeleniumAbstractTest {

  @Test
  public void myTestMethod3() {
    System.out.println("myTestMethod3");
  }

  @Test
  public void myTestMethod4() {
    System.out.println("myTestMethod4");
  }
}

Wenn Sie die folgende Test Suite haben ...

<suite name="Suite">
  <test name="Test1" >
    <classes>
       <class name="MyTestClass2" />
    </classes>
  </test>

  <test name="Test2">
    <classes>
      <class name="MyTestClass1"/>
      <class name="MyTestClass2"/>
    </classes>
  </test>
</suite>

... dann wird die Ausgabe [für leichtes Lesen eingerückt] sein

BeforeSuite
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
'   BeforeTest
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod1
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod2
'   '   '   AfterMethod
'   '   AfterClass
'   '   BeforeClass
'   '   '   BeforeMethod
'   '   '   '   myTestMethod3
'   '   '   AfterMethod
'   '   '   BeforeMethod
'   '   '   '   myTestMethod4
'   '   '   AfterMethod
'   '   AfterClass
'   AfterTest
AfterSuite

Ich hoffe es hilft :)

81
peetya

@BeforeMethod - wird vor jeder Testmethode ausgeführt, z. Die Methode, die die Annotation @Test verwendet

@BeforeTest - wird nur vor dem in der Datei testng.xml angegebenen Tag ausgeführt.

Kurz gesagt, @BeforeMethod arbeitet mit einem in Java-Klassen definierten Test. Und @BeforeTest mit einem in testng.xml definierten Test, dh XML-Dateien.

6
Dinesh Nikam

Meine Meinungen:

@BeforeClass: Die annotierte Methode wird ausgeführt, bevor die erste Testmethode in der aktuellen Klasse aufgerufen wird

@BeforeTest: Die annotierte Methode wird ausgeführt, bevor eine Testmethode in der aktuellen Suite ausgeführt wird

1
MorganChen

wenn Sie sich von einer anderen Klasse erstrecken, sind dies die Ergebnisse:

parentTest - BeforeTest- parent     
testClass1 - BeforeTest- test1    
parentTest - BeforeClass- parent    
testClass1 - BeforeClass- test1    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod1    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent    
parentTest - BeforeMethod- parent    
testClass1 - BeforeMethod- test1    
testClass1 - myTestMethod2    
testClass1 - AfterMethod- test1    
parentTest - AfterMethod- parent
testClass1 - AfterClass- test1    
parentTest - AfterClass- parent
testClass1 - AfterTest- test1
parentTest – AfterTest- parent
1
David_Garcia

Bevor der Unterschied erklärt wird, werden zunächst einige Testterminologien behandelt

Test suite - Besteht aus einem oder mehreren Test-Tags.

Test tag - Besteht aus einer oder mehreren Testklassen.

Test class - Besteht aus einer oder mehreren Methoden.

zum Beispiel

<suite name="suit1">
  <test name="TestTag1">
    <classes>
      <class name="TestClass1"/>
    </classes>
  </test>
  <test name="TestTag2">
    <classes>
      <class name="TestClass2"/>
      <class name="TestClass3"/>
    </classes>
  </test>
</suite>

@BeforeTest: Es wird nur einmal vor einem Test-Tag aufgerufen, unabhängig davon, wie viele Testklassen sich in diesem Tag befinden oder wie viele Methoden mit @Test Versehen sind. Es wird jeweils nur einmal aufgerufen Test-Tag, im vorherigen XML-Beispiel wird @BeforeTest zweimal aufgerufen, einmal vor TestTag1 und zum zweiten Mal vor TestTag2, damit gemeinsame Objekte zwischen verschiedenen Tests initialisiert werden können Klassen innerhalb eines Test-Tags.

@BeforeClass: Es wird nur einmal vor jeder Testklasse aufgerufen, egal wie viele Methoden mit @Test Kommentiert sind. Innerhalb dieser Testklasse wird sie für jede Testklasse nur einmal aufgerufen, im vorherigen Beispiel XML wird @BeforeClass dreimal aufgerufen, einmal vor TestClass1 dem zweiten Zeit vor TestClass2 und das dritte Mal vor TestClass3, damit gemeinsame Objekte zwischen verschiedenen Testmethoden innerhalb einer Testklasse initialisiert werden können.

@BeforeSuite Wird einmalig für die Farbe suit1 Aufgerufen

die Reihenfolge der Anrufe ist wie folgt

@BeforeSuite
    @BeforeTest
        @BeforeClass
            @BeforeMethod
                @Test

Weitere Informationen zu @BeforeMethod Finden Sie in der Antwort https://stackoverflow.com/a/52331616/19739

0
Melad Basilius