Testng的简介和使用

TestNG是Java中的一个测试框架，是一个目前很流行实用的单元测试框架，有完善的用例管理模块，配合Maven能够很方便管理依赖第三方插件。使用TestNG可以做功能、接口、单元、集成的自动化测试，最常见的是结合selenium做功能自动化测试，它使用Java注释去写测试方法。

1.适合测试人员使用的原因：

比Junit涵盖功能更加全面的测试框架
Junit更适合隔离性比较强的单元测试
TestNG更适合复杂的集成测试
使用注解，比较方便

编写一个测试的过程包含以下步骤：

编写测试的业务逻辑并在代码中插入TestNG annotation；
将测试信息添加到testng.xml文件或build.xml中；
运行TestNG。

2. TestNG基本注解

@Test 标记为一个测试方法
@BeforeTest @AfterTest
@BeforeMethod @AfterMethod
ddd
gggg
8888

TestNG是一个java中的开源自动化测试框架，其灵感来自JUnit和NUnit，TestNG还涵盖了JUnit4整个核心的功能，但引入了一些新的功能，使其功能更强大，使用更方便。

优势：支持依赖测试方法，并行测试，负载测试，局部故障，灵活的插件API，支持多线程测试。详细使用说明请参考官方链接：TestNG官方文档。

1. TestNG使用流程
1.1TestNG安装
本文以IDEA+Maven为例介绍TestNG，IntelliJ IDEA版本为IntelliJ IDEA 2020.1.1 (Ultimate Edition)。

IntelliJ IDEA中默认集成了TestNG，点击File->Settings，如下图：

1.2 创建Maven项目
点击File->new-Project，如图

创建基于Maven的项目

创建名字为MavenTest的项目，创建完成后如下图

1.3 Maven配置
在工程的pom.xml中需要添加如下依赖：

<?xml version=”1.0″ encoding=”UTF-8″?>
<project xmlns=”http://maven.apache.org/POM/4.0.0″
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
<modelVersion>4.0.0</modelVersion>

<groupId>org.example</groupId>
<artifactId>MavenTest</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.10</version>
</dependency>
</dependencies>
</project>
1.4 项目TestNG测试类
点击类名Test，按alt+entet键，创建单元测试类

点击Create Test

OK，生成测试类

1.5 运行TestNG
添加一个测试方法，如下

运行结果如下：

2、TestNG常用注解
有必要介绍一下TestNG注解的生命周期，先看一下官网支持的注解有：

注解   描述
@BeforeSuite   在该套件的所有测试运行之前运行，仅运行一次
@AfterSuite   在该套件的所有测试运行之后运行，仅运行一次
@BeforeTest   注释的方法将在属于test标签内的所有类的所有测试方法运行之前运行，一个test标签内可能有多个class（类），在当前test标签内仅运行一次
@AfterTest   注释的方法将在属于test标签内的所有类的所有测试方法运行之后运行，一个test标签内可能有多个class（类），在当前test标签内仅运行一次
@BeforeClass   在调用当前类的第一个测试方法之前运行，在当前类中仅运行一次
@AfterClass   在调用当前类的第一个测试方法之后运行，在当前类中仅运行一次
@BeforeGroups   配置方法将在组列表运行之前运行。此方法保证在调用属于这些组中的任何第一个测试方法之前不久运行
@AfterGroups   此配置方法将在组列表运行之后运行。该方法保证在调用属于这些组的任何最后一个测试方法之后不久运行
@BeforeMethod   注释方法将在当前类中的每个测试方法之前运行
@AfterMethod   注释方法将在当前类中的每个测试方法之后运行
@Parameters   描述如何将参数传递给@Test方法
@DataProvider   标记一种方法来提供测试方法的数据。注释方法必须返回一个Object [] []，其中每个Object []可以被分配给测试方法的参数列表。要从该DataProvider接收数据的@Test方法需要使用与此注释名称相等的dataProvider名称
@Listeners   定义测试类上的侦听器
@Factory   将一个方法标记为工厂，返回TestNG将被用作测试类的对象。该方法必须返回Object []
@Test   将类或方法标记为测试的一部分，此标记若放在类上，则该类所有公共方法都将被作为测试方法
如上列表中的@Factory、@Linsteners这两个是不常用的；
前十个注解看起来不太容易区分，顺序不太容易看明白，以如下范例做简单说明，代码：

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

