TestNG MCQ

Question :What is TestNG?

A programming language

A test automation framework

A browser

An operating system

Correct Answer :  A test automation framework

 

Question :Which file is used to configure TestNG settings?

testng.properties

testng.xml

testng.cfg

testng.settings

Correct Answer :  testng.xml

 

Question :How do you define a test method in TestNG?

public void testMethod()`

public void testMethod()` with `@Test` annotation

public void testMethod()` with `@startTest` annotation

`@TestMethod`

Correct Answer :  public void testMethod()` with `@Test` annotation

 

Question :What is the purpose of the `@Test` annotation in TestNG?

It marks a method as a test method

It defines the test data

It specifies the test priority

It handles test dependencies

Correct Answer :  It marks a method as a test method

 

Question :How do you group test methods in TestNG?

Using the `@Group` annotation

Using the `@Test` annotation

Using the `@Group` annotation with the group name

Using the `@Test` annotation with the group name

Correct Answer :  Using the `@Test` annotation with the group name

 

Question :How do you specify test dependencies in TestNG?

Using the `@Dependency` annotation

Using the `@Test` annotation with `dependsOnMethods` attribute

Using the `@DependsOn` annotation

Using the `@Test` annotation with `dependsOn` attribute

Correct Answer :  Using the `@Test` annotation with `dependsOnMethods` attribute

 

Question :What is the purpose of the `@DataProvider` annotation in TestNG?

It provides data for test methods

It defines test execution order

It configures test groups

It handles test parallelism

Correct Answer :  It provides data for test methods

 

Question :How do you configure TestNG to run tests in parallel?

Using the `parallel` attribute in the `testng.xml` file

Using the `@Parallel` annotation

Using the `parallel` attribute in the `@Test` annotation

Using the `@Parallel` annotation with `true` value

Correct Answer :  Using the `parallel` attribute in the `testng.xml` file

 

Question :What is the purpose of the `@BeforeSuite` annotation in TestNG?

It runs before every test method

It runs before the test suite

It runs before the test class

It runs before every test method in a class

It runs before the test suite

 

Question :How do you disable a test method in TestNG?

Using the `@Test(enabled = false)` annotation

By commenting out the method

Using the `@Ignore` annotation

Using the `@Disabled` annotation

Using the `@Test(enabled = false)` annotation

 

Question :What is the purpose of the `@DataProvider` name attribute in TestNG?

It specifies the data provider name

It provides a unique identifier for the data provider

It links the data provider to a test method

It sets a custom name for the data provider

It specifies the data provider name

 

Question :How do you set the test execution order in TestNG?

Using the `@Order` annotation

Using the `@Sequence` annotation

Using the `@Test` annotation with the `priority` attribute

Using the `@Order` annotation with the order number

Correct Answer :  Using the `@Test` annotation with the `priority` attribute

 

Question :What is the purpose of the `@Listeners` annotation in TestNG?

It defines the test listeners

It specifies the test groups

It sets up the test data

It handles test configurations

Correct Answer :  It defines the test listeners

 

Question :How do you pass parameters to a test method in TestNG?

Using the `@Parameter` annotation

Using the `@Test` annotation with the `params` attribute

Using the `@Parameters` annotation

Using the `@Test` annotation with the `parameters` attribute

Correct Answer :  Using the `@Parameters` annotation

 

Question :What is the purpose of the `@BeforeTest` annotation in TestNG?

It runs before every test method

It runs before the test suite

It runs before the test class

It runs before every test method in a class

Correct Answer :  It runs before the test suite

 

Question :How do you handle test timeouts in TestNG?

Using the `@Timeout` annotation

Using the `@Test` annotation with the `timeout` attribute

Using the `@Time` annotation

Using the `@Test` annotation with the `time` attribute

Correct Answer :  Using the `@Test` annotation with the `timeout` attribute

 

Question :What is the purpose of the `@AfterTest` annotation in TestNG?

It runs after every test method

It runs after the test suite

It runs after the test class

It runs after every test method in a class

Correct Answer :  It runs after the test suite

 

Question :How do you handle test retries in TestNG?

Using the `@Retry` annotation

Using the `@Test` annotation with the `retryOnFailure` attribute

Using the `@Test` annotation with the `retryAnalyzer` attribute

Using the `@Test` annotation with the `retry` attribute

