Introduction to TestNG – TestNG简介

最后修改: 2017年 3月 28日


1. Overview


In this article, we’ll introduce the TestNG testing framework.


We’ll focus on: framework setup, writing simple test case and configuration, test execution, test reports generation, and concurrent test execution.


2. Setup


Let’s start by adding the Maven dependency in our pom.xml file:



The latest version can be found in the Maven repository.


When using Eclipse, the TestNG plugin may be downloaded and installed from the Eclipse Marketplace.

当使用Eclipse时,TestNG插件可以从Eclipse Marketplace下载和安装。

3. Writing a Test Case


To write a test using TestNG, we just need to annotate the test method with org.testng.annotations.Test annotation:


public void givenNumber_whenEven_thenTrue() {
    assertTrue(number % 2 == 0);

4. Test Configurations


While writing test cases, often we need to execute some configuration or initialization instructions before test executions, and also some cleanup after completion of tests. TestNG provides a number of initialization and clean-up features at method, class, group and suite levels:


public void setup() {
    number = 12;

public void tearDown() {
    number = 0;

The setup() method annotated with @BeforeClass annotations will be invoked before execution of any methods of that test class, and tearDown() after execution all methods of the test class.


Similarly, we can use the @BeforeMethod, @AfterMethod, @Before/AfterGroup, @Before/AfterTest and @Before/AfterSuite annotations for any configuration at method, group, test and suite levels.

同样地,我们可以使用@BeforeMethod, @AfterMethod, @Before/AfterGroup, @Before/AfterTest @Before/AfterSuite 注解,用于方法、组、测试和套件级别的任何配置。

5. Test Execution


We can run the test cases with Maven’s “test” command, it will execute all the test cases annotated with @Test putting them to a default test suite. We can also run test cases from the TestNG test suite XML files, by using the maven-surefire-plugin:

我们可以用Maven的 “test “命令运行测试用例,它将执行所有带@Test注释的测试用例,并将其放入默认的测试套件。我们还可以通过使用maven-surefire-plugin来运行TestNG测试套件XML文件的测试用例:


Note that if we have multiple XML files, covering all test cases, we can add all of them in the suiteXmlFiles tag:



In order to run the test standalone, we need to have the TestNG library in the classpath and the compiled test class along with the XML configuration file:


java org.testng.TestNG test_suite.xml

6. Grouping Tests


Tests can be run in groups, for example out of 50 test cases 15 can be grouped together and executed leaving others as is.


In TestNG grouping tests in suites are done using XML file:


<suite name="suite">
    <test name="test suite">
            <class name="com.baeldung.RegistrationTest" />
            <class name="com.baeldung.SignInTest" />

Notice that, both the test classes RegistrationTest, SignInTest now belongs to the same suite and once suite is executed, test cases in this class will get executed.

注意,两个测试类RegistrationTest, SignInTest现在都属于同一个套件,一旦套件被执行,这个类的测试用例就会被执行。

Apart from test suites, we can also create test groups in TestNG, where instead of test classes methods are grouped together. In order to do that, add the groups parameter in the @Test annotation:


@Test(groups = "regression")
public void givenNegativeNumber_sumLessthanZero_thenCorrect() {
    int sum =, Integer::sum);
    assertTrue(sum < 0);

Let’s use an XML to execute the groups:


<test name="test groups">
            <include name="regression" />
          name="com.baeldung.SummationServiceTest" />

This will execute the test method tagged with group regression, in the SummationServiceTest class.

这将执行SummationServiceTest类中标记为regression, 组的测试方法。

7. Parameterized Tests


Parameterized unit tests are used for testing the same code under several conditions. With the help of parameterized unit tests, we can set up a test method that obtains data from some data source. The main idea is to make the unit test method reusable and to test with a different set of inputs.


In TestNG, we can parametrize tests using @Parameter or @DataProvider annotation. While using the XML file annotate the test method with @Parameter:


@Parameters({"value", "isEven"})
public void
  givenNumberFromXML_ifEvenCheckOK_thenCorrect(int value, boolean isEven) {
    assertEquals(isEven, value % 2 == 0);
And provide the data using XML file:
<suite name="My test suite">
    <test name="numbersXML">
        <parameter name="value" value="1"/>
        <parameter name="isEven" value="false"/>
            <class name=""/>

Using data from XML file is useful, but we often need more complex data. @DataProvider annotation is used to handle these scenarios, which can be used to map complex parameter types for testing methods.@DataProvider for primitive data types:


@DataProvider(name = "numbers")
public static Object[][] evenNumbers() {
    return new Object[][]{{1, false}, {2, true}, {4, true}};
@Test(dataProvider = "numbers")
public void 
  givenNumberFromDataProvider_ifEvenCheckOK_thenCorrect(Integer number, boolean expected) {    
    assertEquals(expected, number % 2 == 0);

@DataProviderfor objects:


@Test(dataProvider = "numbersObject")
public void 
  givenNumberObjectFromDataProvider_ifEvenCheckOK_thenCorrect(EvenNumber number) {  
    assertEquals(number.isEven(), number.getValue() % 2 == 0);
@DataProvider(name = "numbersObject")
public Object[][] parameterProvider() {
    return new Object[][]{{new EvenNumber(1, false)},
      {new EvenNumber(2, true)}, {new EvenNumber(4, true)}};

Using this, any object that has to be tested can be created and used in the test. This is mostly useful for integration test cases.


8. Ignoring Test Cases


We sometimes want not to execute a certain test case, temporarily during the development process. This can be done adding enabled=false, in the @Test annotation:

我们有时希望在开发过程中暂时不执行某个测试案例。这可以在@Test 注解中添加enabled=false,来实现。

public void givenNumbers_sumEquals_thenCorrect() { 
    int sum =, Integer::sum);
    assertEquals(6, sum);

9. Dependent Tests


Let’s consider a scenario, where if the initial test case fails, all subsequent test cases should be executed, and rather be marked as skipped. TestNG provides this feature with the dependsOnMethods parameter of the @Test annotation:


public void givenEmail_ifValid_thenTrue() {
    boolean valid = email.contains("@");
    assertEquals(valid, true);
@Test(dependsOnMethods = {"givenEmail_ifValid_thenTrue"})
public void givenValidEmail_whenLoggedIn_thenTrue() {"Email {} valid >> logging in", email);

Notice that, the login test case depends on the email validation test case. Thus, if email validation fails the login test will be skipped.


10. Concurrent Test Execution


TestNG allows tests to run in parallel or in multi-threaded mode, thus providing a way to test these multi-threaded pieces of code.


You can configure, for methods, classes, and suites to run in their own threads reducing the total execution time.


10.1. Classes and Methods in Parallel


To run test classes in parallel, mention the parallel attribute in the suite tag in XML configuration file, with value classes:


<suite name="suite" parallel="classes" thread-count="2">
    <test name="test suite">
	    <class name="" />
            <class name="" />

Note that, if we have multiple test tags in the XML file, these tests can also be run in parallel, by mentioning parallel =” tests”. Also to execute individual methods in parallel, mention parallel =” methods”.

请注意,如果我们在XML文件中有多个test tag,这些测试也可以并行运行,只要提到parallel =” tests”。同样,如果要并行执行单个方法,请提及parallel =” methods”.

10.2. Multi-Threaded Execution of Test Method


Let’s say we need to test the behavior of a code when running in multiple threads. TestNG allows to run a test method in multiple threads:


public class MultiThreadedTests {
    @Test(threadPoolSize = 5, invocationCount = 10, timeOut = 1000)
    public void givenMethod_whenRunInThreads_thenCorrect() {
        int count = Thread.activeCount();
        assertTrue(count > 1);

The threadPoolSize indicates that the method will run in n number of threads as mentioned. The invocationCount and timeOut indicate that the test will be executed multiple times and fail the test if it takes more time.


11. Functional Testing


TestNG comes with features which can be used for functional testing as well. In conjunction with Selenium, it can either be used to test functionalities of a web application or used for testing web services with HttpClient.


More details about functional testing with Selenium and TestNG is available here. Also some more pieces of stuff on integration testing in this article.


12. Conclusion


In this article, we had a quick look at how to setup TestNG and execute a simple test case, generate reports, concurrent execution of test cases and also a little about functional programming. For more features like dependent tests, ignoring test cases, test groups and suites you can refer our JUnit vs TestNG article here.

在这篇文章中,我们快速了解了如何设置TestNG并执行一个简单的测试用例,生成报告,测试用例的并发执行,以及关于函数式编程的一些情况。关于更多的功能,如依赖测试、忽略测试用例、测试组和套件,你可以参考我们的JUnit vs TestNG文章这里

The implementation of all the code snippets can be found over on Github.