public class NewTest {

@Test(groups=”group1″)
public void test1() {
   System.out.println(“test1 from group1”);
   Assert.assertTrue(true);
}

@Test(groups=”group1″)
public void test11() {
   System.out.println(“test11 from group1”);
   Assert.assertTrue(true);
}

@Test(groups=”group2″)
public void test2()
{
   System.out.println(“test2 from group2”);
   Assert.assertTrue(true);
}

@BeforeTest
public void beforeTest()
{
   System.out.println(“beforeTest”);
}

@AfterTest
public void afterTest()
{
   System.out.println(“afterTest”);
}

@BeforeClass
public void beforeClass()
{
   System.out.println(“beforeClass”);
}

@AfterClass
public void afterClass()
{
   System.out.println(“afterClass”);
}

@BeforeSuite
public void beforeSuite()
{
   System.out.println(“beforeSuite”);
}

@AfterSuite
public void afterSuite()
{
   System.out.println(“afterSuite”);
}

//只对group1有效，即test1和test11
@BeforeGroups(groups=”group1″)
public void beforeGroups()
{
   System.out.println(“beforeGroups”);
}

//只对group1有效，即test1和test11
@AfterGroups(groups=”group1″)
public void afterGroups()
{
   System.out.println(“afterGroups”);
}

@BeforeMethod
public void beforeMethod()
{
   System.out.println(“beforeMethod”);
}

@AfterMethod
public void afterMethod()
{
   System.out.println(“afterMethod”);
}
}
运行结果如下：

beforeSuite
beforeTest
beforeClass
beforeGroups
beforeMethod
test1 from group1
afterMethod
beforeMethod
test11 from group1
afterMethod
afterGroups
beforeMethod
test2 from group2
afterMethod
afterClass
afterTest
PASSED: test1
PASSED: test11
PASSED: test2

===============================================
Default test
Tests run: 3, Failures: 0, Skips: 0
===============================================

afterSuite
由此可见，testng运行时，顺序是这样的：

@BeforeSuite->@BeforeTest->@BeforeClass->{@BeforeGroups[@BeforeMethod->@Test1->@AfterMethod，@BeforeMethod->@Test2->@AfterMethod, …]@AfterGroups, @BeforeGroups[@BeforeMethod->@Test3->@AfterMethod，@BeforeMethod->@Test4->@AfterMethod, …]@AfterGroups, …}->@AfterClass->@AfterTest->@AfterSuite

其中{}内将@BeforeGroups@AfterGroups将@Test分组，每个分组内包含多个@Test。

3.xml方式运行
TestNG也可以以xml的方式运行

<suite> 套件，根标签，通常由几个<test组成>
属性：
　　name 套件的名称，必须属性；
　　verbose 运行的级别或详细程度；
　　parallel 是否运行多线程来运行这个套件；
　　thread-count 如果启用多线程，用于指定开户的线程数；
　　annotations 在测试中使用的注释类型；
　　time-out 在本测试中的所有测试方法上使用的默认超时时间；
<test> 　　测试用例，name为必须属性；
<classes> 用例中包含的类，子标签为<class name=”className”>;
<class> 测试类，其中属性name为必须属性；;
<packages> 用例中包含的包，包中所有的方法都会执行，子标签为<package name=”packageName”>;
<package> 测试包，name为必须属性；
<methods> 指定测试类中包含或排除的方法，子类为<include>,<exclude>;
<include> 指定需要测试的方法，name为必须属性；
<exclude> 指定类中不需要测试的方法，name为必须属性；
<groups> 指定测试用例中要运行或排除运行的分组，子标签为<run>,<run>下包含<include>,<exclude>标签，<include>,<exclude>的name指定运行、不运行的分组；
在项目下新建一个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>

3.1 鼠标右击testng.xml运行
TestTest3的代码如下：

import org.testng.Assert;
import org.testng.annotations.Test;
import org.testng.annotations.*;