Using the `@Test` annotation with the `retryAnalyzer` attribute

 

Question :What is the purpose of the `@AfterSuite` annotation in TestNG?

It runs after every test method

It runs after the test suite

It runs after the test class

It runs after every test method in a class

It runs after the test suite

 

Question :How do you configure TestNG to run tests in a specific order?

By using the `preserve-order` attribute in the `testng.xml` file

By using the `@Order` annotation

By using the `order` attribute in the `@Test` annotation

By using the `@Order` annotation with the order number

By using the `preserve-order` attribute in the `testng.xml` file

 

Question :What is the purpose of the `@BeforeClass` annotation in TestNG?

It runs before every test method

It runs before the test suite

It runs before the test class

It runs before every test method in a class

It runs before the test class

 

Question :How do you handle test data providers in TestNG?

By implementing the `DataProvider` interface

By using the `@DataProvider` annotation with the `dataProviderClass` attribute

By using the `DataProviderFactory` class

By using the `@DataProvider` annotation with the `dataProvider` attribute

By using the `@DataProvider` annotation with the `dataProviderClass` attribute

 

Question :What is the purpose of the `@AfterClass` annotation in TestNG?

It runs after every test method

It runs after the test suite

It runs after the test class

It runs after every test method in a class

It runs after the test class

 

Question :How do you configure TestNG to run tests multiple times?

Using the `@Repeat` annotation

Using the `@Test` annotation with the `repeatCount` attribute

Using the `@Repeatable` annotation

Using the `@Test` annotation with the `invocationCount` attribute

Using the `@Test` annotation with the `invocationCount` attribute

 

Question :What is the purpose of the `@BeforeMethod` annotation in TestNG?

It runs before every test method

It runs before the test suite

It runs before the test class

It runs before every test method in a class

It runs before every test method

 

Question :How do you handle test parameterization in TestNG?

Using the `@Test` annotation with the `param` attribute

Using the `@Param` annotation

Using the `@Test` annotation with the `parameters` attribute

Using the `@Parameters` annotation

Using the `@Parameters` annotation

 

Question :What is the purpose of the `@AfterMethod` annotation in TestNG?

It runs after every test method

It runs after the test suite

It runs after the test class

It runs after every test method in a class

It runs after every test method

 

Question :How do you configure TestNG to run only specific test methods?

Using the `@Test` annotation with the `includeMethods` attribute

Using the `@IncludeMethods` annotation

Using the `@Test` annotation with the test method name

Using the `@Test` annotation with the `include` attribute

Using the `@Test` annotation with the `include` attribute

 

Question :What is the purpose of the `@Factory` annotation in TestNG?

It defines the test factories

It creates test instances

It runs the test suite

It specifies the test groups

It defines the test factories

 

Question :How do you configure TestNG to run tests in a specific thread pool size?

Using the `@ThreadPoolSize` annotation

Using the `@Test` annotation with the `threadPoolSize` attribute

Using the `@Thread` annotation

Using the `@Test` annotation with the `threadPool` attribute

Using the `@Test` annotation with the `threadPoolSize` attribute

TestNG Questions

Question: TestNG Annotations Answer:

@Test
@BeforeMethod
@AfterMethod
@BeforeTest
@AfterTest
@BeforeClass
@AfterClass
@Test(enabled = false)
@Test(enabled = true)
@Test(priority=2)
@Test(priority=5,dependsOnMethods={"method1","method2"})
@Test(dependsOnMethods = {"method1"}, alwaysRun=true)
@Test(groups = { "Group1", "Group2" })
@Parameters({"testparameter1", "testparameter2"})
@Listeners(packagename.ListenerClassName.class)
@Test(dataProvider = "getUserIDandPassword")
@Test(description = "Open Facebook Login Page", timeOut=35000)
@Test(invocationCount = 3, invocationTimeOut = 20000)
@Test(invocationCount = 3, skipFailedInvocations = true)
@Test(invocationCount = 3)
@Test(invocationCount = 7, threadPoolSize = 2) 

Question: Order of TestNG annotations Answer: Order of TestNG annotations is as below:

@BeforeSuite
@BeforeTest
@BeforeClass
@BeforeMethod
@Test
@AfterMethod
@AfterClass
@AfterTest
@AfterSuite

