Difference between BeforeClass and BeforeTest in TestNG

Question

As we know from official TestNG documentation:

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked.

@BeforeTest: The annotated method will be run before any test method belonging to the classes inside the <test> tag is run.

Both the above TestNG annotations look similar in functionality. Can anyone explain the unique difference?

Answer 1

@BeforeMethod - executes before every test method e.g. The Method which uses @Test annotation

@BeforeTest - executes only before tag given in testng.xml file.

In a nutshell, @BeforeMethod works on test defined in Java classes. And @BeforeTest works on test defined in testng.xml i.e XML files.

Answer 2

Before explaining the difference, first this is some testing terminologies

Test suite – Consists of one or more test tags.

Test tag - Consists of one or more test classes.

Test class – Consists of one or more methods.

for examble

<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 : It will be called Only one time before any test tag, no matter how many test classes inside that tag or how many method annotated with @Test, it will be called only one time for each test tag,in the previous XML example @BeforeTest will be called twice, one time beforeTestTag1 the second time before TestTag2 so it can be used to initialize common objects between different test classes inside one test tag.

@BeforeClass : It will be called Only one time before any test class, no matter how many method annotated with @Test inside this test class, it will be called only one time for each test class,in the previous XML example @BeforeClass will be called three times, one time beforeTestClass1 the second time before TestClass2 and the third time before TestClass3 so it can be used to initialize common objects between different test methods inside one test class.

@BeforeSuite will be called once for the suit1 suit

the order of calls will be as follow

@BeforeSuite
    @BeforeTest
        @BeforeClass
            @BeforeMethod
                @Test

To know more about @BeforeMethod, please refer to the answer https://stackoverflow.com/a/52331616/1973933

Answer 3

if you extend from another class this are the results:

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 4

My opinions:

@BeforeClass:The annotated method will be run before the first test method in the current class is invoked

@BeforeTest:The annotated method will be run before any test method in the current suite is run

Answer 5

This is the TestNG hierarchy: Test Suite -> Test -> Class -> Method

@BeforeTest is executed once before the execution of all methods in all classes within test tag.

on the other hand;

@BeforeClass is executed once before the execution of all methods within the class it is defined.

I have uploaded the script on my GitHub Profile. Here is a link for same. Please give a thumbs up if you like.

Please have a look at github:

Answer 6

@BeforeClass: The annotated method will be run before the first test method in the current class is invoked. 
@BeforeMethod: The annotated method will be run before each test method.

The annotations above will also be honored (inherited) when placed on a superclass of a TestNG class. This is useful for example to centralize test setup for multiple test classes in a common superclass.

In that case, TestNG guarantees that the "@Before" methods are executed in inheritance order (highest superclass first, then going down the inheritance chain), and the "@After" methods in reverse order (going up the inheritance chain).

To know more about TestNG annotations: https://testng.org/doc/documentation-main.html#annotations

Answer 7

What is missing in the above answers is the usage difference between @BeforeClass and @BeforeTest annotations.

As it is clear that the method (most commonly the setup method) annotated with @BeforeClass will execute only once before all the testcases written in the class. And the method annotated with '@BeforeTest' will execute before every testcase regardless of their count/sequence/underline logic.

Therefore, @BeforeClass is used when our method has long calls with long execution time and the output of these calls will be unchanged by any of the testcases. For example, getting an API response in the setup method, which will be used by all the tests. Whereas, @BeforeTest@ is used when we need to do some cleanup stuff, and every test needs some fresh resource to start with. For example, one newly created order etc.