TestNG官方文档中文版(1) -介绍

T e s t NG 的 官 方 文 档 请 见 :
http://testng.org/doc/documentation-main.html

1 介绍
T e s t N G 是 一 个 设 计 用 来 简 化 广 泛 的 测 试 需 求 的 测 试 框 架 ， 从 单 元 测 试 (隔 离测试- 个类)到集成测试(测试由有多个类多个包甚至多个外部框架组成的鉴 个系统，例如远用服务器)。
编写一个测试的过程有三个典型步骤:
* 编写测试的 业务逻辑并在代码中插入TestNGannotat ion
* 将 测 试 信 息 添 加 到 t e s t n g . x m l 文 件 或 者 b u i l d . x ml 中

* 运 行 Te s t NG
在欢迎页面上可以找到快速入门示例。 下面是这篇文档使用的概念:
        *suite由xnl 文件描述。它包含一个或多个测试并被定义为<suite›标签

        * test 由<test>描述并包含 一个或者多个TestNG类
* T e s t N G 类 是 包 含 至 少 一个 T e s t N G a n n o t a t i o n 的 j a v a 类 ， 由 < c l a s s > 标 签 描 述并包含 一个或多个测试方法
* 测试方法是源文件中带有@Testd注释的java 方法
        T e s t NG 测 试 可 以 被 @Be f o r e x x x 和 @A f t e r x X x a n n o t a t i o n s 配 置，容许在特定点的前后执行一些 java逻辑，这些点上面已经列出。

这份手册的剩余部分将讲述以 下内容:
* 所 有 的 a n n o t a t i o n 列 表 并 带 有 简 短 说 明 ，为 T e s t NG 的 多 种 功 能 性 提 供 参 考 ， 你可能需要参考为每个annotat ion 提供的代码片段来学习细节。
* testng. xml文件描述，它的语法和如果指定它。

 * 多个特性的详细列表和怎样结合annot at ion 和tes tng. xml 来使用它们
注 :上面的内容很简短，但是请注意其中的一些细节。
1. Te s t NG 是一 个设计用来简 化广泛的测试需 求的测试框架， 从单元测 试到 集成测试
这 个 是 T e s t NG 设 计 的 出 发 点 ，不 仅 仅 是 单 元 测 试 ， 布 且 可 以 用 于 集 成 测 试 。 设计目标的不同，对比j un i t 的只适合用于单元测试，Test NG无疑走的更远。
可以用于集成测试，这个特性是我选择TestNG的最重要的原因。
2. 测试的过程的三个典型步骤，注意和junit(4.0)相比，多了一个将测试信息添加到testng.xml 文件或者build.xml

测试信息尤其是测试数据不再写死在测试代码中，好处就是修改测试数据时不需要修改代码/ 编译了，从而有助于将测试人员引入单元测试/集成测试。

3. 基本概念，相比junit 的TestCase/TestSuite, TestvG有suite/test/test method三个级别，即将test/test method明确区分开了。

junit 中的TestCase将test/test method混合，比较容易让人概念不清晰，尤其是新手。
 

Te s t NG 官 方 文档 中 文版 ( 2 ) - a n n o t a t i o n

Tes t NG的官方文档的中文翻译版第二章，原文请见
http://testng.org/doc/documentation-main.html2-Annotation
这里是TestNG中用到的annotat ion 的快速预览，还有它们的属性。
@BeforeSuite:
被注释的方法将在所有测试运行前运行

@AfterSuite: 被注释的方法将在所有测试运行后运行
@BeforeTest:
被注释的方法将在测试运行前运行

@AfterTest:

被注释的方法将在测试运行后运行

@B e f o r e G r o u p s :
被配置的方法将在列表中的gou rp 前运 行。这个方法保证在第一个属于这些组的测试方法调用前立即执行。
@A f t e r G r o u p s :
被配置的方法将在列表中的gour p 后运行。 这个方法保证在最后 一个属于这些组的测试方法调用后立即执行。
@B e f o r e C l a s s : 被注释的方法将在当前类的第一个测试方法调用前运行。
@AfterClass: 被注释的方法将在当前类的第一个测试方用后 运行 。
@BeforeMethod: 被注释的方法将在每 一个测试方法调用前运行。
@AfterMethod: 被注释的方法将在每一个测试方法调用后运行。
属性:
alwaysRun
对于每个bufore 方法(beforeSuite, beforeTest, beforeTestClass 和 beforeTestMethod，但是不包括 beforeGroups):
如 果 设 置 为 t r u e ， 被 配 置 的 方 法 将 总 是 运 行 市 不 管 它 属 于哪 个 组 。
对 于 a f t e r 方 法 ( a f t e r S u i t e , a f t e r C l a s s , . . . ): 如 果 设 置 为 t r u e , 被 配置的方法甚至在一个或多个先调用的方法失败或被忽略时也将运行。

 dependsOnGroups：这个方法依赖的组列表