Question: Assertion in TestNG Answer: Assertions are used to verify the expected outcomes of test cases. Assertions are essential for test automation as they help validate that the actual results match the expected results during test execution. When an assertion fails, it indicates a test failure, and the testing framework will mark the test as failed.

Here are some commonly used assertion methods in TestNG:

• assertEquals(expected, actual): Compares the expected value with the actual value and asserts that they are equal.
• assertNotEquals(expected, actual): Compares the expected value with the actual value and asserts that they are not equal.
• assertTrue(condition): Asserts that the given condition is true.
• assertFalse(condition): Asserts that the given condition is false.
• assertNull(object): Asserts that the given object reference is null.
• assertNotNull(object): Asserts that the given object reference is not null.

Question: How do you group test methods in TestNG, and what is the purpose of grouping tests? Answer: In TestNG (Test Next Generation), you can group test methods using the groups attribute. Grouping tests allows you to categorize your test methods and execute them selectively. This feature is particularly useful when you want to run specific sets of tests based on different criteria or requirements. For example, you may have a suite of tests that cover basic functionality and another set that focuses on more complex scenarios or integration tests.

import org.testng.annotations.Test;

public class MyTestSuite {
    @Test(groups = "smoke")
    public void testMethod1() {
        // Test logic here
    }

    @Test(groups = "regression")
    public void testMethod2() {
        // Test logic here
    }

    @Test(groups = {"smoke", "regression"})
    public void testMethod3() {
        // Test logic here
    }

    @Test(groups = "integration")
    public void testMethod4() {
        // Test logic here
    }
}

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="MyTestSuite">
    <test name="SmokeTests">
        <groups>
            <run>
                <include name="smoke" />
            </run>
        </groups>
        <classes>
            <class name="com.example.MyTestSuite" />
        </classes>
    </test>

    <test name="RegressionTests">
        <groups>
            <run>
                <include name="regression" />
            </run>
        </groups>
        <classes>
            <class name="com.example.MyTestSuite" />
        </classes>
    </test>
</suite>

Question: What is the purpose of the @DataProvider annotation in TestNG? How do you implement data-driven testing using TestNG? Answer: The purpose of the @DataProvider annotation in TestNG is to facilitate data-driven testing, where you can run the same test method with multiple sets of data. Data-driven testing allows you to test various scenarios and edge cases with different input data, making your test suite more robust and comprehensive.

Steps to implement data-driven testing:

1. Create a Data Provider Method
2. Annotate the Data Provider Method
3. Pass Data to Test Method

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class DataProviderExample {

    @DataProvider(name = "testData")
    public Object[][] testData() {
        return new Object[][] {
            { 2, 3, 5 },     // Test Case 1: 2 + 3 = 5
            { -1, 5, 4 },    // Test Case 2: -1 + 5 = 4
            { 0, 0, 0 }      // Test Case 3: 0 + 0 = 0
        };
    }

    @Test(dataProvider = "testData")
    public void testAddition(int num1, int num2, int expectedSum) {
        int actualSum = add(num1, num2);
        assert actualSum == expectedSum : "Addition failed!";
    }

    public int add(int a, int b) {
        return a + b;
    }
}

Question: Explain the concept of dependencies in TestNG. How do you manage test method dependencies using annotations? Answer: In TestNG, dependencies allow you to define a relationship between test methods, specifying that one test method depends on the successful execution of another.

1. dependsOnMethods Attribute

@Test
public void testLogin() {
    // Test login functionality
}

@Test(dependsOnMethods = "testLogin")
public void testDashboard() {
    // Test dashboard functionality that requires successful login
}

2. dependsOnGroups Attribute

@Test(groups = "login")
public void testLogin() {
    // Test login functionality
}

@Test(dependsOnGroups = "login")
public void testDashboard() {
    // Test dashboard functionality that requires successful login
}

Question: How do you perform parallel test execution in TestNG? What are the benefits and challenges of parallel testing? Answer: In TestNG, you can perform parallel test execution by leveraging its built-in support for parallel test execution. Parallel testing allows you to run multiple test methods or test classes concurrently on multiple threads, which can significantly reduce test execution time and improve overall test suite efficiency.

TestNG offers the following options for parallel test execution:

1. Parallel Test Execution at Test Level:

You can specify parallel test execution at the test level using parallel="tests". This allows multiple tags to execute concurrently.

