Différence entre BeforeClass et BeforeTest dans TestNG

As we know from official TestNG documentation:

@BeforeClass: La méthode annotée sera exécuté avant le premier test de la méthode dans la classe actuelle est invoquée.

@BeforeTest: La méthode annotée sera exécuté avant toute méthode de test appartenant à des classes à l'intérieur de la <test> balise est exécuté.

Les deux ci-dessus testng annotations look similaire à la fonctionnalité.
Cependant, il devrait y avoir une différence unique dans la fonction.
Quelqu'un peut merci de le souligner?

Une fois par classe vs une fois par cas de test, vous pouvez avoir plusieurs cas de tests dans une classe, je pense?
À la fois les annotations utilisées pour initier avant l'exécution de tous les cas de tests. C'est la similitude. Quelque chose d'unique en dehors de cela?
vous avez 1 Testclass, avec 3 Méthodes:@BeforeClass sera exécutée une fois, @BeforeTest sera exécuté 3 fois. c'est ça la différence. @BeforeClass peut être utilisé pour configurer l'environnement de test, @BeforeTest peut être utilisé pour nettoyer les données ou les données de configuration etc...
si oui, qu'est ce que '@BeforeMethod' ne? en fait à la fois le '@BeforeClass' et '@BeforeTest' sera exécutée une fois 🙂 '@BeforeMethod " sera exécuté 3 fois. Oui, nettoyer les données est la chose principale.
ok je me suis trompé, mais la réponse a été très clair, parfait

OriginalL'auteur Prashanth Sams | 2015-06-02

  1. 74

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

    Si vous avez la suite de la Suite de tests...

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

    ... puis la sortie [en retrait pour faciliter la lecture] sera

    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

    Espère que cela aide 🙂

    Très très explicite réponse 🙂 Merci! Espérons que cela aide beaucoup....

    OriginalL'auteur peetya

  2. 5

    @BeforeMethod - exécute avant chaque méthode de test par exemple, La Méthode qui utilise l'annotation @Test

    @BeforeTest - exécute seulement avant la balise donnée dans testng.xml fichier.

    En un mot, @BeforeMethod travaux sur le test défini dans les classes Java.
    Et @BeforeTest travaux sur le test défini dans testng.xml j'.e fichiers XML.

    OriginalL'auteur Dinesh Nikam

  3. 1

    si vous étendre à partir d'une autre classe, ce sont les résultats:

    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

    OriginalL'auteur David_Garcia

  4. 0

    Mon avis:

    @BeforeClass:La méthode annotée sera exécuté avant la première méthode de test dans la classe actuelle est invoquée

    @BeforeTest:La méthode annotée sera exécuté avant toute méthode d'essai dans le courant de la suite est exécuté

    OriginalL'auteur MorganChen