dependsOnMethods：这个方法依赖的方法列表
enabled：这个类的方法是否激活

grOUDs：这个类或方法所属的分组列表
inheritGroups：如果设置为tr ue，这个方法被属于在类级 別被@Test annotation指定的组
@DataProvider：标记 一个方法用于为测试方法提供数据。

被注释的方法必须返回Obj ect 又，其中每个Obj ect 又] 可以指派为这个 测试方法的参数列表。
从这个DataProvider 按收数据@Tes t 方法需要使用一个和当前注释相同名 称的dataProvider 名称
name ：这个DataProvider的名称
@Factor y ：标记方法作为一个返回对象的工厂，这些对象将被TestNG 用于作为测试类。这个方法必须返回Ob ject [ ]
@Parameters：描述如何传递参数给@Test 方法
v a l u e ：用 于填充这 个方法的参数的变量列表

@Test：标记一个类或方法作为测试的一- 部分
alwaysRun：如果设置为t rue，这个测试方法将总是运行，甚至当它依赖的方法失败时。
d a t a P r o v i d e r ：这个测试方法的dat a provider 的名称

dataProviderClass：用于查找data provider的类。
如果不指定，将在当前测试方法所在的类或者它的基类 上杳找dat a provider.
法 。

如果这个属性被指定，则 da t a pr o v i de r 方法需要是指定类的 st a t i c 方
dependsOnGroups： 当前方法依赖的组列 表
dependsOnMethods ：当前方法依赖的方法列表

 description enabled：当前方法的描述 当前类的方法/ 方法是否被激活
e x p e c t e d Ex c e p t i o n s：测试方法期望抛出的异常列表。如果没有异 常 或 者 抛 出 的 不 是 列 表 中 的 任 何 一 个 ， 当前 方 法 都 将 标 记 为 失 败.
groups：当前类/ 方法所属的组列表

invocationCount：当前方法被调用的次数

successPercentage ：当前方法期望的成功率
sequent ia l：如 果 设 置 为 t r u e , 当前 测 试 类 上的 所 有 方 法 保 证 按 照顺序运行。甚至测试们在par al lel=” true〞的情況下。

这个属性只能用于类级别，如果用于方法级别将被忽略。
timeOut：当前方法容许花费的最大时间，单位亮秒。

threadPoolSize：当前方法的线程池大小。方法将被多线程调用， 次数由 i nv oc at i oncoun t 参数指定
注意:如果invocationCount 没有指定则这个属性将被忽略
注:
上面是TestNG中用到的annotation 列表，从中我们可以看到TestNG提供 的一 些特性
1. before方法和after方法带 来 了足 够 丰 富 的 测 试 生 命 周 期 控 制

2. dependsOnGroups/dependsOnMethods 提供了依赖检查机制，并可以严格 控制 执行顺序
3. DataProvider 使得对同一个方法的测试覆盖变的非常轻松，非常适合进 行边界测试，只要给出多种测试数据就可以针对一个测试方法进行覆盖
4. expectedExceptions 使得异常测试变的非常轻松
5. invocationCount/threadPoolsize 终于可以简单的直接进行多线程测 试了，这个绝对是junit 的超级弱项，回想junit 中那个万恶的
S y s t e m. e x i s t ( o ) . . .
6. timeout 终于不用死等然后手工强行关闭测试，TestNG想的太周到了

 
 TestNG官方文档中文版(3)-testng. xml

Tes tNG的官方文档的中文翻译版第3章，原文请见

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

3 - testng. xml
调 用 T e s t NG 由 几 种 不 同 方 法 :

* 使用testng.xml 文件
* 使用ant
* 从命令行
这节描述tes tng. xml 的格式 (文档的后面会讲到ant 和命令行)。
当前testng. xml 的DTD文件可以从官方找到:h t t p : / / t e s t n g . o r g / t e s t n g - 1 . 0 . d t d 。 (为 了 方 便 使 用 ， 你 可 能 更 喜 欢 浏 览 H T M 版 本)
下面是testng. xml 文件的一个例子:

<!DOCTYPE suite SYSTEM "http://testng. org/testng-1. 0. dtd" >
«suite name="Suitel" verbose="!" >
<test name="Nopackage" >
<classes>
moc.n ‹class name="NoPackagelest"
</classes) </test>
<test name="RegressionI" ‹classes
<class name="test. sample. ParameterSample" <class name-"test. sample. ParameterTest" />
</classes)
</test> (suite>

你可以指定包名替代 类名:

<!DOCTYPE sui te SYSTEM“http://testng. org/testng- 1.0.dtd” >
 <suite name="Suitel" verbose="1" › <test name-"Regression!"
<packages>
<package name="test. sample" />
</packages› </test>
</suite>

在这个例子中，TestNG将在包test .sample中查找所有的类，并只保留带 有 T e s t NG a n n o t a t i o n 的 类 。
你同样可以指定包含或不包含的组和方法:

<test name="Regression!" <groups)
(run>
«exclude name="brokenTests"
<include name="checkinTests" </run>
</groups>
<classes)
<class name="test. IndividualMethodsTest"›
<methods>
‹include name="testMethod" /›
</methods›
</class)
</classes>
</test>

        你同样可以在tes tng. xml 中定义新的组，指定属性的额外详细情况，比如 是 否 并 行 运 行 测 试 ， 使 用 多 少 线 程 ， 是 否 运 行 j u n i t 测 试 ， 等 等 .• .

        请查看DTD文件了解完整的特性列表。

 T e s t NG 官 方 文档 中 文 版 ( 4 ) - 运 行 TestNG

4-运行TestNG
T e s t NG 可 以 以 不 同 的 方 式 调 用 :

* Command line
* ant
* Eclipse
* IntelliJ's IDEA
1) 命 令行