<suite name="MyTestSuite" parallel="tests">
    <test name="Test1">
        <!-- Test configuration and classes go here -->
    </test>
    <test name="Test2">
        <!-- Test configuration and classes go here -->
    </test>
</suite>

2. Parallel Test Execution at Class Level:

You can specify parallel test execution at the class level using parallel="classes". This allows test classes to execute concurrently.

<suite name="MyTestSuite" parallel="classes">
    <test name="MyTestClass">
        <classes>
            <class name="com.example.tests.Class1" />
            <class name="com.example.tests.Class2" />
        </classes>
    </test>
</suite>

3. Parallel Test Execution at Method Level:

You can specify parallel test execution at the method level using parallel="methods". This allows individual test methods to execute concurrently.

<suite name="MyTestSuite" parallel="methods">
    <test name="MyTestClass">
        <classes>
            <class name="com.example.tests.Class1" />
            <class name="com.example.tests.Class2" />
        </classes>
    </test>
</suite>

Parallel Testing Suite with Thread Count:

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="Parallel Testing Suite">
    <test name="Parallel Tests" parallel="methods" thread-count="2">
        <classes>
            <class name="ParallelTest" />
        </classes>
    </test>
</suite>

Threads in parallel testing refer to different execution paths in which test execution can be divided and run concurrently. For example, if there are two threads and two methods, each thread can execute one method when methods are configured to run in parallel. If there are three methods and two threads, one method will have to wait until a thread becomes available for execution.

In TestNG, we also get the liberty to run a single test method in parallel by configuring it inside the test code itself.

public class TestNG {

    @Test(threadPoolSize = 4, invocationCount = 4, timeOut = 1000)
    public void testMethod() {
        System.out.println("Thread ID Is : " + Thread.currentThread().getId());
    }
}

Parameters in the @Test annotation:

• threadPoolSize: The number of threads to create for running the test method in parallel.
• invocationCount: The number of times to invoke the test method.
• timeOut: The maximum time a test execution should take. If this limit is exceeded, the test fails automatically.

Question: TestNG Groups - Include, Exclude Answer: Include Groups:
The element is used to include specific groups for execution.

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="MyTestSuite">
    <test name="IncludeGroupsTest">
        <groups>
            <run>
                <include name="smoke" />
                <include name="sanity" />
            </run>
        </groups>
        <classes>
            <class name="com.example.tests.TestClass1" />
            <class name="com.example.tests.TestClass2" />
        </classes>
    </test>
</suite>

Exclude Groups:
The element is used to exclude specific groups from execution.

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="MyTestSuite">
    <test name="ExcludeGroupsTest">
        <groups>
            <run>
                <exclude name="regression" />
            </run>
        </groups>
        <classes>
            <class name="com.example.tests.TestClass1" />
            <class name="com.example.tests.TestClass2" />
        </classes>
    </test>
</suite>

Question: What are TestNG listeners, and how do you use them to customize test execution behavior or generate custom reports? Answer: TestNG listeners are a powerful feature that allows you to customize the behavior of TestNG during test execution. Listeners are Java classes that implement various TestNG listener interfaces and are registered with the TestNG test suite. These listeners "listen" to events that occur during the test execution lifecycle and can perform actions or provide additional information based on those events.

TestNG provides several listener interfaces that can be used to customize test execution behavior or generate custom reports. Some commonly used TestNG listener interfaces are:

• ITestListener: Provides methods to handle test-level events such as test start, test success, test failure, and test skipped.
• ISuiteListener: Provides methods to handle suite-level events such as suite start and suite finish.
• IInvokedMethodListener: Provides methods such as beforeInvocation() and afterInvocation() to handle events surrounding individual method invocations.
• IReporter: Allows you to generate custom reports based on test results.
• IAnnotationTransformer: Allows you to modify test annotations at runtime, such as dynamically changing annotation attributes.

Example of ITestListener:

import org.testng.ITestListener;
import org.testng.ITestResult;

public class CustomTestListener implements ITestListener {

    @Override
    public void onTestStart(ITestResult result) {
        System.out.println("Test Started: " + result.getName());
    }

    @Override
    public void onTestSuccess(ITestResult result) {
        System.out.println("Test Passed: " + result.getName());
    }

    @Override
    public void onTestFailure(ITestResult result) {
        System.out.println("Test Failed: " + result.getName());
    }

