單篇長文TestNG從入門到精通

簡介

TestNG是Test Next Generation的縮寫，它的靈感來自於JUnit和NUnit，在它們基礎上增加了很多很牛的功能，比如說：

• 註解。
• 多線程，比如所有方法都在各自線程中，一個測試類一個線程等。
• 驗證代碼是否多線程安全。
• 靈活的測試配置。
• 支持數據驅動（@DataProvider）。
• 支持參數化。
• 強大的執行機制（不需要TestSuite）。
• 能跟各種工具結合（比如IDEA、Maven等）。
• 內嵌BeanShell。
• 提供運行時和日誌的JDK函數（不需要添加dependencies）。
• 提供應用服務器測試依賴的方法。

一句話總結就是，TestNG強大到能覆蓋所有測試類型：單元測試、功能測試、端到端測試、集成測試等等等。

一個簡單的示例如下：

package example1;
 
import org.testng.annotations.*;
 
public class SimpleTest {
 
 @BeforeClass
 public void setUp() {
   // code that will be invoked when this test is instantiated
 }
 
 @Test(groups = { "fast" })
 public void aFastTest() {
   System.out.println("Fast test");
 }
 
 @Test(groups = { "slow" })
 public void aSlowTest() {
    System.out.println("Slow test");
 }
 
}

• setUp()會在測試類創建後，測試方法執行前運行。
• 測試方法名字可以任意的，TestNG通過@Test註解來標識。
• 可以把測試方法按group分組。

然後使用xml來配置運行策略：

<project default="test">
 
 <path id="cp">
   <pathelement location="lib/testng-testng-5.13.1.jar"/>
   <pathelement location="build"/>
 </path>
 
 <taskdef name="testng" classpathref="cp"
          classname="org.testng.TestNGAntTask" />
 
 <target name="test">
   <testng classpathref="cp" groups="fast">
     <classfileset dir="build" includes="example1/*.class"/>
   </testng>
 </target>
 
</project>

使用ant調用（下面第2節給出了最新的運行方式）：

c:> ant
Buildfile: build.xml
 
test:
[testng] Fast test
[testng] ===============================================
[testng] Suite for Command line test
[testng] Total tests run: 1, Failures: 0, Skips: 0
[testng] ===============================================
 
 
BUILD SUCCESSFUL
Total time: 4 seconds

最後就能看報告了：

start test-output\index.html (on Windows)

如何運行TestNG

除了前面提到的ant調用，更常見的運行TestNG的方式是以下兩種：

1. IDEA
2. Maven

IDEA

在IDEA中運行TestNG第①種方式是點擊方法或類前面的小箭頭：

第②種方式是在方法或類內部點擊右鍵：

第③種方式是使用testng.xml，IDEA可以右鍵testng.xml來運行，在文件名和文件內部點擊均可：

testng.xml支持很多種配置，比如配置測試類：

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
  
<suite name="Suite1" verbose="1" >
  <test name="Nopackage" >
    <classes>
       <class name="NoPackageTest" />
    </classes>
  </test>
 
  <test name="Regression1">
    <classes>
      <class name="test.sample.ParameterSample"/>
      <class name="test.sample.ParameterTest"/>
    </classes>
  </test>
</suite>

配置測試包：

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 
<suite name="Suite1" verbose="1" >
  <test name="Regression1"   >
    <packages>
      <package name="test.sample" />
   </packages>
 </test>
</suite>

配置組和方法：

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 
<suite name="Suite1" verbose="1" >
  <test name="Regression1">
    <groups>
      <run>
        <exclude name="brokenTests"  />
        <include name="checkinTests"  />
      </run>
    </groups>

    <classes>
      <class name="test.IndividualMethodsTest">
        <methods>
          <include name="testMethod" />
        </methods>
      </class>
    </classes>
  </test>
</suite>

默認TestNG會按xml順序執行，可以設置 preserve-order爲false變成隨機順序：

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
 
<suite name="Suite1" verbose="1" >
  <test name="Regression1" preserve-order="false">
    <classes>

      <class name="test.Test1">
        <methods>
          <include name="m1" />
          <include name="m2" />
        </methods>
      </class>

      <class name="test.Test2" />

    </classes>
  </test>