public class TestTest3 {

@Test(groups = “group1”)
public void testC03() {
System.out.println(“testC03”);
Assert.assertTrue(true);
}

@Test(groups = “group1”)
public void testC04() {
System.out.println(“testC04”);
Assert.assertTrue(true);
}

@Test(groups = “group2”)
public void testC05() {
System.out.println(“testC05”);
Assert.assertTrue(true);
}

@BeforeTest
public void beforeTest() {
System.out.println(“beforeTest”);
}

@AfterTest
public void afterTest() {
System.out.println(“afterTest”);
}

@BeforeClass
public void beforeClass() {
System.out.println(“beforeClass”);
}

@AfterClass
public void afterClass() {
System.out.println(“afterClass”);
}

@BeforeSuite
public void beforeSuite() {
System.out.println(“beforeSuite”);
}

@AfterSuite
public void afterSuite() {
System.out.println(“afterSuite”);
}

@BeforeGroups(groups = {“group1”, “group2”})
public void beforeGroups() {
System.out.println(“beforeGroups”);
}

@AfterGroups(groups = {“group1”, “group2”})
public void afterGroups() {
System.out.println(“afterGroups”);
}

@BeforeMethod
public void beforeMethod() {
System.out.println(“beforeMethod”);
}

@AfterMethod
public void afterMethod() {
System.out.println(“afterMethod”);
}
}
TestTest4的代码如下：

import org.testng.Assert;
import org.testng.annotations.Test;
import org.testng.annotations.*;

public class TestTest4 {

@Test(groups = “group1”)
public void testD03() {
System.out.println(“testD03”);
Assert.assertTrue(true);
}

@Test(groups = “group1”)
public void testD04() {
System.out.println(“testD04”);
Assert.assertTrue(true);
}

@Test(groups = “group2”)
public void testD05() {
System.out.println(“testD05”);
Assert.assertTrue(true);
}

@BeforeTest
public void beforeTest() {
System.out.println(“beforeTest”);
}

@AfterTest
public void afterTest() {
System.out.println(“afterTest”);
}

@BeforeClass
public void beforeClass() {
System.out.println(“beforeClass”);
}

@AfterClass
public void afterClass() {
System.out.println(“afterClass”);
}

@BeforeGroups(groups = “group1”)
public void beforeGroups() {
System.out.println(“beforeGroups”);
}

@AfterGroups(groups = “group1”)
public void afterGroups() {
System.out.println(“afterGroups”);
}

@BeforeMethod
public void beforeMethod() {
System.out.println(“beforeMethod”);
}

@AfterMethod
public void afterMethod() {
System.out.println(“afterMethod”);
}
}
修改testng.xml的内容如下：

<!DOCTYPE suite SYSTEM “http://testng.org/testng-1.0.dtd” >

<suite name=”Suite” parallel=”none”>
<test name=”Test”>
<!– <groups>–>
<!– <run>–>
<!– <include name=”group1″/>–>
<!– </run>–>
<!– </groups>–>

<classes>
<class name=”TestTest3″/>
</classes>

</test> <!– Test –>

<test name=”Test2″>
<classes>
<class name=”TestTest4″/>
</classes>
</test> <!– Test –>

</suite> <!– Suite –>
鼠标右键testng.xml文件，运行结果如下：

[TestNG] Running:
C:\Users\HP\IdeaProjects\MavenTest\testng.xml

beforeSuite

beforeTest

beforeClass

beforeGroups

beforeMethod

testC03

afterMethod

beforeMethod

testC04

afterMethod

afterGroups

beforeGroups

beforeMethod

testC05

afterMethod

afterGroups

afterClass

afterTest

beforeTest

beforeClass

beforeGroups

beforeMethod

testD03

afterMethod

beforeMethod

testD04

afterMethod

afterGroups

beforeMethod

testD05

afterMethod

afterClass

afterTest

afterSuite

===============================================
Suite
Total tests run: 6, Failures: 0, Skips: 0
===============================================

Process finished with exit code 0
3.1 使用maven运行
需要在pom文件中，指明testng.xml文件的位置。

maven使用surefire这个插件进行测试，可以执行testng或者Junit脚本。

语法为 <suiteXmlFile>src/test/resources/testNGFilesFolder/${testNgFileName}.xml</suiteXmlFile>

<dependencies>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.8</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19</version>
<configuration>
<suiteXmlFiles>
<suiteXmlFile>testng.xml</suiteXmlFile>//该文件位于工程根目录时，直接填写名字，其它位置要加上路径。
</suiteXmlFiles>
</configuration>
</plugin>
</plugins>
</build>
运行测试脚本

