Advantages of Parallel Tests Execution
Parallelism or multi-threaded execution can provide a lot of advantages to the users. The following are two:
1) Reduces execution time: As tests are executed in parallel, multiple tests get executed simultaneously, hence reducing the overall time taken to execute the tests.
2) Allows multi-threaded tests: Using this feature, we can write tests to verify certain multi-threaded code in the applications
This feature is vastly used by the QA industry for functional automation testing. This feature helps QA guys configure their tests to be executed easily in multiple browsers or operating systems simultaneously.
There are different ways in which parallelism feature can be configured in TestNG.
Running test methods in parallel
TestNG provides multiple ways to execute the tests in a multi-threaded condition, one of them is executing each test method in a single thread. This mode reduces the execution time significantly because more tests are executed in parallel, hence reducing the total execution time.
package com.howtodoinjava.parallelism;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class ParallelMethodTest
{
@BeforeMethod
public void beforeMethod() {
long id = Thread.currentThread().getId();
System.out.println("Before test-method. Thread id is: " + id);
}
@Test
public void testMethodsOne() {
long id = Thread.currentThread().getId();
System.out.println("Simple test-method One. Thread id is: " + id);
}
@Test
public void testMethodsTwo() {
long id = Thread.currentThread().getId();
System.out.println("Simple test-method Two. Thread id is: " + id);
}
@AfterMethod
public void afterMethod() {
long id = Thread.currentThread().getId();
System.out.println("After test-method. Thread id is: " + id);
}
}
|
The preceding test class contains two test methods, which prints a message onto the console when executed. The ID of the thread on which the current method is being executed is evaluated using theThread.currentThread.getId() code. It also contains the before and after methods, which also prints the thread ID of the current thread onto the console when executed.
Create a new file named methods-test-testng.xml under the project and write below code.
<suite name="Test-method Suite" parallel="methods" thread-count="2" >
<test name="Test-method test" group-by-instances="true">
<classes>
<class name="com.howtodoinjava.parallelism.ParallelMethodTest" />
</classes>
</test>
</suite>
|
Select this file in Eclipse and run it as a TestNG suite. You will see the following test result in the Console window:
Before test-method. Thread id is: 10
Before test-method. Thread id is: 9
Simple test-method Two. Thread id is: 10
Simple test-method One. Thread id is: 9
After test-method. Thread id is: 10
After test-method. Thread id is: 9
|
Note that the Id value shown in the previous screenshot may not be the same in your console output. The Id value is assigned at runtime by the Java virtual machine (JVM) during execution.
The previous test result clearly shows that each test method and its respective before and after method is executed in a different thread. This is identified by the ID of the thread that is printed on the console.
Running test classes in parallel
In this example, we will learn about executing test classes in parallel; each test class that is part of the test execution will be executed in its own thread.
ParallelClassesTestOne.java
public class ParallelClassesTestOne
{
@BeforeClass
public void beforeClass() {
long id = Thread.currentThread().getId();
System.out.println("Before test-class. Thread id is: " + id);
}
@Test
public void testMethodOne() {
long id = Thread.currentThread().getId();
System.out.println("Sample test-method One. Thread id is: " + id);
}
@Test
public void testMethodTwo() {
long id = Thread.currentThread().getId();
System.out.println("Sample test-method Two. Thread id is: " + id);
}
@AfterClass
public void afterClass() {
long id = Thread.currentThread().getId();
System.out.println("After test-class. Thread id is: " + id);
}
}
|
ParallelClassesTestTwo.java
public class ParallelClassesTestTwo
{
@BeforeClass
public void beforeClass() {
long id = Thread.currentThread().getId();
System.out.println("Before test-class. Thread id is: " + id);
}
@Test
public void testMethodOne() {
long id = Thread.currentThread().getId();
System.out.println("Sample test-method One. Thread id is: " + id);
}
@Test
public void testMethodTwo() {
long id = Thread.currentThread().getId();
System.out.println("Sample test-method Two. Thread id is: " + id);
}
@AfterClass
public void afterClass() {
long id = Thread.currentThread().getId();
System.out.println("After test-class. Thread id is: " + id);
}
}
|
Create a new file named classes-test-testng.xml under the project and write below code.
<suite name="Test-class Suite" parallel="classes" thread-count="2" >
<test name="Test-class test" >
<classes>
<class name="com.howtodoinjava.parallelism.ParallelClassesTestOne" />
<class name="com.howtodoinjava.parallelism.ParallelClassesTestTwo" />
</classes>
</test>
</suite>
|
Select this file in Eclipse and run it as a TestNG suite. You will see the following test result in the Console window:
Before test-class. Thread id is: 10
Before test-class. Thread id is: 9
Sample test-method One. Thread id is: 9
Sample test-method One. Thread id is: 10
Sample test-method Two. Thread id is: 10
After test-class. Thread id is: 10
Sample test-method Two. Thread id is: 9
After test-class. Thread id is: 9
|
The previous test result clearly shows that each test class and its respective beforeClass and afterClassmethods are executed in a different thread. This is identified by the id of the thread that is printed on the console.
Running tests inside a suite in parallel
Let’s learn about executing each test inside a suite in parallel, that is, each test that is part of the test suite execution will be executed in its own separate respective thread.
package com.howtodoinjava.parallelism;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
public class ParallelSuiteTest
{
String testName = "";
@BeforeTest
@Parameters({ "test-name" })
public void beforeTest(String testName) {
this.testName = testName;
long id = Thread.currentThread().getId();
System.out.println("Before test " + testName + ". Thread id is: " + id);
}
@BeforeClass
public void beforeClass() {
long id = Thread.currentThread().getId();
System.out.println("Before test-class " + testName + ". Thread id is: "
+ id);
}
@Test
public void testMethodOne() {
long id = Thread.currentThread().getId();
System.out.println("Sample test-method " + testName
+ ". Thread id is: " + id);
}
@AfterClass
public void afterClass() {
long id = Thread.currentThread().getId();
System.out.println("After test-method " + testName
+ ". Thread id is: " + id);
}
@AfterTest
public void afterTest() {
long id = Thread.currentThread().getId();
System.out.println("After test " + testName + ". Thread id is: " + id);
}
}
|
Create a new file named suite-test-testng.xml under the project and write below code.
<suite name="Test-class Suite" parallel="tests" thread-count="2">
<test name="Test-class test 1">
<parameter name="test-name" value="test-method One" />
<classes>
<class name="com.howtodoinjava.parallelism.ParallelSuiteTest" />
</classes>
</test>
<test name="Test-class test 2">
<parameter name="test-name" value="test-method One" />
<classes>
<class name="com.howtodoinjava.parallelism.ParallelSuiteTest" />
</classes>
</test>
</suite>
|
Select this file in Eclipse and run it as a TestNG suite. You will see the following test result in the Console window:
Before test Test One. Thread id is: 9
Before test Test Two. Thread id is: 10
Before test-class Test One. Thread id is: 9
Before test-class Test Two. Thread id is: 10
Sample test-method Test One. Thread id is: 9
Sample test-method Test Two. Thread id is: 10
After test-method Test Two. Thread id is: 10
After test-method Test One. Thread id is: 9
After test Test One. Thread id is: 9
After test Test Two. Thread id is: 10
|
The previous test result clearly shows that each test in a suite is executed in its respective thread. This is identified by the ID of the thread that is printed on the console.
Configuring a test method to run in multiple threads
Earlier we discussed how to run classes, methods, and tests in parallel or in multi-threaded mode. TestNG also provides the flexibility to configure a test method to be run in a multi-threaded environment. This is achieved by configuring it while using the @Test annotation on a method.
public class IndependentTest
{
@Test(threadPoolSize = 3, invocationCount = 6, timeOut = 1000)
public void testMethod()
{
Long id = Thread.currentThread().getId();
System.out.println("Test method executing on thread with id: " + id);
}
}
|
The method is configured to run in multi-threaded mode by using the threadPoolSize attribute along with the Test annotation. The value of the threadPoolSize is set to 3; this configures the test method to be run in three different threads. The other two attributes, invocationCount and timeOut, configures the test to be invoked a multiple number of times and fail if the execution takes more time.
Create a new file named independent-test-testng.xml under the project and write below code.
<suite name="Independent test Suite" >
<test name="Independent test">
<classes>
<class name="com.howtodoinjava.parallelism.IndependentTest" />
</classes>
</test>
</suite>
|
Select this file in Eclipse and run it as a TestNG suite. You will see the following test result in the Console window:
Test method executing on thread with id: 11
Test method executing on thread with id: 10
Test method executing on thread with id: 9
Test method executing on thread with id: 11
Test method executing on thread with id: 11
Test method executing on thread with id: 10
|
Here, test method is executed multiple times based on the invocationCount attribute value. Each execution is done in a separate thread that is clearly visible from the test report output. This feature is useful when you want to run only a fixed number of test methods in multi-threaded mode and not the whole test suite.
Happy Learning !!