假设你已经将 TestNG加入到class path，调用TestNG最简单的方法事下
面的:
java org. testng. TestNG testng1. xml [testng2. xml testng3. xml .. 〕
必须指定最少一个描述你试图测试的TestNGsuite的xml 文件。另外，下 面的命令行参数可以使用:
命 令行 参数 列 表

选顼	参数	文档说明
-d (test-output）	一个目录	生成报告的目录
-sourcedir	分号隔开的目录列表	带有javadoc 注 释的测试源文件目录.这个选项只在使用 javadoc 类型的annotation 时才有效 (例 如 ” s r c / t e s t " o r "src/test/org/testng/eclipse-plugin;src/test/org/testng/testng").
-testclass	可以在cl asspath路径中找到的逗号分隔的类列表	号分隔的类文件列表(例如“org. foo. Test1, or g. foo. test2”).
-groups	逗号分隔的组列表	要运行的组列表 ( 例 如 “ v i n d o ws , l i n u x , r e g r e s s i o n ” ) .
-excludegroups	逗号分隔的组列表	不想包含在这 次运行中的组列表
-testrunfactory	可以在classpath中找到的ja va 类	指定测 试的runner•这个类需要实现接又org. testng. ITestRunnerFactory•
-listener	可 以在 c l a s s pa t h 路径中找到的逗号分隔的类列 表	指定测试的listener.这个类需要实现接又org. testng. ITestListener
-paral lel	methods tests	如果指定，设置 运行测试时如何使用并发线程的默认机制. 如果不设置，默认机制是完全不使用 并 发 线 程 。 这 个 设 置 可 以 被 s u i t e 定 义 覆 盖.
-threadcount	并发测试运行时默认使用的线程数	用于设置 并发测试时默认的线程数，只在并发模式被选择时才生效 (例如，打开 - paralle1选项).这个设置可以被suite定义覆盖•
- suitename	测试套件使用的默认名称	指定在命 令行上定义的测试套件的名称。如果suite.xml 文件或源代码指定了另外 一个不 同的套件名称，这个选项将被忽略。可以创建带空格的套件名称， 如果在名称 前后加双引1号如"Like thi s“.
-testname	测试使用的默认名称	指定在命令行 上 定义的测试的名称。如果suite. xml 文件或源代码指定了另外 一个不同的测试名 称，这个选项将被忽略。可以创建带空格的测试名称，如果在名称前后加双引号 如"Like this"
- r e p o r t e r	扩 展 配 置 用 于自定 义报 告 l i s t e n n e r .	类似 - listener 选项，除了容许reporter示例上由javabean形式的配置. 例 如 :- r e p o r t e r com. test.MyReporter:methodFilter=*insert*, enableFiltering=tru

可以通过不带任何参数直接调用TestNFG 来获得这个文档。 可以将命令行开关写到txt 文件中，例如c comand. txt，然后告诉TestNG 使用这 个 文件 类找到 参数 :
C:> more c: command. txt
- d test-output testng.xml
C:> java org. testng. TestNG @c: command. txt 另外，可以通过 jvm的命令行来传递参数给TestNG，例如
java -Dtestng. test. classpath="c:/build;c:/java/classes:" org. testng. TestNG testng. xmI
T e s t NG 能 够 理 解 的 参 数

testng. test. classpath
分号分隔的包含测试类的一 系列目录 如果这个属性被设置，TestNG将使用它替代从class path 来查找测试类.如果 你正在使用在xml文件里面的包标签并且在classpa th路径中由很多类市大部分 都不是测试类的时候比较方便

举例:
javaorg. testng.TestNG-groupswindows,linux-testclassorg. test.MyTest 注意ant 任务和testng.xml容许用更多的参数来启动TestNG(包含的方法， 指定的参数，等等)，因此可以认为命令行适用于学习Tes t vG并且想快速入门。

指定的参数，等等)，因此可以认为命令行适用于学习Tes t vG并且想快速入门。

2) Ant
可以这样定义TestNG的ant 任务: <taskdef resource="testngtasks"
classpath="testng. jar ”/>
这 个 任 务 运 行 T e s t N G 测 试 ， 并 且 通 常 是 在 单 独 的 j v n 中 。 接 受 下面 的 属 性 :

属性名	描述	是否必须
annotat ions	宇 符 串 ” J D R 〞或 者 ” J a v a d o c ” . 定 义 测 试 适 用的注释类型•如果使用” Javadoc”，则需要同时指定”sourcedir”	不 是 必 须 . 如 果 适 用 j k d 5 则 默 认 为 〞J D K 〞， 如 果 适 用 j d k 1 . 4 则 默 认 为 ” J a v a d o c ”
classfilesetref	要运行的测试类的Fileset 结构的引用
classpath	要运行的测试的PATH- 1ike 结构
classpathref	要运行的测试的PATH- 1ike 结构的引用
d u m p C o m m a n d	打 印 T e s t NG 启 动 命 令 。	不 是 必 须 ， 默认false
enablessert	开启 JDK1. 4的断言.	不是必领， 默认true
failureProperty	失败发生时要设置的属性的名称	只有 hal tonfailure没有设置时才有效 不是必须，
hal tonfailure	如果测试运行期间发生失败，停止构造过程	不 是 必 须，默 认 f a l s e
haltonskipped	如果发生至少一次测试跳过，停止构造过程	不 是 必 须 ，默 认 f a l s e
groups	要运行的组列表，空格或逗号分隔
excludedgroups	排除在外的组列表，空格或逗号分隔
jvm	使用的 jvm，将被Runtime. exec( 运行 java
listeners	逗号或空格分隔的全路径类列表，需要实现 org. testng. ITestListener 或org. testng. IReporter	不是必须
outputdir	报告输出目录	不是 必 须，默 认 输 出 到 t e s t - o u t p u t .
skippedProperty	当发生测试被跳过时设置的proper ty的名称. 只有当hal tonskipped没有设置时才使用	不是必须
sourcedir	用 于 j d k 1 . 4 测 试 的 P A T H - I i k e 结 构 (使 用 JavaDoc 形式的annotations)
s o u r c e d i r r e f	用 于j d k 1. 4 测 试 的 P A TH- 1 i k e 结 构 的 引 用 (使 用 J a v a D o c 形 式 的 a n n o t a t i o n s )
suiteRunnerClass	TestNG启动器的全路径名称	不是必须 𨉖 𡲬𠃊 𩥈𨃴𨉖𠃊 # i t # org. testng. TestNG
parallel	运行测试时使用的并行模式一me t hod s 或者 TeStS	不是必须一 如果没有指定，并行模式不被选择
threadCount	运 行 时 使 用 的 线 程 数 量 。如 果 并 行 模 式 被 同时指定否则忽略	默认1
testJar	包含测试和套件定义的jar 包路径
timeOut	所有测试必须运行完成的最大超时时间，单位毫秒
useDefaultListeners	是否使用默认监听器和报告器，默认true.
workingDir	运行TestNG前ant 任务应该转移到的目录。
xmlfilesetref	用于要测试的套件定义的Fileset 结构的引用
su itename	设置测试套件的默认名称如果在suite的xml 文件或者源代码中都没有被定义	不是必须，默认设置为〞Ant sui te"
t e s t n am e	设置测试的默认名称如果在suite的xml 文件或 者源代码中都没有被定义。	不是必须，默认设置为”Ant test"

属 性 c l a s s p a t h , c l a s s p a t h r e f 或 者 内 嵌 的 < c l a s s p a t h » 必 须 设 置 一个 ， 用 于提供测试的cl as spa th
属性xmlfilesetref, classf ilesetref 或者内嵌的<xmlfileset>，分别 的<classfileset>必须使用用来提供测试
注意:如果使用jdk1.4，属性attributessourcedir, sourcedirref 或者 内嵌的<sourcedir〉 必须提供.
注意:使用<classf ileset 〉 并不自动按添加测试类到classpath:需要报告这 些 在 c l a s s p a t h 中 的 任 务 要 工作 的 类

内嵌元素
classpath
<testng》任务支持一个内嵌的<classpath》元素来提供PATH- 1ike 的结
构.
bootclasspath
docin.com b o o t s t r a p 类 文件 的 位 置 可 以 用 这 个 P A TH 形 式 的 结 构 指 定 - 如 果 f o r k 没 有 设置则被忽略
xmlfileset
套 餐 定 义 (t e s t n g . x ml ) 可 以 通 过 一 个 F i l t s e t 结 构 传 递 给 任 务
classfileset
TestNG可以直接在类上运行，同样支持FiltSet 结构 sourcedir
PATI 北式的结构，用于jdkl. 4的测试，使用javadoc annotation jvmarg

通 过 内 联 的 < j v ma r g > 元 素 将 额 外 的 参 数 传 递 给 新 的 虚 拟 机 ， 例 如 : <testng>
<jvmarg value="-Djava. compiler=NONE" />
<!- -
</testng) sysproperty
使用内嵌的<sysp roper t y〉 元素来指定类需要的系统属性。在测试的执行期 问虚拟机可以获取这些属性。这个元素的属性和环境变量相同。
<testng)
<sysproperty key=”basedir” value="stbasedir]"/
<!- </testng>
将运行测试并且使得测试可以访问basedir 属性 reporter
内部的<r epor ter >元素是一个可选的方式，用于注入自定义的报告监听器， 容许用户为调整运行时的报告期行为市
这个元素强制要 求设置cl assname 属性，指示自定义监听器的类。为了设置 报告期属性，《repor ter >元素可以包含多个内嵌的<property>元素来提供name 和value 属性，如下所示:

 请注意这里仅仅支持有限的属性类型:String, int,boolean, byte, char, double, float, long, short.