进入到项目工程的根目录，使用 mvn clean test -Dtestng.xml 命令。

4. 常用的断言（assert）
assertEqual ([String message], expected value, actual value) 断言两个值相等。值可能是类型有 int, short, long, byte, char or java.lang.Object. 第一个参数是一个可选的字符串消息;
assertTrue([String message], boolean condition) 　　　　　　　断言一个条件为真;
assertFalse([String message],boolean condition) 　　　　　　　　　　断言一个条件为假;
assertNotNull([String message], java.lang.Object object) 　断言一个对象不为空(null);
assertNull([String message], java.lang.Object object) 　　　　断言一个对象为空(null);
assertSame([String message], java.lang.Object expected, java.lang.Object actual) 　　　断言两个对象引用相同的对象;
assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual) 断言两个对象不是引用同一个对象;
assertArrayEquals([String message], expectedArray, resultArray) 　　　　　　　　　　　　断言预期数组和结果数组相等。数组的类型可能是 int, long, short, char, byte or java.lang.Object.;
5. TestNG预期异常测试
预期异常测试通过在@Test注解后加入预期的Exception来进行添加，范例如下所示：

@Test(expectedExceptions = ArithmeticException.class)
public void divisionWithException() {
int i = 1 / 0;
System.out.println(“After division the value of i is :”+ i);
}
运行结果如下：

[RemoteTestNG] detected TestNG version 6.10.0
[TestNG] Running:
C:\Users\Administrator\AppData\Local\Temp\testng-eclipse–754789457\testng-customsuite.xml

PASSED: divisionWithException

===============================================
Default test
Tests run: 1, Failures: 0, Skips: 0
===============================================

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

[TestNG] Time taken by org.testng.reporters.JUnitReportReporter@55d56113: 0 ms
[TestNG] Time taken by org.testng.reporters.SuiteHTMLReporter@1e127982: 0 ms
[TestNG] Time taken by org.testng.reporters.jq.Main@6e0e048a: 32 ms
[TestNG] Time taken by [FailedReporter passed=0 failed=0 skipped=0]: 0 ms
[TestNG] Time taken by org.testng.reporters.XMLReporter@43814d18: 0 ms
[TestNG] Time taken by org.testng.reporters.EmailableReporter2@6ebc05a6: 0 ms
6. TestNG忽略测试
有时候我们写的用例没准备好，或者该次测试不想运行此用例，那么删掉显然不明智，那么就可以通过注解@Test(enabled = false)来将其忽略掉，此用例就不会运行了，如下范例：

import org.testng.annotations.Test;

public class TestCase1 {

@Test(enabled=false)
public void TestNgLearn1() {
System.out.println(“this is TestNG test case1”);
}

@Test
public void TestNgLearn2() {
System.out.println(“this is TestNG test case2”);
}
}
运行结果：

this is TestNG test case2
PASSED: TestNgLearn2

7. TestNG超时测试
“超时”表示如果单元测试花费的时间超过指定的毫秒数，那么TestNG将会中止它并将其标记为失败。此项常用于性能测试。如下为一个范例：

import org.testng.annotations.Test;

public class TestCase1 {

@Test(timeOut = 5000) // time in mulliseconds
public void testThisShouldPass() throws InterruptedException {
Thread.sleep(4000);
}

@Test(timeOut = 1000)
public void testThisShouldFail() {
while (true){
// do nothing
}

}
}
结果如下：

PASSED: testThisShouldPass
FAILED: testThisShouldFail
org.testng.internal.thread.ThreadTimeoutException: Method com.demo.test.testng.TestCase1.testThisShouldFail() didn’t finish within the time-out 1000
   at com.demo.test.testng.TestCase1.testThisShouldFail(TestCase1.java:37)
   at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
   at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
   at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
   at java.lang.reflect.Method.invoke(Method.java:498)
   at org.testng.internal.MethodInvocationHelper.invokeMethod(MethodInvocationHelper.java:104)
   at org.testng.internal.InvokeMethodRunnable.runOne(InvokeMethodRunnable.java:54)
   at org.testng.internal.InvokeMethodRunnable.run(InvokeMethodRunnable.java:44)
   at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
   at java.util.concurrent.FutureTask.run(FutureTask.java:266)
   at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
   at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
   at java.lang.Thread.run(Thread.java:748)

