@Test:
Usage: Marks a method as a test method.
Execution: The methods annotated with @Test are executed when TestNG runs the test suite.
Java Code
import org.testng.annotations.Test;
public class MyTestClass {
@Test
public void myTestMethod() {
// Test logic goes here
}
}
@BeforeSuite:
Usage: Executed before the TestNG suite starts, runs only once.
Execution: This annotation is used to set up global preconditions for the entire test suite.
Java Code
import org.testng.annotations.BeforeSuite;
public class MyTestClass {
@BeforeSuite
public void setUpBeforeSuite() {
// Global setup logic goes here
}
}
@AfterSuite:
Usage: Executed after the TestNG suite ends, runs only once.
Execution: This annotation is used for cleanup or teardown tasks after the entire test suite has finished executing.
Java Code
import org.testng.annotations.AfterSuite;
public class MyTestClass {
@AfterSuite
public void tearDownAfterSuite() {
// Global teardown logic goes here
}
}
@BeforeTest:
Usage: Executed before each <test> tag in the testng.xml file.
Execution: Methods annotated with @BeforeTest are executed before each <test> tag defined in the testng.xml file.
Java Code
import org.testng.annotations.BeforeTest;
public class MyTestClass {
@BeforeTest
public void setUpBeforeTest() {
// Test-specific setup logic goes here
}
}
@AfterTest:
Usage: Executed after each <test> tag in the testng.xml file.
Execution: Methods annotated with @AfterTest are executed after each <test> tag defined in the testng.xml file.
Java Code
import org.testng.annotations.AfterTest;
public class MyTestClass {
@AfterTest
public void tearDownAfterTest() {
// Test-specific teardown logic goes here
}
}
@BeforeClass:
Usage: Executed before the first test method in the current class.
Execution: Methods annotated with @BeforeClass are executed once before any test methods in the current class are executed.
Java Code
import org.testng.annotations.BeforeClass;
public class MyTestClass {
@BeforeClass
public void setUpBeforeClass() {
// Class-specific setup logic goes here
}
}
@AfterClass:
Usage: Executed after all the test methods in the current class have been run.
Execution: Methods annotated with @AfterClass are executed once after all test methods in the current class have been executed.
Java Code
import org.testng.annotations.AfterClass;
public class MyTestClass {
@AfterClass
public void tearDownAfterClass() {
// Class-specific teardown logic goes here
}
}
@BeforeMethod:
Usage: Executed before each test method.
Execution: Methods annotated with @BeforeMethod are executed before each test method in the class.
Java Code
import org.testng.annotations.BeforeMethod;
public class MyTestClass {
@BeforeMethod
public void setUpBeforeMethod() {
// Method-specific setup logic goes here
}
}
@AfterMethod:
Usage: Executed after each test method.
Execution: Methods annotated with @AfterMethod are executed after each test method in the class.
Java Code
import org.testng.annotations.AfterMethod;
public class MyTestClass {
@AfterMethod
public void tearDownAfterMethod() {
// Method-specific teardown logic goes here
}
}
@DataProvider:
Usage: Supplies data to test methods, allowing them to be executed multiple times with different data sets.
Execution: Methods annotated with @DataProvider provide the data required for test methods.
Java Code
import org.testng.annotations.DataProvider;
public class MyDataProvider {
@DataProvider(name = “myData”)
public Object[][] provideData() {
// Data generation logic goes here
}
}
@Parameters:
Usage: Provides values to test methods from the testng.xml file.
Execution: TestNG injects parameter values from the testng.xml file into test methods annotated with @Parameters.
Java Code
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
public class MyTestClass {
@Test
@Parameters(“myParameter”)
public void myTestMethod(String parameterValue) {
// Test logic using parameterValue goes here
}
}
@Listeners:
Usage: Defines custom listeners to perform additional actions during test execution, such as logging or reporting.
Execution: Methods annotated with @Listeners are invoked during various stages of test execution to perform custom actions.
Java Code
import org.testng.annotations.Listeners;
@Listeners(MyCustomListener.class)
public class MyTestClass {
// Test methods and other annotations go here
}
@Factory:
Usage: Allows the creation of test instances dynamically, enabling data-driven testing and parallel execution.
Execution: The @Factory annotation is used to create multiple instances of a test class, each with different data sets or configurations.
Java Code
import org.testng.annotations.Factory;
public class MyFactory {
@Factory
public Object[] createInstances() {
// Test instances creation logic goes here
}
}
@BeforeGroups:
Usage: Executed before the first test method that belongs to any of the specified groups.
Execution: Methods annotated with @BeforeGroups are executed before any test methods belonging to the specified groups are executed.
Java Code
import org.testng.annotations.BeforeGroups;
public class MyTestClass {
@BeforeGroups(“group1”)
public void setUpBeforeGroup() {
// Group-specific setup logic goes here
}
}
@AfterGroups:
Usage: Executed after all the test methods that belong to any of the specified groups have been run.
Execution: Methods annotated with @AfterGroups are executed after all test methods belonging to the specified groups have been executed.
Java Code
import org.testng.annotations.AfterGroups;
public class MyTestClass {
@AfterGroups(“group1”)
public void tearDownAfterGroup() {
// Group-specific teardown logic goes here
}
}
These examples illustrate how each annotation is used and executed in TestNG-based Selenium tests.
Author’s Bio:
As CEO of TestLeaf, I’m dedicated to transforming software testing by empowering individuals with real-world skills and advanced technology. With 24+ years in software engineering, I lead our mission to shape local talent into global software professionals. Join us in redefining the future of test engineering and making a lasting impact in the tech world.
Babu Manickam