env
可以通过内嵌的 <env>元素给TestNG的单独的虛拟机传递指定的环境变 量。
要查阅<env〉 元素属性的详细描述，请查看ant 的exec任务的描述。
举 例 : S u i t e. x ml

<testng classpathref="run. cp"
outputDir="$ (testng. report. dir)"
sourcedir="$ (test. src. dir)" haltOnfailure="true")
<xmlfileset dir="$ (test14. dir)" includes="testng. xmI"/> </testng)
Class FileSet
<testng classpathref-"run. cp'
outputDir="$ (testng. report. dir)"
haltOnFailure="true"M verbose="2")
<classfileset dir="§ (test. build. dirt" includes="**/×, class" />
</testng)

Te s t NG 官 方 文档 中 文版 ( 5) - 测 试 方法 / 类和组

5- Test methods, Test classes and Test groups

5.1- Test groups
TestNG容许执行复杂的测试方法分组。不仅可以申明方法属于组，而且可以指 定分组包含其他分组。
然 后 T e s t NG 可 以 被 调 用 ， 并 被 要 求 包 含 某 些 分 组 和 排 除 其 他 的 分 组 。 这将提供怎样划分测试的最大弹性，并日如果想运行两个不同的测试装置不需要重新编译。 例如，非常普遍的需要至少两个种类的测试
* Check- in tests. 这些测试将在提交新代码之前运行.它们典型的被 要求快速市且仅仅确认没有基础功能被破坏。
*Functional tests. 至少1天，尽管理想的是连续运行。这些测试将覆盖所 有的软件 功能， 并且必须运行代表性的，check- in测试是功能性测试的子集。TestNG容许用非常直接的 方式说明这个。
例如: 可以这样构造测试，申明完整的测试类属于"runct est “组，另外两 个 方 法 属 于组 " c h e c k i n t e s t ”:

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

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

    @Test (groups = { "functest" }) 
    public void testMethod3 (){
    }
}

调用TestNG,使用

<test name="Test1">
    <groups)>
        <run>
            <include name="functest"/ ›
        </run>
    </groups> 
    <classes)
        <class name="examplel. Testl"/> 
    </classes)
</test>

将运行在类中的所有测试方法，如果使用checkintest 调用则将只运行 testMethodl(和testMethod20 .
这 里 由 其 他 例 子， 这 次 使 用 正 则 表 达 式 。 假 设 某 些 测 试 方 法 可 能 无 法 在 Li nux 上运行，测试将是类似如此:

@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(){
    }

你可以使用下面的testng. xml 文件只启动Windows 方法:

<test name="TestI">
    <groups> 
        <run>
            <include name="windows. *"/> 
        </run>
    </groups>
    <classes)
        <class name="examplel. Testl"/>
    </classes) 
</test>

注 意 : T e s t N G 使 用 正 则 表 达 ， 而 不 是 w i l d ma t s 。 注 意 这 个 差 别 。
Method groups
同样可以包含或排除个别方法:

<test name -"Testl"> 
    <classes>
        <class name="examplel. TestI">
            <methods>
                <include name=", *enabledTestMethod. *"/> 
                <exclude name=". *brokenTestMethod. *"/>
             </methods> 
        </class>
    </classes> 
</test>