8. 分组测试
分组测试即为使用group，如果你使用xml的话就是里边的<groups>标签，如果是直接在class中，是通过@Test(groups=”group2″)这种方式来分组，如第四节的注解说明中的那个例子，分了两个group，而且@BeforeGroup是需要添加group名称才可以正确挂载到该group下的；
这个group说明可以是在单个的测试方法上，也可以在class上，只要具有同样的group名称都会在同一个group中，同时group名称可以有多个，类似@Test(groups = {“mysql”,”database”})这种，范例如下：
一个测试文件NewTest.class：

public class NewTest {

@Test(groups=”group1″)
public void test1() {
   System.out.println(“test1 from group1”);
   Assert.assertTrue(true);
}

@Test(groups=”group1″)
public void test11() {
   System.out.println(“test11 from group1”);
   Assert.assertTrue(true);
}

@Test(groups=”group2″)
public void test2()
{
   System.out.println(“test2 from group2”);
   Assert.assertTrue(true);
}

@BeforeTest
public void beforeTest()
{
   System.out.println(“beforeTest”);
}

@AfterTest
public void afterTest()
{
   System.out.println(“afterTest”);
}

@BeforeClass
public void beforeClass()
{
   System.out.println(“beforeClass”);
}

@AfterClass
public void afterClass()
{
   System.out.println(“afterClass”);
}

@BeforeSuite
public void beforeSuite()
{
   System.out.println(“beforeSuite”);
}

@AfterSuite
public void afterSuite()
{
   System.out.println(“afterSuite”);
}

@BeforeGroups(groups=”group1″)
public void beforeGroups()
{
   System.out.println(“beforeGroups”);
}

@AfterGroups(groups=”group1″)
public void afterGroups()
{
   System.out.println(“afterGroups”);
}

@BeforeMethod
public void beforeMethod()
{
   System.out.println(“beforeMethod”);
}

@AfterMethod
public void afterMethod()
{
   System.out.println(“afterMethod”);
}

}
另一个TestCase1.class:

@Test(groups= “group2”)
public class TestCase1 {

@Test(enabled=false)
public void TestNgLearn1() {
System.out.println(“this is TestNG test case1”);
}

@Test
public void TestNgLearn2() {
System.out.println(“this is TestNG test case2”);
}
}
xml如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<suite name=”Suite” parallel=”false”>
<test name=”Test”>
<groups>
<include name=”group1″></incloud>
<include name=”group2″></incloud>
</groups>
<classes>
<class name=”com.demo.test.testng.NewTest”/>
<class name=”com.demo.test.testng.TestCase1″/>
</classes>
</test> <!– Test –>
</suite> <!– Suite –>
运行结果如下：

beforeSuite
beforeTest
beforeClass
beforeGroups
beforeMethod
test1 from group1
afterMethod
beforeMethod
test11 from group1
afterMethod
afterGroups
beforeMethod
test2 from group2
afterMethod
afterClass
this is TestNG test case2
afterTest
afterSuite
如上所示，先运行了group1的两个用例，再运行group2的两条用例；
注意在xml标识group，需要将要运行的group加进来，同时还要将被标识这些group的class也加进来，不被加进去的不会运行。

9. 分suite测试
测试套件是用于测试软件程序的行为或一组行为的测试用例的集合。在TestNG中，我们无法在测试源代码中定义一个套件，但它可以由一个XML文件表示，因为套件是执行的功能。它还允许灵活配置要运行的测试。套件可以包含一个或多个测试，并由<suite>标记定义。<suite>是testng.xml的根标记。它描述了一个测试套件，它又由几个<test>部分组成。
下表列出了<suite>接受的所有定义的合法属性。

属性   描述
name   套件的名称，这是一个强制属性
verbose   运行的级别或详细程度，级别为0-10，其中10最详细
parallel   TestNG是否运行不同的线程来运行这个套件，默认为none，其他级别为methods、tests、classes、instances
thread-count   如果启用并行模式(忽略其他方式)，则为使用的线程数
annotations   在测试中使用的注释类型
time-out   在本测试中的所有测试方法上使用的默认超时