</suite>

Maven

官方教程給出了命令行執行TestNG：

java org.testng.TestNG testng1.xml [testng2.xml testng3.xml ...]

實際調用是調不通的，可以藉助Maven來實現。

先在pom.xml添加：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.19.1</version>
            <configuration>
                <suiteXmlFiles>
                    <suiteXmlFile>testng.xml</suiteXmlFile>
                </suiteXmlFiles>
            </configuration>
        </plugin>
    </plugins>
</build>

然後執行mvn clean test命令就行啦。

測試方法和測試類

使用了@Test註解的方法就是測試方法，包含測試方法的類就是測試類。比如：

package example1;
 
import org.testng.annotations.*;
 
public class SimpleTest {
 
 @BeforeClass
 public void setUp() {
   // code that will be invoked when this test is instantiated
 }
 
 @Test(groups = { "fast" })
 public void aFastTest() {
   System.out.println("Fast test");
 }
 
 @Test(groups = { "slow" })
 public void aSlowTest() {
    System.out.println("Slow test");
 }
 
}

@Test也能放在測試類上面，這樣測試類下的所有方法都是測試方法，比如：

@Test
public class Test1 {
  public void test1() {
  }
 
  public void test2() {
  }
}

而且可以在測試類和測試方法上同時使用@Test，比如給某個Test加入分組：

@Test
public class Test1 {
  public void test1() {
  }
 
  @Test(groups = "g1")
  public void test2() {
  }
}

有個點需要注意的是@Test註解的測試方法，默認是會忽略返回值的，除非在testng.xml配置：

<suite allow-return-values="true">
 
or
 
<test allow-return-values="true">

測試組

測試組其實就是給測試方法打標記，比如冒煙測試用例和功能測試用例：

public class Test1 {
  @Test(groups = { "functest", "checkintest" })
  public void testMethod1() {
  }
 
  @Test(groups = {"functest", "checkintest"} )
  public void testMethod2() {
  }
 
  @Test(groups = { "functest" })
  public void testMethod3() {
  }
}

如果只配置functest，就會執行全部測試方法：

<test name="Test1">
  <groups>
    <run>
      <include name="functest"/>
    </run>
  </groups>
  <classes>
    <class name="example1.Test1"/>
  </classes>
</test>

如果只配置checkintest，就會只執行前面2個方法：

<test name="Test1">
  <groups>
    <run>
      <include name="checkintest"/>
    </run>
  </groups>
  <classes>
    <class name="example1.Test1"/>
  </classes>
</test>

除了指定完整name，也可以使用正則表達式：

@Test
public class Test1 {
  @Test(groups = { "windows.checkintest" })
  public void testWindowsOnly() {
  }
 
  @Test(groups = {"linux.checkintest"} )
  public void testLinuxOnly() {
  }
 
  @Test(groups = { "windows.functest" )
  public void testWindowsToo() {
  }
}

<test name="Test1">
  <groups>
    <run>
      <include name="windows.*"/>
    </run>
  </groups>
 
  <classes>
    <class name="example1.Test1"/>
  </classes>
</test>

進一步，測試組除了include測試方法，還可以exclude：

<test name="Test1">
  <classes>
    <class name="example1.Test1">
      <methods>
        <include name=".*enabledTestMethod.*"/>
        <exclude name=".*brokenTestMethod.*"/>
      </methods>
     </class>
  </classes>
</test>

還有一個辦法是使用@Test和@Before/After的enabled屬性。

測試組也能進行嵌套：

<test name="Regression1">
  <groups>
    <define name="functest">
      <include name="windows"/>
      <include name="linux"/>
    </define>
  
    <define name="all">
      <include name="functest"/>
      <include name="checkintest"/>
    </define>
  
    <run>
      <include name="all"/>
    </run>
  </groups>
  
  <classes>
    <class name="test.sample.Test1"/>
  </classes>
</test>

<define></define>定義了父分組，裏面<include>的就是子分組。

同樣的，嵌套分組也可以對子分組進行exclude：

@Test(groups = {"checkintest", "broken"} )
public void testMethod2() {
}

<test name="Simple example">
  <groups>
    <run>
      <include name="checkintest"/>
      <exclude name="broken"/>
    </run>
  </groups>
  