这在需要使莫个单独的方法失效而不想重新编译时非常方便，但是不建议太多 的使用这个机制，因为这将可能破坏你的测试框架如果你开始重构你的java 代码 (标签中使用的正则表达式可能不再匹配你的方法)
5.2 - Groups of groups
"Functest" itself will contain the groups "windows" and "linux" while "checkintest will only contain "windows' Here is how you would
define this in your property fi l e :
组 可 以 包 含 其 他 组 。 这 些 组 被 称 为 ” Me t a G r o u p s 〞。 例 奶， 你 可 能 想 定 义 一 个 ” a 1 l " 组 ， 包 括 ” c h e c k i n t e s t ” 和” f u n c t e s t ” 。 ” f u n c t e s t ” 自 身将 包 含 组
〞w i n d o w s 〞 和 ” l i n u x ” ， 而 ” c h e c k i n t e s t 〞将 包 含 〞w i n d o w s ” 

<test name="Regression">
    <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>

    <classe>
        <class name="test. sample. Test1"/>
    </classes> 
</test>

5.3 - Exclusion groups
Tes tNG 容许包含组也容许排除组.
例如，当由因为最近的修改而临时破坏的测试而又没有时间去修复它们时非 常有用。无论如何，你想要干净的运行功能性测试，因此你想要是这些测试失效， 但是记住它们重新被激活。
• 个简单的解决这个问题的方法是创建一 个称为“ br ok en” 的组并让这些测试方 法 归 属 它 。 例 奶 ， 在 上面 的 例 子中 ， 我 知 道 t e s t Me t h o d 2 ( 现 在 被 破 坏 了， 所 有我想关闭它:

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

现在我所想要做的只是在运行中排除这个组:

<test name="Simple example">
    <groups> 
        <run>
            <include name="checkintest"/>
            <exclude name="broken" /> 
        </run>
    </groups>

    <classes>
        <class name="examplel. Testl"/>
    </classes> 
</test>

用这种方法，我将得到 一个干净的测试运行，同时记录了那些被破坏并想要 后续修复的测试。
注 意 : 你 也 可 以 通 过 使 用 在 @ T e s t a n d @B e f o r e / A f t e r a n n o t a t i o n s 上 的 “enab l ed” 属性在个体的层面 上关闭测试，

5.4 - Partial groups
你可以在类的级别上定义组，然后在方法的层次上添加组:

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

在这个类中，method20 属于组”checkin-test〞，在类的级别定义。而 me t h o d 1 ( 同 时 属 于 “ c h e c k i n - t e s t 〞 和 ” f u n c - t e s t

T e s t N G 宫 方 文 档 中 文 版 (6 ) 一 参 数

5. 5 - Parameters

测试方法不要 求是无参数的。你可以在每个测试方法 上使用任意数量的参数， 并 指 示 t e s t NG 传 递 正 确 的 參 数 。
有两种方式用于设置参数:使用test ng. xml 或者编程式。 5. 5. 1- Parameters from testng. xmI
如果你要为你的参数使用简单值，你可以在你的test ng. xml 中明确指定:

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

在这个代码中，我们明确指定java方法的参数“firstVame” 应该接收名为 “ r i r s t - n a m e ” x ml 参 数 的 值 。 这 个 x ml 参 数 在 t e s t n g . x m l 中 定 义 :

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

同 样 的 方 法 可 以 用 于注 解 @B e f o r e / A f t e r 和 @F a c t o r y :

@Parameters ({"datasource","jdbeDriver"}) 
@BeforeMethod
public void beforelest (String ds, String driver) (
    m dataSource = ...;
// look up the value of datasource
    m_jdbcDriver = driver; 
}

这次，两个java 参数ds 和driver 将分别接收被设置给属性dat asource 和 j d bc - d r i v e r 的 值 。
参数可以通过可选注解来声明为可选:

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

如果在testng. xml 文件中没有找到名为”db”的参数，测试方法将接受在 @O p t i o n a l 注 解 中 指 定 的 默 认 值 : “ n y s a l ”
@Parameter s 注解可以在 下面位置使用:
* 在 任 何 有 @ T e s t ， @B e f o r e / A f t e r 或 者 @F a c t o r y 注 解 的 方 法 上
* 在测试类的最多 一个构造函数上。这种情况下，当Test NG需要实例化测 试类时，他将调用这个特别的带有初始化为testng. xml 中指定的值的参数的构造函数。这个特性可以被用于初始化类内部的值域为将用于测试方法的值。 注 意:
*xml 参数被以在注解中出现的相同顺序映射到java 参数，如果参数数量 不匹 配 t e s t v G 将 发 生错 误 。
*参数是有范围的。在testng.xml 中，你可以在<suite>标签或者<test> 标签 下声明参数。如果两个参数同名， 在<t es t >标签 下定义的参数优先。 非常
适用于这样的场合:需要指定一个应用于所有测试的参数，但是又希望在特定测 试 用 覆 盖 它的 值 。
* 需要传递复杂参数，或者参数需要从java 中创建 (复杂对象，从属性
5.5.2-/Parameters with DataProviders I 在testne. xn1中指定参数，对于以下情况是不够的:
* 不使用testng.xml 文件或者数据库中读取的对象)在这种情况下，你可以使用DataProvider 来提
供 你 测 试 需 要 的 数 值 。D a t a P r o v i d e r 是 类 中 的 一个 返 回 对 象 数 组 的 数 组 的 方 法 。 这个方法带有@DataProvider 注解:

// 这个方法将提供数据给任何声明它的Data Provider名为"test1”的测试方法

@DataProvider (name = "testl") 
public Object[][] createDatal (){
    return new Object[][]{
    {"Cedric, new Integer (36) },
    { "Anne", new Integer (37)},
    }；
}

//这个方法声明它的数据将由名为"test1”的Data Provider 提供

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

将打印
        Cedric 36

        Anne 37
@Test 方法用dataProvider 属性来指定它的DataProvider。这个名字必须 符合同一-个类中用@DataProvider(name-”.... )注解的方法，它们要使用同一个 匹配的名字。
默认，将在当前类或者它的基类中查找data provider。如果你想将data pr ovider 放置到另 一个类中，需要将这个da ta provider 方法设置为静态方法 并在dat aPr oviderCl ass属性中指定在哪个类中可以找到这个方法。
 

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

public class MyTest {
    @Test (dataProvider="create", dataProviderClass = StaticProvider. class)
    public void test (Integer n) {
        // ...
    }
}

Data Provider 方 法 将 返 回 下面 两 个 类 型 中 的 一 种 :
The Data Provider method can return one of the following two types:

*对象数组的数组(Object[ 又1)，外围数据的大小是测试方法将被调用的 次数，而内层数组的大小和类型必须和测试方法的参数列表匹配。如同上面举例 说明的。
* Object又]>的Iterator，和Object[]又的唯 一差别在于Iterator 容许 延迟创建测试数据。tes tNG将一个接一个的调用i ter ator ，再用i ter ator 返 回的参数调用测试方法。如果有很 多参数集合需要传递给方法而又不想一开始就 创 建 所 有 参 数 ， 会 非常 有 用 。
Here is an example of this feature for bot h JDK 1.4 and JDK5 (note t h a t t h e J DK 1 . 4 e x a mp l e d o e s n o t u s e G e n e r i c s ) :
这里有 一个同时适用于DK1.4和 K5的例子(注意下 1.4的例子不使 用 注 解 ):

**
* @testng. data-provider name="testl"
*/
public Iterator createData(){
    return new MyIterator (DATA);
}
@DataProvider (name = "testl") 
public Iterator createData () {
    return new MyIterator (DATA) ;
}

如 果 将 测 试 方 法 的 第 一个 参 数 申 明 为 j a v a . l a n g . r e f l e c t . N e t h o d , T e s t N G 将使用这个第 一个参数来传递当前测试方法。当多个测试方法使用同 一个 @DataProv ide r 而需要依当前申请数据的方法市定来返回不同值时特别有用。 举 例 说 明 ， 下 面 的 代 码 在 @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 testl (String s) {
}

@Test (dataProvider = "dp")
public void test2 (Strings) {
}

将会显示:
        test1

        test2
 
 5. 5. 3 - Parameters in reports
被用于调用测试方法的参数将在TestNG 生 成 的 H T M L 报 告 中 显 示 。实 例 如 下 :

Te s t NG 官 方 文档 中 文版 ( 7 ) - 方法 依 赖 和工厂

5.6- Dependentmethods

有些时候，你需要你的测试方法按照一个特定的顺序被调用。这非常有用，比 如:
* 在运行更多测试方法前确认特定数量的测试方法调用完成并且成功

* 初始化测试并希望这个初始化方法也作为测试方法(被标记为 @Before/After的方法将不作为最终报告的 一部分) 为了做到这点，需要使用@Test 注解的dependsOnMethods属性或者
d e p e n d s On G r o u p s 属 性 。
有两种依赖:
* 强依赖。在运行你的测试方法前所有依赖方法必须运行并且成功。哪怕 有 一个依赖方法失败，测试方法都不会被调用，• 在报告中将被标记为SKIP。
* 软依赖。测试方法在依赖方法运行后总是会被运行，即使某些依赖方法 失败。对于只想确认测试方法是按照特定顺序运行，而测试方法并不真正依赖其 他方法是否成功的情况，非常有用。软依赖通过在@Te st 注解中增加
〞a l v a y s R u n = t r u e ” 来 实 现 。
这里有 一个强依赖的例子:

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

在这个例子中，net hod l (被申明依赖于方法 ser ver St ar t edok 0 ，这保证 ser verStartedok(方法将总是首先被调用。
也可以让方法依赖于完整的测试组:

@Test(groups= {"init" }) 
public void serverStartedok() {}

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

@Test(dependsOnGroups = {“init.* }) 
public void methodi (){}

在这里例子中，methodl(被中明依赖于任何匹配正则表达式〞init. *”的组， 这 保 证 了 方 法 s e r v e r S t a r t e d o k 0 和 i n i t E n v i r o n m e n t 0 总 是 在 me t h o d 1 Q 前 被 调用。
注意:前面说明说，在测试运行期间，属于同 一个组的方法的调用顺序并不保 证相同。如果一个方法的依赖失败了，而且是强依赖(默认al waysRun=false)， 这 个 方 法 将 不 被 标 记 为 F A I L 而 是 S K I P 。 被 跳 过 的 方 法 在 最 终 的 报 告 中 报 告 (在 HTML中用红和绿之外的其他颜色)，这很重要，因为被跳过的方法并不一定是 失败。
dependsOnGroups 和dependsOnvethods 都接受正则表达式作为参数。对于 dependsOnMet hods，如果你依赖的方法巧合有多个重载的版本，所有装载的方法 都将被调用。如果你只想调用重载的方法中的 一个，请使用dependsOnGroups。
有关方法依赖的更高级的例子，请参考本文档，将使用继承来提供 一个优雅 的解决方案来处理多重依赖的问题。

5.7- Factories
工厂类容许你动态创建测试案例。例如，想象你需要创建一个测试方法，访 问一个web 站点 上的页面很多次，而你希望用不同的值来调用它:

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

testng.xml:

<test name="TI">
    <parameter name="number-of-times" value="10"/>
    <class name= "TestWebServer" /> 
</test>

<test name="Т2">
    <parameter name="number-of-times" value="20"/> 
    <class name= "TestWebServer" />
</test>
<test name="Т3")
    <parameter name="number-of-times" value="30"/>
    <class name= "TestWebServer"/> 
</test>

这种方式很快就会变的难于管理，所以作为替换品，你可以使用factory:

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

而新的测试类是这样:
 

public class Weblest {
    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
        }
    }
}

testng. xml 只需要引用简单引用这个包含factory方法的类，因为测试实例将 在运行时被创建。
sclass name="WebTestFactorv" /
工厂类将像@Test 和@Before/After一样接收参数，必须返回Object又]。返 回 的 对 象 可 以 是 任 何 类 (不 一 定 要 求 是 和 f a c t o r y 类 一 样 ) ， 并 且 他 们 甚 至 都 不 需要包含TestNG的注解 (这种情况下他们将被testNG忽略)

Te s t NG 官 方 文档 中文版 ( 8 ) -类级别注解和并发

5. 8 - Class level annotations
@Test 注解可以放置在类上:

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

    public void test2 () { 
    }
}

类 级 别 注 解 的 效 果 是 将 这 个 类 的 所 有 的 p u b l i c 方 法 都 变 成 测 试 方 法 ，即 使 他 们 没有被注解。还可以在需要增加属性的方法上重复@Test 注解
例如:

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

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

将方法test10 和test2(都变成测试方法，但是在此之上，test2(现在属 于组〞g1”
5.9 - Parallel running and time-outs
可以通过使用parallel 属性要求TestNG在单独的线程中运行测试。这个属 性可以在两个值中取其一:

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

* p a r a l l e l = 〞me t h o d s ” : T e s t NG 将 在 单 独 的 线 程 中 运 行 测 试 方 法 ， 除 了 那 些依赖其他测试方法的，这些将在同 一个线程中运行，以保证他们的执行顺序。
*parallel="tests":TestvG将在 一个线程中运行所有在同 一个‹test> 标签中的测试方法，但是每个<tes t>标签将在单独的线程中运行。这 种方式容
许 把 所 有 不 是 线 程 安 全 的 类 分 组 到 相 同 的 < t e s t > 标 签 中 ，保 证 他 们 将 在 相 同 的 线 程 中 运 行 ， 有 利 于 T e s t NG 使 用 尽 可 能 多 的 线 程 来 运 行 测 试 。
此外，thread- count 属性容许指定运行时将分配多少线程。 注意:@Test的属性timeOut 在并发和非并发模型下都可以工作。
也 可 以 指 定 @T e s t 方 法 在 不 同 的 线 程 中 被 调 用 。 可 以 使 用 t h r e a d P o o l s i z e 属性水实现这样的结果:

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

在这个例子中，方法testServer 将被了个不同线程调用10次。此外，10
秒 种 的 t i me - o u t 属 性 保 证 任 何 线 程 都 不 会 长 时 间 阻 塞 。