10. 依赖测试
有时，我们可能需要以特定顺序调用测试用例中的方法，或者可能希望在方法之间共享一些数据和状态。 TestNG支持这种依赖关系，因为它支持在测试方法之间显式依赖的声明。
TestNG允许指定依赖关系：

在@Test注释中使用属性dependsOnMethods
在@Test注释中使用属性dependsOnGroups
除此之外依赖还分为hard依赖和soft依赖：

hard依赖：默认为此依赖方式，即其所有依赖的methods或者groups必须全部pass，否则被标识依赖的类或者方法将会被略过，在报告中标识为skip，如后面的范例所示，此为默认的依赖方式；
soft依赖：此方式下，其依赖的方法或者组有不是全部pass也不会影响被标识依赖的类或者方法的运行，注意如果使用此方式，则依赖者和被依赖者之间必须不存在成功失败的因果关系，否则会导致用例失败。此方法在注解中需要加入alwaysRun=true即可，如@Test(dependsOnMethods= {“TestNgLearn1”}， alwaysRun=true)；
在TestNG中，我们使用dependOnMethods和dependsOnGroups来实现依赖测试。且这两个都支持正则表达式，如范例三所示，如下为几个使用范例：

范例一，被依赖方法pass：
public class TestCase1 {

@Test(enabled=true)
public void TestNgLearn1() {
System.out.println(“this is TestNG test case1”);
}

@Test(dependsOnMethods= {“TestNgLearn1”})
public void TestNgLearn2() {
System.out.println(“this is TestNG test case2”);
}
}
运行结果：

this is TestNG test case1
this is TestNG test case2
PASSED: TestNgLearn1
PASSED: TestNgLearn2

范例二，被依赖方法fail：

public class Depends {

    @Test(enabled = false)
    public void test01() {
        System.out.println("test01");
    }

    @Test(dependsOnMethods = {"test01"})
    public void test02() {
        System.out.println("test02");
    }

    @Test(dependsOnMethods = {"test02"})
    public void test03() {
        System.out.println("test03");
    }
}

结果：

SKIPPED: TestNgLearn2
范例三、group依赖:
如下所示，method1依赖group名称为init的所有方法：

@Test(groups = { “init” })
public void serverStartedOk() {}

@Test(groups = { “init” })
public void initEnvironment() {}

@Test(dependsOnGroups = { “init.*” })
public void method1() {}
这里init这个group中的两个方法的执行顺序如果没有在xml中指明则是按照方法名英文字母的字典顺序执行的。

关于TestNG框架测试用例的执行顺序请查看我的另一篇博客：TestNG框架测试用例的执行顺序分析。

11. 参数化测试
TestNG中的另一个有趣的功能是参数化测试。在大多数情况下，业务逻辑需要大量测试的场景和测试数据，参数化测试允许测试人员使用不同的值一次又一次地运行相同的测试。
TestNG可以通过两种不同的方式将参数直接传递给测试方法：

1.使用 @Parameters 注解
2. 使用@DataProvider数据提供者
下面分别介绍两种传参方式：
1、使用@Parameters传送参数
范例代码如下：

public class ParamTest {


    @Test
    @Parameters({"name", "age"})
    public void parTest1(String name, int age) {

        System.out.println(name);
        System.out.println(age);


    }

    @Test
    @Parameters({"sex", "address"})
    public void parTest2(String sex, String address) {
        System.out.println(sex);
        System.out.println(address);
    }
}

parameter.xml xml文件配置：

<suite name="suitename">
    <test name="param">
        <parameter name="name" value="zll"/>
        <parameter name="age" value="111"/>

        <parameter name="sex" value="male"></parameter>
        <parameter name="address" value="beijing"></parameter>

        <classes>
            <class name="com.course.zll.param.ParamTest"/>
        </classes>


    </test>


</suite>

运行xml，结果如下：

2、使用@DataProvider传递参数
此处需要注意，传参的类型必须要一致，且带有@DataProvider注解的函数返回的必然是Object[][]，object类型的二维数组此处需要注意。
代码如下：

public class DataProviderTest {

    @Test(dataProvider = "data")
    public void testDataProvider(String name, int age) {
        System.out.println(name);
        System.out.println(age);

    }