  <classes>
    <class name="example1.Test1"/>
  </classes>
</test>

最後，對於分組的位置，如果測試類和測試方法都標記了分組，那麼測試類的分組會作用到所有方法中，比如：

@Test(groups = {"checkin-test"})
public class All {
    @Test(groups = {"func-test")
    public void method1() { ...}

    public void method2() { ...}
}

method2()屬於checkin-test分組，method1屬於func-test和checkin-test兩個分組。

TestNG參數化

TestNG參數化有兩種方式，第一種是從testng.xml讀取數據，第二種是通過代碼讀取數據。

從testng.xml讀取數據

直接看示例：

@Parameters({ "first-name" })
@Test
public void testSingleString(String firstName) {
  System.out.println("Invoked testString " + firstName);
  assert "Cedric".equals(firstName);
}

<suite name="My suite">
  <parameter name="first-name"  value="Cedric"/>
  <test name="Simple example">
  <-- ... -->

• @Parameters指定參數化名字。

• 測試方法入參與參數化名字一一對應。

• testng.xml中<parameter>定義參數化的值。

  在testng.xml中，<parameter>既可以定義在<suite>中也可以定義在<test>中，如果有同名的，會以<test>的覆蓋<suite>。

@Parameters既可以作用到@Test，也可以作用到 @Before/After和@Factory，比如：

@Parameters({ "datasource", "jdbcDriver" })
@BeforeMethod
public void beforeTest(String ds, String driver) {
  m_dataSource = ...;                              // look up the value of datasource
  m_jdbcDriver = driver;
}

也可以作用到測試類的構造方法中，但是隻能最多一個構造方法，這樣就能在初始化類的時候，進行參數化賦值，便於測試方法使用

@Optional用於標識參數是否可選，比如：

@Parameters("db")
@Test
public void testNonExistentParameter(@Optional("mysql") String db) { ... }

• 如果db這個參數取不到名字，那麼就會取mysql的值。

通過代碼讀取數據

第一種參數化方式其實比較雞肋，第二種方式纔是TestNG參數化的靈魂，用到了@DataProvider，它會返回一個二維數組：

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

public class DPTest {
    @DataProvider(name = "test1")
    public Object[][] createData1() {
        return new Object[][] {
                { "Cedric", 36},
                { "Anne", 37},
        };
    }

    @Test(dataProvider = "test1")
    public void verifyData1(String n1, Integer n2) {
        System.out.println(n1 + " " + n2);
    }
}

• @DataProvider用於生產數據，name是唯一標識。
• 在@Test中通過dataProvider屬性指定name。
• 測試方法的入參跟數組中元素一一對應。

默認@DataProvider和@Test是在同一個類中，如果想放在不同的類，那麼需要定義爲靜態方法（或者無參數構造方法的類），比如：

import org.testng.annotations.DataProvider;

public class StaticProvider {
    @DataProvider(name = "create")
    public static Object[][] createData() {
        return new Object[][] {
                new Object[] {42}
        };
    }
}

import org.testng.annotations.Test;

public class DiffClazzTest {
    @Test(dataProvider = "create", dataProviderClass = StaticProvider.class)
    public void test(Integer n) {
        System.out.println(n);
    }
}

• createData()爲static。
• 需要額外通過@Test的dataProviderClass屬性指定@DataProvider所在的類。

@DataProvider的返回值（參數類型）除了已經提到的Object[][]，還可以是Iterator<Object[]>，它不會一次性生成所有數據，而是每調用一次生成一次，節約內存，比如：

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

import java.util.Arrays;
import java.util.Iterator;

public class IterTest {
    @DataProvider(name = "test1")
    public Iterator<Object[]> createData1() {
        Object[][] myObjects = new Object[][]{
                {"Cedric", 36},
                {"Anne", 37},
        };
        return Arrays.asList(myObjects).iterator();
    }