    @Override
    public void onTestSkipped(ITestResult result) {
        System.out.println("Test Skipped: " + result.getName());
    }

    // Other methods from the ITestListener interface
}

Registering the listener in testng.xml:

<suite name="MyTestSuite">
    <listeners>
        <listener class-name="com.example.listeners.CustomTestListener" />
    </listeners>
    <!-- Test configurations and test classes go here -->
</suite>

Question: Handle test timeouts and set maximum time limits for test methods in TestNG Answer: In TestNG, you can handle test timeouts and set maximum time limits for test methods to prevent tests from running indefinitely and to mark them as failed if they exceed the specified time limit. This is useful for avoiding potential test hang-ups and ensuring that test execution remains efficient.

@Test(timeOut = 3000) // The test method should complete within 3 seconds (3000 milliseconds)
public void testWithTimeout2() throws InterruptedException {
    // Test logic that may take some time to execute
    Thread.sleep(5000); // This test will fail because it exceeds the time limit
}

Question: What are the different types of listeners available in TestNG, and how can you use them to handle test events? Answer: TestNG provides several listener interfaces that allow you to respond to different events during test execution:

• ITestListener: Provides methods to handle test-level events such as test start, test success, test failure, and test skipped. It allows you to perform actions before and after test execution and respond to test outcomes.
• ISuiteListener: Provides methods to handle suite-level events such as suite start and suite finish. It allows you to perform actions at the beginning and end of test suite execution.
• IInvokedMethodListener: Provides methods to handle events surrounding individual method invocations through methods such as beforeInvocation() and afterInvocation().
• IConfigurationListener: Provides methods to handle configuration method execution events, such as methods annotated with @BeforeSuite, @AfterSuite, and other configuration annotations.
• IAnnotationTransformer: Allows you to modify annotations at runtime. You can add or modify attributes of test annotations dynamically.
• IReporter: Allows you to generate custom reports based on test results. You can create custom test execution reports with additional information.

By implementing these listener interfaces and overriding their respective methods, you can customize the behavior of TestNG during test execution. For example, you can log test results, perform cleanup tasks, handle test events, generate custom reports, and modify test configurations at runtime. Question: What are TestNG suites? Answer: In TestNG, a suite is a way to organize and execute a logical group of tests. It allows you to define a set of test classes or test methods that belong together and should be executed as a cohesive unit. TestNG suites provide a higher level of organization, allowing you to group related tests, configure test execution settings, and manage dependencies between test classes or methods. Question: How do you perform parameterization in TestNG, and what are the different ways to pass parameters to test methods? Answer: Parameterization allows you to pass data to test methods and execute them with different sets of input values. Parameterization is useful when you want to run the same test method with various combinations of data to test different scenarios or perform data-driven testing.

Using @Parameters Annotation:

@Test
@Parameters({ "username", "password" })
public void testLogin(String username, String password) {
    // Test login functionality using the provided username and password
}

testng.xml:

<suite name="MyTestSuite">
    <test name="Test1">
        <parameter name="username" value="user1" />
        <parameter name="password" value="pass123" />
        <classes>
            <class name="com.example.tests.ParameterizationExample" />
        </classes>
    </test>
</suite>

Question: Explain the concept of soft assertions in TestNG and how they differ from regular assertions. Answer: Soft assertions provide an alternative way of performing assertions compared to regular or hard assertions. The key difference lies in how they handle assertion failures and the continuation of test execution after an assertion failure occurs.

When a regular assertion, such as assertEquals or assertTrue, fails in TestNG, the test immediately stops at that assertion, and TestNG marks the test as failed.

Soft assertions, on the other hand, allow you to continue executing the test even after an assertion failure. This means all assertions can be checked, and the test is marked as failed when assertAll() is called if any of the soft assertions have failed.

@Test
public void testSoftAssertion() {
    int actualValue = 10;
    int expectedValue = 5;

    SoftAssert softAssert = new SoftAssert();

    softAssert.assertEquals(actualValue, expectedValue); // Assertion fails, but the test continues
    System.out.println("This line will be executed.");
    softAssert.assertAll(); // This will mark the test as failed if any soft assertion has failed
}

Question: How do you skip or ignore test methods selectively in TestNG, and what is the purpose of doing so? Answer: TestNG provides several ways to skip or ignore test methods selectively. This is useful when a test is temporarily unavailable, under development, not applicable to a particular execution, or should run only when a prerequisite test or group has been successfully executed.