    @DataProvider(name = "data")
    public Object[][] providerData() {
        Object[][] o = new Object[][]{
                {"zhangsan", 10},
                {"lisi", 20},
                {"wangwu", 30},
                {"zhaoliu", 30}
        };
        return o;
    }


    @Test(dataProvider = "methodData")
    public void test01(String name, int age) {
        System.out.println(name);
        System.out.println(age);
    }


    @Test(dataProvider = "methodData")
    public void test02(String name, int age) {
        System.out.println(name);
        System.out.println(age);
    }
    
    
    @DataProvider(name = "methodData")
    public Object[][] methodDataTest(Method method) {
        Object[][] result = null;
        if (method.getName().equals("test01")) {
            result = new Object[][]{
                    {"zhangsan", 10},
                    {"lisi", 20},
                    {"wangwu", 30},
                    {"zhaoliu", 30}
            };


        } else if (method.getName().equals("test02")) {
            result = new Object[][]{
                    {"zhangsan", 10},
                    {"lisi", 20},
                    {"wangwu", 30},
                    {"zhaoliu", 30}
            };
        }
        return result;
    }
}

运行此class，结果为：

12. XML配置文件说明
前面讲的大多都是以测试脚本为基础来运行的，少部分是以xml运行，这里以xml来讲解下：

<!DOCTYPE suite SYSTEM “http://testng.org/testng-1.0.dtd” >
<suite name=”SuiteName” verbose=”1″ >
如下分别讲解各个标签：

1、suite标签
testNG.xml文件的最外层标签即suite，即测试套件，其下可以有多个<test>和<groups>，其有几个可以添加的属性在第十节的分suite测试中有做说明，这里做下详细说明：

(1)、name属性
此属性属于必须要有的，值可以自行设定，此名字会在testNG的报告中看到；

(2)、verbose属性
此属性为指定testNG报告的详细程度，从0开始到10，其中10为最详细，默认生成的xml此属性值为1；

(3)、parallel属性
此属性是指代运行方式，默认为none，即串行运行方式；并行执行方法包括如下几种，下面做分别说明：

methods：方法层级，若为此值，则该suite下所有的测试方法都将进行多线程，即测试用例级别的多线程。如果用例之间有依赖，则执行顺序会按照设定的依赖来运行；
<suite name=”My suite” parallel=”methods” thread-count=”5″>
tests：TestNG将在同一线程中运行相同的<Test>标签中的所有方法，每个<test>标签都将处于一个单独的线程中，这允许您将不是线程安全的所有类分组在同一个<test>中，并保证它们都将在同一个线程中运行，同时利用TestNG使用尽可能多的线程运行测试。
<suite name=”My suite” parallel=”tests” thread-count=”5″>
classes：类级别并发，即TestNG会将该suite下每个class都将在单独的线程中运行，同一个class下的所有用例都将在同一个线程中运行；
<suite name=”My suite” parallel=”classes” thread-count=”5″>
instances：实例级别，即TestNG将在同一线程中运行同一实例中的所有方法，两个不同实例上的两个方法将在不同的线程中运行。
<suite name=”My suite” parallel=”instances” thread-count=”5″>

(4)、thread-count属性
此属性用于指定线程数，按照需要输入，需要parallel参数非none时才可以添加；

(5)、annotations属性
此项为注解的级别，为methods级别和class级别，一般不用设置；

(6)、time-out属性
此属性用于指定超时时间，该suite下所有的用例的超时时间；

(7)、group-by-instances属性
此项用于那些有依赖的方法，且被依赖的对象有多个重载对象，因为如果是依赖方法，且该方法有多个重载方法，则默认是会将所有重载方法都跑完再运行被依赖方法，但有时候我们不想这样，则将此项设置为true即可；

(8)、preserve-order属性
值可输入true或者false，如果为true，则用例执行会按照在xml中的顺序执行，否则会乱序执行，不添加此属性的话默认是按顺序执行的；

2、test标签
此标签无特别意义，其下可以包括多个标签，如groups、classes等，如下介绍下几种书写方式：

（1）选择一个包中的全部测试脚本（包含子包）

<test name = “allTestsInAPackage” >
<packages>
<package name = “whole.path.to.package.* />
</packages>
</test>
（2）选择一个类中的全部测试脚本