    @Test(dataProvider = "test1")
    public void verifyData1(String n1, Integer n2) {
        System.out.println(n1 + " " + n2);
    }
}

看到這裏，對@DataProvider已經有了足夠的認識，它支持兩種參數類型：

• Object[][]
• Iterator<Object[]>

假如測試方法只有一個入參，是不是隻能用二維來實現：

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

import java.util.Arrays;
import java.util.Iterator;

public class IterTest {
    @DataProvider(name = "test1")
    public Iterator<Object[]> createData1() {
        Object[][] myObjects = new Object[][]{{"x"}, {"y"}};
        return Arrays.asList(myObjects).iterator();
    }

    @Test(dataProvider = "test1")
    public void verifyData1(String n) {
        System.out.println(n);
    }
}

其實不是，@DataProvider支持一維數組：

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

public class IterTest {
    @DataProvider(name = "test1")
    public Object[] createData1() {
        Object[] myObjects = new Object[]{"x", "y"};
        return myObjects;
    }

    @Test(dataProvider = "test1")
    public void verifyData1(String n) {
        System.out.println(n);
    }
}

以及一維數組的迭代器：

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

import java.util.Arrays;
import java.util.Iterator;

public class IterTest {
    @DataProvider(name = "test1")
    public Iterator<Object> createData1() {
        Object[] myObjects = new Object[]{"x", "y"};
        return Arrays.asList(myObjects).iterator();
    }

    @Test(dataProvider = "test1")
    public void verifyData1(String n) {
        System.out.println(n);
    }
}

最精彩的來了，@DataProvider支持反射，也就是反向獲取測試方法的信息：

@DataProvider(name = "dp")
public Object[][] createData(Method m) {
  System.out.println(m.getName());  // print test method name
  return new Object[][] { new Object[] { "Cedric" }};
}
 
@Test(dataProvider = "dp")
public void test1(String s) {
}
 
@Test(dataProvider = "dp")
public void test2(String s) {
}

• createData的入參是java.lang.reflect.Method，這樣就能獲取到測試方法的信息，比如這裏的getName()會依次拿到test1、test2。

@DataProvider還支持併發：

@DataProvider(parallel = true)// ...

默認是10個線程，可以在testng.xml中修改：

<suite name="Suite1" data-provider-thread-count="20" >...

一個xml共享一個線程池，如果要用多個線程池，那麼需要創建多個testng.xml。

錦上添花的是，TestNG的參數化會打印在測試報告中：

指定用例執行順序

TestNG用例的執行順序有兩種方式來指定：註解和XML。

註解

使用@Test的dependsOnMethods屬性：

@Test
public void serverStartedOk() {}
 
@Test(dependsOnMethods = { "serverStartedOk" })
public void method1() {}

或者dependsOnGroups屬性：

@Test(groups = { "init" })
public void serverStartedOk() {}
 
@Test(groups = { "init" })
public void initEnvironment() {}
 
@Test(dependsOnGroups = { "init.*" })
public void method1() {}

@Before/After也能實現初始化，但是它們的結果不會出現在測試報告中。

默認TestNG會強制校驗，依賴的用例必須成功纔會執行當前用例，否則當前用例會被標記爲SKIP，這叫做強依賴。通過設置alwaysRun=true可以變成弱依賴，無論依賴用例執行成功與否，都會執行當前用例。

需要特別注意的是，依賴測試方法是按照測試類來進行執行的（group by class），比如b()方法依賴的a()方法有多個實例，那麼會按照以下順序執行:

a(1)
a(2)
b(2)
b(2)

舉個實際的例子，登入和登出，如果想達到以下效果：

signIn("us")
signOut("us")
signIn("uk")
signOut("uk")

那麼需要在XML中進行配置：