1. Using the enabled Attribute:

@Test(enabled = false)
public void testMethod2() {
    // This test method will be skipped
}

2. Using dependsOnMethods or dependsOnGroups:
A test method can depend on another test method or group. If the required dependency does not successfully execute, the dependent test may be skipped by TestNG. Question: What are the different ways to specify test execution order in TestNG, and when would you use each method? Answer: TestNG provides several mechanisms for controlling or influencing test execution order.

1. Default Execution Order:
TestNG generally follows the order in which test classes and methods are discovered or specified. The exact order should not be relied upon when tests have no explicit ordering or dependency relationship.

2. Using the preserve-order Attribute:
The preserve-order attribute can be used in the TestNG XML configuration to preserve the order in which test classes are declared.

<suite name="MyTestSuite">
    <test name="Test1" preserve-order="true">
        <classes>
            <class name="com.example.tests.TestClass1" />
            <class name="com.example.tests.TestClass2" />
        </classes>
    </test>
</suite>

3. Using dependsOnMethods Attribute:
Use dependsOnMethods when one test method must execute after another test method and the second test should depend on the successful execution of the first.

@Test
public void testStep1() {
    // Test step 1 logic
}

@Test(dependsOnMethods = "testStep1")
public void testStep2() {
    // Test step 2 logic
}

4. Using Priority Attribute:
Use the priority attribute when you want to assign an execution priority to test methods. Lower priority values are executed before higher priority values.

@Test(priority = 1)
public void testStep1() {
    // Test step 1 logic
}

@Test(priority = 2)
public void testStep2() {
    // Test step 2 logic
}

Question: How can you create test dependencies in TestNG without using annotations? Answer: TestNG allows dependencies to be configured through testng.xml using group dependencies. Method-level dependencies, however, are normally defined using annotations or TestNG's programmatic APIs; they cannot be specified by simply adding a dependsOnMethods attribute to a testng.xml method entry.

1. Using testng.xml for Group Dependencies:
You can define dependencies between groups in the TestNG XML configuration.

<suite name="TestSuite">
    <test name="Test1">
        <groups>
            <dependencies>
                <group name="testMethod2" depends-on="testMethod1" />
            </dependencies>
        </groups>
        <classes>
            <class name="com.example.TestClass1" />
            <class name="com.example.TestClass2" />
        </classes>
    </test>
</suite>

For method-level dependencies, you can use dependsOnMethods in the @Test annotation.

import org.testng.annotations.Test;

public class TestClass1 {

    @Test
    public void testMethod1() {
        // Test method logic
    }
}

public class TestClass2 {

    @Test(dependsOnMethods = "testMethod1")
    public void testMethod2() {
        // Test method logic
    }
}

In this example, testMethod2 depends on testMethod1 because of the dependsOnMethods attribute. Question: How do you generate and analyze TestNG reports, and what information do these reports provide? Answer: TestNG generates reports after test execution, providing valuable information about test results and overall test suite execution. The generated reports commonly include HTML reports with details about test methods, pass/fail status, execution time, and other relevant information.

1. Run TestNG Tests:
First, execute your TestNG test suite. This can be done using various methods, such as running tests from the command line, an IDE, build tools such as Maven or Gradle, or continuous integration systems such as Jenkins.

2. Generate TestNG Reports:
After test execution, TestNG commonly generates HTML reports in the test-output folder by default. The reports provide an overview of the test results and detailed information about individual test methods.

3. Analyze TestNG Reports:
Open the generated HTML report in a web browser or HTML viewer to analyze the test results. The report can provide information such as:

• Suite Summary: Shows information such as the total number of test cases, passed tests, failed tests, skipped tests, and execution time.
• Test Details: Includes details for individual test methods, such as the test method name, test class name, status, and execution time.
• Test Logs and Stack Traces: For failed test methods, TestNG can provide error messages and stack traces to help identify the cause of failure.
• Configuration Methods: If configuration methods such as @BeforeTest or @BeforeClass are used, their execution results can be included in the report.
• Groups and Parameters: TestNG reports can provide information about groups and parameters associated with test execution.
• Time Taken: Execution times can help identify slow-running tests.
• Custom Reports: If you implement a custom TestNG reporter using the IReporter interface, you can generate additional customized reports based on the test results.