<test name = “allTestsInAPackage” >
<packages>
<package name = “whole.path.to.package.* />
</packages>
</test>
（3）选择一个类中的部分测试脚本

<test name = “aFewTestsFromAClass” >
<classes>
<class name=”whole.path.to.package.className >
<methods>
<include name = “firstMethod” />
<include name = “secondMethod” />
<include name = “thirdMethod” />
</methods>
</class>
</classes>
</test>
（4）选择一个包中的某些组

<test name = “includedGroupsInAPackage” >
<groups>
<run>
<include name = “includedGroup” />
</run>
</groups>
<packages>
<package name = “whole.path.to.package.* />
</packages>
</test>
（5）排除一个包中的某些组

<test name = “excludedGroupsInAPackage” >
<groups>
<run>
<exclude name = “excludedGroup” />
</run>
</groups>
<packages>
<package name = “whole.path.to.package.* />
</packages>
</test>
其可以附带的属性有如下几种，下面对各个属性做单独说明：

(1)、name属性
此属性属于必须要有的，值可以自行设定，此名字会在testNG的报告中看到；

(2)、verbose属性
此属性为指定testNG报告的详细程度，从0开始到10，其中10为最详细，默认生成的xml此属性值为1

(3)、threadPoolSize属性
该属性指定此test的线程池大小，为数字；

<test name = “excludedGroupsInAPackage” >
<groups>
<run>
<exclude name = “excludedGroup” />
</run>
</groups>
<packages>
<package name = “whole.path.to.package.* />
</packages>
</test>
(4)、invocationCount属性
该属性指定此test的运行次数，为数字，范例如上面的代码所示；

(5)、time-out属性
此属性用于指定超时时间，该suite下所有的用例的超时时间，范例如上面的代码所示；

(6)、group-by-instances属性
此项用于那些有依赖的方法，且被依赖的对象有多个重载对象，因为如果是依赖方法，且该方法有多个重载方法，则默认是会将所有重载方法都跑完再运行被依赖方法，但有时候我们不想这样，则将此项设置为true即可；

<suite name=”Factory” group-by-instances=”true”>
(7)、preserve-order属性
值可输入true或者false，如果为true，则用例执行会按照在xml中的顺序执行，否则会乱序执行，不添加此属性的话默认是按顺序执行的；

3、group标签
此标签必然是在<test>标签下的，用于标识那些组会被用于测试或者被排除在测试之外，其同级必然要包含一个<classes>标签或者<pakages>标签，用于指定groups来自于哪些包或者类；
如下即为包含一个group，排除一个group的例子：

<groups>
<run>
<include name = “includedGroupName” />
<exclude name = “excludedGroupName” />
</run>
</groups>
高级应用：

<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>
4、其他
其他的话就是测试脚本的选择了，有三种方式：

（1）选择一个包

<packages>
<package name = “packageName” />
</packages>
（2）选择一个类

<classes>
<class name = “className” />
</classes>
（3）选择一个方法

<classes>
<class name = “className” />
<methods>
<include name = “methodName” />
</methods>
</class>
</classes>
这里也支持正则表达式，例如:

13. TestNG报告
默认报告输出位置为当前工程的test-output文件夹下，包括xml格式和html格式。
如果想要美化报告，则按照如下步骤：
1、配置：Eclipse –> Window –> Preferences –>testng
2、勾选Disable default listeners
3、在Pre Defined Listeners 输入框中输入org.uncommons.reportng.HTMLReporter
记得在POM上添加如下代码：

<dependency>
<groupId>org.uncommons</groupId>
<artifactId>reportng</artifactId>
<version>1.1.4</version>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>3.0</version>
<scope>test</scope>
</dependency>
不然无法运行的。
如上图所示，还可以自定义testng.xml的模板，并在上图中指定。

使用IDEA+TestNG进行测试，没有生成测试报告，是因为没有勾选监听器使用默认报告，具体操作如下：

“Run” -> “Edit Configurations” -> “listeners” -> “Use default reporters”

输出报告在test-output文件夹中（index.html）。

原文链接：https://blog.csdn.net/zhangliang1010/article/details/120388679

Testng的简介和使用

标签云

近期文章

分类

Testng的简介和使用

相关文章