Differenza tra BeforeClass e BeforeTest in TestNG

Question

As we know from official TestNG documentation: 

@BeforeClass: Il metodo annotato verrà eseguito prima del primo metodo di test nella classe corrente viene richiamato.

@BeforeTest: Il metodo annotato verrà eseguito prima dell'esecuzione di qualsiasi metodo di prova appartenente alle classi all'interno del tag <test>.

Entrambe le annotazioni di test precedenti hanno funzionalità simili. Tuttavia, ci dovrebbe essere una differenza unica nella funzione. Qualcuno può per favore enfatizzare questo?

Answer 1

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

Se avete il seguente Test Suite ...

<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> 

... allora l'uscita sarà

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 

Speranza che aiuta :)

Answer 2

se si estende da un'altra classe questo sono i risultati:

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 

Answer 3

mie opinioni:

@BeforeClass: il metodo annotato verrà eseguito prima del primo metodo di test nella classe corrente viene richiamato

@BeforeTest: Il metodo annotato verrà eseguito prima di ogni metodo di prova nella suite corrente è gestito

Answer 4

@BeforeMethod - esegue prima di ogni metodo di prova per esempio Il metodo che utilizza l'annotazione @Test

@BeforeTest - viene eseguito solo prima del tag specificato nel file testng.xml.

In breve, @BeforeMethod funziona su test definiti nelle classi Java. E @BeforeTest funziona su test definiti nei file XML i.e testng.xml.