TestNG Annotations And Benefits | TestNG Tutorial

TestNG Annotations:

In this post, we see the list of TestNG Annotations. You could learn complete TestNG Tutorial here. Here is a quick overview of the annotations available in TestNG.

@Test: Marks a class or a method as a part of the test.

@BeforeMethod: A method which is marked with this annotation will be executed before every @test annotated method.

@AfterMethod: A method which is marked with this annotation will be executed after every @test annotated method.

@BeforeClass: A method which is marked with this annotation will be executed before first @Test method execution. It runs only once per class.

@AfterClass: A method which is marked with this annotation will be executed after all the test methods in the current class have been run

@BeforeTest: A method which is marked with this annotation will be executed before first @Test annotated method.

@AfterTest: A method which is marked with this annotation will be executed when all @Test annotated methods complete the execution of those classes which are inside <test> tag in testng.xml file.

@BeforeSuite: A method which is marked with this annotation will run only once before all tests in the suite have run

@AfterSuite: A method which is marked with this annotation will run once after execution of all tests in the suite have run

@BeforeGroups: This annotated method will run before the first test run of that specific group.

@AfterGroups: This annotated method will run after all test methods of that group completes its execution.

Some other TestNG Annotations, we need to discuss here are mentioned below:

@Parameters: This annotation is used to pass parameters to test methods.

@DataProvider: If we use @DataProvider annotation for any method that means you are using that method as a data supplier. The configuration of @DataProvider annotated method must be like it always return Object[][] which we can use in @Test annotated method. The @Test method that wants to receive data from this DataProvider needs to use a dataProvider name equals to the name of this annotation.

@Factory: Marks a method as a factory that returns objects that will be used by TestNG as Test classes. The method must return Object[ ].

@Listeners: This annotation is used with test class. It helps in writing logs and results.

Check below video to see “TestNG Annotations”

Please be patient. The video will load in some time.

If you liked this video, then please subscribe to our YouTube Channel for more video tutorials.

Benefits of Using TestNG Annotations:

Following are some of the benefits of using annotations:

• TestNG identifies the methods it is interested in, by looking up annotations. Hence, method names are not restricted to any pattern or format.
• We can pass additional parameters to annotations.
• Annotations are strongly typed, so the compiler will flag any mistakes right away.
• Test classes no longer need to extend anything (such as TestCase, for JUnit 3).

Let’s see the order of methods called using the below script:

package softwareTestingMaterial;

import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class TestngAnnotation {
	   
	   // Test Case 1
	   @Test
	   public void testCase1() {
	      System.out.println("in Test Case 1");
	   }

	   // Test Case 2
	   @Test
	   public void testCase2() {
	      System.out.println("in Test Case 2");
	   }

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

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

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

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

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

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

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

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

}

Console output:

[TestNG] Running:

in Before Suite
in Before Test
in Before Class
in Before Method
in Test Case 1
in After Method
in Before Method
in Test Case 2
in After Method
in After Class
in After Test
in After Suite

===============================================
Default suite
Total tests run: 2, Failures: 0, Skips: 0
===============================================

Execution process is as follows:

First of all, beforeSuite() method is executed only once.

Lastly, the afterSuite() method executes only once.

Even the methods beforeTest(), beforeClass(), afterClass(), and afterTest() methods are executed only once.

beforeMethod() method executes for each test case but before executing the test case.

afterMethod() method executes for each test case but after executing the test case.

In between beforeMethod() and afterMethod(), each test case executes.

This is all about TestNG Annotations. If you have any queries, please comment below. You could find the complete TestNG tutorial here.

TestNG Complete Tutorial

If you are not a regular reader of my blog then I highly recommend you to signup for the free email newsletter using the below link.