  <suite name="Factory" group-by-instances="true">
or
  <test name="Factory" group-by-instances="true">

XML

在testng.xml中使用<dependencies>和depends-on來指定用例順序：

<test name="My suite">
  <groups>
    <dependencies>
      <group name="c" depends-on="a  b" />
      <group name="z" depends-on="c" />
    </dependencies>
  </groups>
</test>

動態創建測試用例

假設有這樣的測試用例，在測試時需要對網頁訪問多次，那麼在TestNG中會這樣編寫代碼：

public class TestWebServer {
  @Test(parameters = { "number-of-times" })
  public void accessPage(int numberOfTimes) {
    while (numberOfTimes-- > 0) {
     // access the web page
    }
  }
}

<test name="T1">
  <parameter name="number-of-times" value="10"/>
  <classes>
    <class name= "TestWebServer" />
  </classes>
</test>
 
<test name="T2">
  <parameter name="number-of-times" value="20"/>
  <classes>
    <class name= "TestWebServer"/>
  </classes>
</test>
 
<test name="T3">
  <parameter name="number-of-times" value="30"/>
  <classes>
    <class name= "TestWebServer"/>
  </classes>
</test>

• 由於訪問次數不一，在testng.xml中定義了3個test，然後藉助參數化將訪問次數傳給@Test測試方法。
• 在@Test測試方法中循環遍歷numberOfTimes。

這種需求可以採用TestNG的Factory來對代碼進行簡化：

import org.testng.annotations.Factory;

public class WebTestFactory {
    @Factory
    public Object[] createInstances() {
        Object[] result = new Object[3];
        for (int i = 0; i <= 2; i++) {
            result[i] = new WebTest((i + 1) * 10);
        }
        return result;
    }
}

import org.testng.annotations.Test;

public class WebTest {
    private int m_numberOfTimes;

    public WebTest(int numberOfTimes) {
        m_numberOfTimes = numberOfTimes;
    }

    @Test
    public void testServer() {
        for (int i = 0; i < m_numberOfTimes; i++) {
            // access the web page
            System.out.println(i);
        }
    }
}

• WebTestFactory是工廠函數，返回Object[]。
• WebTestFactory動態創建了多個WebTest實例。

既可以在IDEA中點擊WebTestFactory的運行按鈕執行測試：

注意如果執行WebTest，會提示No tests were found。

也可以在testng.xml中驅動：

<class name="WebTestFactory" />

還可以直接在代碼中驅動：

TestNG testNG = new TestNG();
testNG.setTestClasses(WebTestFactory.class);
testNG.run();

@Factory和@Test一樣，都能使用dataProvider屬性，比如：

@Factory(dataProvider = "dp")
public FactoryDataProviderSampleTest(int n) {
  super(n);
}
 
@DataProvider
static public Object[][] dp() {
  return new Object[][] {
    new Object[] { 41 },
    new Object[] { 42 },
  };
}

忽略部分測試用例

TestNG可以使用@Ignore註解忽略測試，比如：

import org.testng.annotations.Ignore;
import org.testng.annotations.Test;
 
@Ignore
public class TestcaseSample {
 
    @Test
    public void testMethod1() {
    }
 
    @Test
    public void testMethod2() {
    }
}

如果作用到測試類上，那麼它會忽略這個類下面的所有測試方法。如果只作用到測試方法上，那麼它就相當於@Test(enabled=false)。另外還能放在包上面：

@Ignore
package com.testng.master;
 
import org.testng.annotations.Ignore;

多線程並行測試用例

可以給@Test添加屬性，讓用例以多線程並行執行：

@Test(threadPoolSize = 3, invocationCount = 10,  timeOut = 10000)
public void testServer() {

• threadPoolSize指3個線程。
• invocationCount指運行10次。
• timeOut指阻塞等待超時。

也可以在testng.xml中設置，thread-count指定線程數，parallel設置不同的值有不同的含義：

methods：

<suite name="My suite" parallel="methods" thread-count="5">

所有測試方法在不同的獨立線程中執行。

tests：

<suite name="My suite" parallel="tests" thread-count="5">

<test>標籤內的測試方法會在同一個線程中執行，不同的<test>標籤會在不同的獨立線程中執行。

classes：

<suite name="My suite" parallel="classes" thread-count="5">

同一個類中的測試方法會在同一個線程中執行，不同的類會在不同的獨立線程中執行。

instances：

<suite name="My suite" parallel="instances" thread-count="5">

同一個實例中的測試方法會在同一個線程中執行，不同的實例會在不同的獨立線程中執行。（Factory能創建多個實例）

重跑失敗用例

TestNG在運行後會把失敗的用例輸出到testng-failed.xml文件中，可以直接運行這個文件來重跑失敗用例。

誇一句，這個設計真棒。

有時候，需要讓用例失敗時自動重試，那麼可以在代碼中這樣實現：

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;
 
public class MyRetry implements IRetryAnalyzer {
 
  private int retryCount = 0;
  private static final int maxRetryCount = 3;
 
  @Override
  public boolean retry(ITestResult result) {
    if (retryCount < maxRetryCount) {
      retryCount++;
      return true;
    }
    return false;
  }
}

import org.testng.Assert;
import org.testng.annotations.Test;
 
public class TestclassSample {
 
  @Test(retryAnalyzer = MyRetry.class)
  public void test2() {
    Assert.fail();
  }
}

• 實現IRetryAnalyzer接口的retry方法。
• 在@Test的retryAnalyzer中指定重試類。

TestNG編程

除了IDEA和Maven這兩種運行方式，TestNG還可以直接在程序中調用運行：

TestListenerAdapter tla = new TestListenerAdapter();
TestNG testng = new TestNG();
testng.setTestClasses(new Class[] { Run2.class });
testng.addListener(tla);
testng.run();

• TestListenerAdapter是默認的，可以實現org.testng.ITestListener接口自定義TestListener。
• setTestClasses添加測試類。
• run()運行。

還可以通過編程創建一個虛擬的testng.xml，org.testng.xml包的XmlClass, XmlTest等提供了這個能力：

XmlSuite suite = new XmlSuite();
suite.setName("TmpSuite");
 
XmlTest test = new XmlTest(suite);
test.setName("TmpTest");
List<XmlClass> classes = new ArrayList<XmlClass>();
classes.add(new XmlClass("test.failures.Child"));
test.setXmlClasses(classes) ;

這段代碼會創建一個這樣的testng.xml：

<suite name="TmpSuite" >
  <test name="TmpTest" >
    <classes>
      <class name="test.failures.Child"  />
    <classes>
    </test>
</suite>

XmlSuite可以通過TestNG程序調用：

List<XmlSuite> suites = new ArrayList<XmlSuite>();
suites.add(suite);
TestNG tng = new TestNG();
tng.setXmlSuites(suites);
tng.run();

XML中寫BeanShell

是的，TestNG的XML中可以寫BeanShell，用來替代<include>和<exclude>：

<test name="BeanShell test">
   <method-selectors>
     <method-selector>
       <script language="beanshell"><![CDATA[
         groups.containsKey("test1")
       ]]></script>
     </method-selector>
   </method-selectors>
  <!-- ... -->

• CDATA用來防止跟XML標籤語法衝突。
• 預置了method（當前測試方法）、testngMethod（當前測試方法的描述）、groups（當前測試方法所屬分組）三個對象，可以用來做匹配。
• 使用<script>後，<include>和<exclude>會失效。

Listener

TestNG提供了很多Listener用來自定義TestNG行爲，類似於Hook那個意思：

• IAnnotationTransformer
• IAnnotationTransformer2
• IHookable
• IInvokedMethodListener
• IMethodInterceptor
• IReporter
• ISuiteListener
• ITestListener
• ITestNGListener
• IAlterSuiteListener

比如用IAnnotationTransformer動態設置@Test屬性：

public class MyTransformer implements IAnnotationTransformer {
  public void transform(ITest annotation, Class testClass,
      Constructor testConstructor, Method testMethod)
  {
    if ("invoke".equals(testMethod.getName())) {
      annotation.setInvocationCount(5);
    }
  }
}

如果想修改@Factory或@DataProvider，得用IAnnotationTransformer2。

比如用IMethodInterceptor設定用例組的執行順序：

public List<IMethodInstance> intercept(List<IMethodInstance> methods, ITestContext context) {
  List<IMethodInstance> result = new ArrayList<IMethodInstance>();
  for (IMethodInstance m : methods) {
    Test test = m.getMethod().getConstructorOrMethod().getAnnotation(Test.class);
    Set<String> groups = new HashSet<String>();
    for (String group : test.groups()) {
      groups.add(group);
    }
    //讓fast分組第一個執行
    if (groups.contains("fast")) {
      result.add(0, m);
    }
    else {
      result.add(m);
    }
  }
  return result;
}

比如想自定義測試開始前和測試後的行爲，可以先寫個Listener：

public class BeforeAfterLog extends TestListenerAdapter {
 		public void onTestSuccess(ITestResult result) {
        System.out.println("onTestSuccess");
    }

    public void onTestFailure(ITestResult result) {
        System.out.println("onTestFailure");
    }
}

然後在測試類上添加：

@Listeners(BeforeAfterLog.class)
public class MyTest {
}

這樣就不用每個測試類都寫@BeforeClass和@AfterClass了。

依賴注入

TestNG支持在測試方法中添加特定類來進行依賴注入（就是獲取TestNG相關信息）：

• ITestContext
• XmlTest 當前<test>標籤
• Method 當前調用的測試方法
• Object[] 當前測試方法的入參
• ITestResult 當前測試結果

不同註解支持的方式如下表所示：

示例：

public class NoInjectionTest {
 
  @DataProvider(name = "provider")
  public Object[][] provide() throws Exception {
      return new Object[][] { { CC.class.getMethod("f") } };
  }
 
  @Test(dataProvider = "provider")
  public void withoutInjection(@NoInjection Method m) {
      Assert.assertEquals(m.getName(), "f");
  }
 
  @Test(dataProvider = "provider")
  public void withInjection(Method m) {
      Assert.assertEquals(m.getName(), "withInjection");
  }
}

@NoInjection用於禁止依賴注入。

斷言

TestNG支持Java的assert關鍵字斷言，示例：

@Test
public void verifyLastName() {
  assert "Beust".equals(m_lastName) : "Expected name Beust, for" + m_lastName;
}

也可以用JUnit斷言方法：

import static org.testng.AssertJUnit.*;
//...
@Test
public void verify() {
  assertEquals("Beust", m_lastName);
}

日誌

用Listener來實現，直接看代碼：

public class DotTestListener extends TestListenerAdapter {
  private int m_count = 0;
 
  @Override
  public void onTestFailure(ITestResult tr) {
    log("F");
  }
 
  @Override
  public void onTestSkipped(ITestResult tr) {
    log("S");
  }
 
  @Override
  public void onTestSuccess(ITestResult tr) {
    log(".");
  }
 
  private void log(String string) {
    System.out.print(string);
    if (++m_count % 40 == 0) {
      System.out.println("");
    }
  }
}

測試報告

TestNG自帶了一個測試報告，運行完後會生成index.html，打開就是，比較醜，推薦用Allure。

如果想獲取測試報告的數據，那麼可以從org.testng.IReporter接口的方法：

public void generateReport(List<ISuite> suites, String outputDirectory)

根據它的入參去拿。

如果想給測試報告添加數據，那麼可以使用org.testng.Reporter類：

Reporter.log("M3 WAS CALLED");

YAML替代XML

如果你煩透了XML，那麼可以試試YAML。

比如XML：

<suite name="SingleSuite" verbose="2" thread-count="4">
 
  <parameter name="n" value="42" />
 
  <test name="Regression2">
    <groups>
      <run>
        <exclude name="broken" />
      </run>
    </groups>
 
    <classes>
      <class name="test.listeners.ResultEndMillisTest" />
    </classes>
  </test>
</suite>

換成YAML：

name: SingleSuite
threadCount: 4
parameters: { n: 42 }
 
tests:
  - name: Regression2
    parameters: { count: 10 }
    excludedGroups: [ broken ]
    classes:
      - test.listeners.ResultEndMillisTest

舒服多了。不過TestNG本身沒有引入YAML依賴包，需要自己添加：

<dependency>
  <groupid>org.yaml</groupid>
  <artifactid>snakeyaml</artifactid>
  <version>1.23</version>
</dependency>

彩蛋

看完了官方教程，感覺測試框架的功能基本上大同小異，只是技術實現上有所區別。讓我驚喜的是，TestNG運行失敗的用例可以自動生成一份失敗用例的xml文件，直接拿來重跑就可以了。還有一直以爲TestNG只能用XML，沒想到也能用YAML了。最後，它給出了-Dtestng.mode.dryrun=true這個參數，猜猜它是幹嘛的。有時候只想看跑起來會執行哪些測試，而不想真正執行，那麼就可以用這個參數。

參考資料：

https://testng.org/doc/

https://testng.org/doc/documentation-main.html