TestNG简略的学习(十二)TestNG运转ITeye - AG环亚娱乐集团

TestNG简略的学习(十二)TestNG运转ITeye

2019年03月01日13时24分44秒 | 作者: 寄松 | 标签: 运转,办法,测验 | 浏览: 1483

文档来自官方地址:

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

 

 1. 介绍
    TestNG是一个规划用来简化广泛的测验需求的测验结构,从单元测验(阻隔测验一个类)到集成测验(测验由有多个类多个包乃至多个外部结构组成的整个别系,例如运用服务器)。

    编写一个测验的进程有三个典型进程:

    * 编写测验的 事务逻辑并在代码中刺进TestNG annotation
    * 将测验信息添加到testng.xml文件或许build.xml中
    * 运转TestNG

在欢迎页面上能够找到快速入门示例。

下面是这篇文档运用的概念:

    * suite由xml文件描绘。它包括一个或多个测验并被界说为 suite 标签
    * test由 test 描绘并包括一个或许多个TestNG类
    * TestNG类是包括至少一个TestNG annotation的java类,由 class 标签描绘并包括一个或多个测验办法
    * 测验办法是源文件中带有@Testd注释的java办法

    TestNG测验能够被@BeforeXXX 和 @AfterXXX annotations装备,容许在特定点的前后履行一些java逻辑,这些点上面现已列出。

这份手册的剩下部分将叙述以下内容:

    * 一切的annotation列表并带有简略阐明,为TestNG的多种功用性供给参阅, 你或许需求参阅为每个annotation供给的代码片段来学习细节。

     * testng.xml文件描绘,它的语法和假如指定它。
    * 多个特性的具体列表和怎样结合annotation和testng.xml来运用它们

*******************************************************************************

注:上面的内容很简略,可是请留意其间的一些细节。

1. TestNG是一个规划用来简化广泛的测验需求的测验结构,从单元测验到集成测验
    这个是TestNG规划的起点,不只是是单元测验,而且能够用于集成测验。规划方针的不同,比照junit的只合适用于单元测验,TestNG无疑走的更远。
    能够用于集成测验,这个特性是我挑选TestNG的最重要的原因。

2. 测验的进程的三个典型进程,留意和junit(4.0)比较,多了一个将测验信息添加到testng.xml文件或许build.xml
    测验信息尤其是测验数据不再写死在测验代码中,优点就是修正测验数据时不需求修正代码/编译了,然后有助于将测验人员引进单元测验/集成测验。

3. 基本概念,比较junit的TestCase/TestSuite,TestNG有suite/test/test method三个等级,行将test/test method明晰区别开了。
    junit中的TestCase将test/test method混合,比较简略让人概念不明晰,尤其是新手。

2 - Annotation

这儿是TestNG顶用到的annotation的快速预览,还有它们的特点。


@BeforeSuite:        被注释的办法将在一切测验运转前运转
@AfterSuite:        被注释的办法将在一切测验运转后运转
@BeforeTest:        被注释的办法将在测验运转前运转
@AfterTest:        被注释的办法将在测验运转后运转
@BeforeGroups:        被装备的办法将在列表中的gourp前运转。这个办法确保在第一个归于这些组的测验办法调用前当即履行。
@AfterGroups:        被装备的办法将在列表中的gourp后运转。这个办法确保在终究一个归于这些组的测验办法调用后当即履行。
@BeforeClass:        被注释的办法将在当时类的第一个测验办法调用前运转。
@AfterClass:        被注释的办法将在当时类的一切测验办法调用后运转。
@BeforeMethod:        被注释的办法将在每一个测验办法调用前运转。
@AfterMethod:        被注释的办法将在每一个测验办法调用后运转。
特点:
    alwaysRun    关于每个bufore办法(beforeSuite, beforeTest, beforeTestClass 和 beforeTestMethod, 可是不包括 beforeGroups):
                假如设置为true,被装备的办法将总是运转而不管它归于哪个组。
                关于after办法(afterSuite, afterClass, ...): 假如设置为true,被装备的办法乃至在一个或多个先调用的办法失利或被疏忽时也将运转。
    dependsOnGroups        这个办法依靠的组列表
    dependsOnMethods    这个办法依靠的办法列表
    enabled            这个类的办法是否激活
    groups            这个类或办法所属的分组列表
    inheritGroups        假如设置为true,这个办法被归于在类等级被@Test annotation指定的组
 
@DataProvider    符号一个办法用于为测验办法供给数据。
                被注释的办法有必要回来Object[][], 其间每个Object[]能够指使为这个测验办法的参数列表。
                从这个DataProvider接纳数据@Test办法需求运用一个和当时注释相同称号的dataProvider称号
    name         这个DataProvider的称号
 
@Factory    符号办法作为一个回来目标的工厂,这些目标将被TestNG用于作为测验类。这个办法有必要回来Object[]
 
@Parameters    描绘怎么传递参数给@Test办法
    value    用于填充这个办法的参数的变量列表
 
@Test        符号一个类或办法作为测验的一部分
    alwaysRun     假如设置为true,这个测验办法将总是运转,乃至当它依靠的办法失利时。
    dataProvider     这个测验办法的data provider的称号
    dataProviderClass     用于查找data provider的类。
                    假如不指定,将在当时测验办法地点的类或许它的基类上查找data provider。
                    假如这个特点被指定, 则data provider办法需求是指定类的static办法。
    dependsOnGroups     当时办法依靠的组列表
    dependsOnMethods     当时办法依靠的办法列表
    description     当时办法的描绘
    enabled     当时类的办法/办法是否被激活
    expectedExceptions     测验办法期望抛出的反常列表。假如没有反常或许抛出的不是列表中的任何一个,当时办法都将符号为失利.
    groups     当时类/办法所属的组列表
    invocationCount     当时办法被调用的次数
    successPercentage     当时办法期望的成功率
    sequential     假如设置为true,当时测验类上的一切办法确保依照次序运转。乃至测验们在parallel="true"的状况下.
            这个特点只能用于类等级,假如用于办法等级将被疏忽。
    timeOut     当时办法容许花费的最大时刻,单位毫秒。
    threadPoolSize     当时办法的线程池巨细。办法将被多线程调用,次数由invocationCount参数指定
            留意:假如invocationCount没有指定则这个特点将被疏忽


注:
    上面是TestNG顶用到的annotation列表,从中咱们能够看到TestNG供给的一些特性

1. before办法和after办法    带来了满意丰厚的测验生命周期操控
2. dependsOnGroups/dependsOnMethods 供给了依靠检查机制,并能够严格操控履行次序
3. DataProvider 使得对同一个办法的测验掩盖变的十分轻松,十分合适进行鸿沟测验,只需给出多种测验数据就能够针对一个测验办法进行掩盖
4. expectedExceptions 使得反常测验变的十分轻松
5. invocationCount/threadPoolSize 总算能够简略的直接进行多线程测验了,这个肯定是junit的超级弱项,回想junit中那个万恶的System.exist(0)...
6. timeOut 总算不用死等然后手艺强行封闭测验,TestNG想的太周到了

TestNG官方文档中文版(3)-testng.xml
    TestNG的官方文档的中文翻译版第3章,原文请见 http://testng.org/doc/documentation-main.html

    3 - testng.xml

    调用TestNG由几种不同办法:

    * 运用testng.xml文件
    * 运用ant
    * 从指令行

    这节描绘testng.xml的格局(文档的后边会讲到ant和指令行)。

    当时testng.xml的DTD文件能够从官方找到:http://testng.org/testng-1.0.dtd。(为了便当运用,你或许更喜爱阅读HTML版别)。
    下面是testng.xml文件的一个比方:


!DOCTYPE suite SYSTEM "http://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 "http://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 "http://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 "http://testng.org/testng-1.0.dtd"  
suite name="Suite1" verbose="1"  
  test name="Regression1"    
    packages  
      package name="test.sample" /  
   /packages  
  /test  
/suite  
 
    在这个比方中,TestNG将在包test.sample中查找一切的类,并只保存带有TestNG annotation的类。

    你相同能够指定包括或不包括的组和办法:


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  

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  
 
    你相同能够在testng.xml中界说新的组,指定特点的额定具体状况,比方是否并行运转测验,运用多少线程,是否运转junit测验,等等...
    请检查DTD文件了解完好的特性列表。

4 - 运转TestNG

TestNG能够以不同的办法调用:

    * Command line
    * ant
    * Eclipse
    * IntelliJs IDEA

1) 指令行

假定你现已将TestNG加入到class path,调用TestNG最简略的办法事下面的:

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

有必要指定最少一个描绘你企图测验的TestNG suite的xml文件。别的,下面的指令行参数能够运用:

指令行参数列表

选项        参数                文档阐明
-d        一个目录            生成陈述的目录( test-output)
-sourcedir    分号离隔的目录列表        带有javadoc注释的测验源文件目录. 这个选项只在运用javadoc类型的annotation时才有用.
                        (例如 "src/test" or "src/test/org/testng/eclipse-plugin;src/test/org/testng/testng").
-testclass    能够在classpath途径中找到的逗号分隔的类列表。逗号分隔的类文件列表(例如 "org.foo.Test1,org.foo.test2").
-groups        逗号分隔的组列表        要运转的组列表(例如 "windows,linux,regression").
-excludegroups    逗号分隔的组列表        不想包括在这次运转中的组列表
-testrunfactory    能够在classpath中找到的java类    指定测验的runner.这个类需求完结接口org.testng.ITestRunnerFactory .
-listener    能够在classpath途径中找到的逗号分隔的类列表。    指定测验的listener. 这个类需求完结接口org.testng.ITestListener
-parallel    methods|tests            假如指定, 设置运转测验时怎么运用并发线程的默许机制.假如不设置,默许机制是彻底不运用并发线程。这个设置能够被suite界说掩盖.
-threadcount    并发测验运转时默许运用的线程数    用于设置并发测验时默许的线程数. 只在并发办法被挑选时才收效 (例如, 翻开 -parallel 选项). 这个设置能够被suite界说掩盖.
-suitename    测验套件运用的默许称号.        指定在指令行上界说的测验套件的称号。假如suite.xml文件或源代码指定了别的一个不同的套件称号,这个选项将被疏忽。能够创立带空格的套件称号,假如在称号前后加双引号如"like this".
-testname    测验运用的默许称号.        指定在指令行上界说的测验的称号。假如suite.xml文件或源代码指定了别的一个不同的测验称号,这个选项将被疏忽。能够创立带空格的测验称号,假如在称号前后加双引号如"like this".
-reporter    扩展装备用于自界说陈述listenner.    相似 -listener 选项, 除了容许reporter示例上由javabean办法的装备.
    例如: -reporter com.test.MyReporter:methodFilter=*insert*,enableFiltering=true

能够经过不带任何参数直接调用TestNFG来取得这个文档。

能够将指令行开关写到txt文件中,例如c:/command.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.xml

TestNG能够了解的参数
特点             类型                     文档
testng.test.classpath     分号分隔的包括测验类的一系列目录     假如这个特点被设置,TestNG将运用它代替从class path来查找测验类. 假如你正在运用在xml文件里边的包标签而且在classpath途径中由许多类而大部分都不是测验类的时分比较便当

举例:

java org.testng.TestNG -groups windows,linux -testclass org.test.MyTest

留意 ant 使命和testng.xml容许用更多的参数来发动TestNG(包括的办法,指定的参数,等等),因而能够以为指令行适用于学习TestNG而且想快速入门。


2) Ant

能够这样界说TestNG的ant使命:

taskdef resource="testngtasks"
         classpath="testng.jar"/

这个使命运转TestNG测验,而且通常是在独自的jvm中。承受下面的特点:

特点名            描绘                是否有必要
annotations         字符串"JDK"或许"Javadoc". 界说测验适用的注释类型.假如运用"Javadoc", 则需求一起指定"sourcedir".     不是有必要. 假如适用jkd5则默许为"JDK",假如适用jdk1.4则默许为"Javadoc"
classfilesetref     要运转的测验类的FileSet结构的引证.     
classpath         要运转的测验的PATH-like 结构.     
classpathref         要运转的测验的PATH-like 结构的引证.     
dumpCommand         打印TestNG发动指令.     不是有必要,默许false
enableAssert         敞开JDK 1.4的断语.     不是有必要,默许true
failureProperty     失利发作时要设置的特点的称号. 只要haltonfailure没有设置时才有用.     不是有必要.
haltonfailure         假如测验运转期间发作失利,中止结构进程.     不是有必要,默许false
haltonskipped         假如发作至少一次测验越过,中止结构进程.        不是有必要,默许false
groups             要运转的组列表,空格或逗号分隔   
excludedgroups         扫除在外的组列表,空格或逗号分隔
jvm             运用的jvm,将被Runtime.exec()运转     java
listeners         逗号或空格分隔的全途径类列表,需求完结org.testng.ITestListener或org.testng.IReporter     不是有必要
outputdir         陈述输出目录             不是有必要,默许输出到test-output.
skippedProperty     当发作测验被越过期设置的property的称号.只要当haltonskipped没有设置时才运用     不是有必要
sourcedir         用于jdk1.4测验的PATH-like结构(运用JavaDoc办法的annotations)     
sourcedirref         用于jdk1.4测验的PATH-like结构的引证(运用JavaDoc办法的annotations)          
suiteRunnerClass     TestNG发动器的全途径称号    不是有必要.  默许运用org.testng.TestNG
parallel         运转测验时运用的并行办法 - methods或许tests     不是有必要 - 假如没有指定,并行办法不被挑选
threadCount         运转时运用的线程数量。假如并行办法被一起指定不然疏忽。     默许1
testJar         包括测验和套件界说的jar包途径
timeOut         一切测验有必要运转完结的最大超时时刻,单位毫秒
useDefaultListeners     是否运用默许监听器和陈述器.     默许true.
workingDir         运转TestNG前ant使命应该转移到的目录。
xmlfilesetref        用于要测验的套件界说的FileSet结构的引证     
suitename         设置测验套件的默许称号假如在suite的xml文件或许源代码中都没有被界说。    不是有必要,默许设置为"Ant suite"
testname        设置测验的默许称号假如在suite的xml文件或许源代码中都没有被界说。    不是有必要,默许设置为"Ant test"


特点classpath, classpathref或许内嵌的 classpath 有必要设置一个,用于供给测验的classpath

特点xmlfilesetref, classfilesetref 或许内嵌的 xmlfileset , 别离的 classfileset 有必要运用用来供给测验

留意:假如运用jdk1.4,特点attributes sourcedir, sourcedirref 或许内嵌的 sourcedir 有必要供给.

留意:运用 classfileset 并不主动按添加测验类到classpath: 需求陈述这些在classpath中的使命要作业的类

内嵌元素
classpath
  testng 使命支撑一个内嵌的 classpath 元从来供给PATH-like的结构.

bootclasspath
bootstrap类文件的方位能够用这个PATH办法的结构指定-假如fork没有设置则被疏忽

xmlfileset
套餐界说(testng.xml)能够经过一个FiltSet结构传递给使命

classfileset
TestNG能够直接在类上运转,相同支撑FiltSet结构

sourcedir
PATH办法的结构,用于jdk1.4的测验,运用javadoc annotation

jvmarg
经过内嵌的 jvmarg 元素将额定的参数传递给新的虚拟机,例如:

testng
   jvmarg value="-Djava.compiler=NONE" /
   ! ...
/testng

sysproperty
运用内嵌的 sysproperty 元从来指定类需求的体系特点。在测验的履行期间虚拟机能够获取这些特点。 这个元素的特点和环境变量相同。


testng  
   sysproperty key="basedir" value="${basedir}"/  
   ! ...  
/testng  

testng  
   sysproperty key="basedir" value="${basedir}"/  
   ! ...  
/testng  

将运转测验而且使得测验能够拜访basedir特点
reporter

内部的 reporter 元素是一个可选的办法,用于注入自界说的陈述监听器,容许用户为调整运转时的陈述期行为而
这个元素强制要求设置classname特点,指示自界说监听器的类。为了设置陈述期特点, reporter 元素能够包括多个内嵌的 property 元从来供给name和value特点,如下所示:

 

请留意这儿只是支撑有限的特点类型:String, int, boolean, byte, char, double, float, long, short.

env
能够经过内嵌的 env 元素给TestNG的独自的虚拟机传递指定的环境变量。
要查阅 env 元素特点的具体描绘,请检查ant的exec使命的描绘。

举例:
Suite xml


testng classpathref="run.cp" 
        outputDir="${testng.report.dir}" 
        sourcedir="${test.src.dir}" 
        haltOnfailure="true"  
  
   xmlfileset dir="${test14.dir}" includes="testng.xml"/  
/testng  

testng classpathref="run.cp" 
        outputDir="${testng.report.dir}" 
        sourcedir="${test.src.dir}" 
        haltOnfailure="true"  
  
   xmlfileset dir="${test14.dir}" includes="testng.xml"/  
/testng  
 
Class FileSet

testng classpathref="run.cp"
        outputDir="${testng.report.dir}"
        haltOnFailure="true"M verbose="2"
    classfileset dir="${test.build.dir}" includes="**/*.class" /
/testng

5 - Test methods, Test classes and Test groups
5.1 - Test groups

TestNG容许履行杂乱的测验办法分组。不只能够声明办法归于组,而且能够指定分组包括其他分组。
然后TestNG能够被调用,并被要求包括某些分组和扫除其他的分组。
这将供给怎样区分测验的最大弹性,而且假如想运转两个不同的测验设备不需求从头编译。

例如,十分遍及的需求至少两个品种的测验

    * Check-in tests.  这些测验将在提交新代码之前运转. 它们典型的被要求快速而且只是承认没有基础功用被损坏。
    * Functional tests.  这些测验将掩盖一切的软件功用,而且有必要运转至少1天,尽管抱负的是接连运转.

代表性的,check-in测验是功用性测验的子集。TestNG容许用十分直接的办法阐明这个。
例如: 能够这样结构测验,声明完好的测验类归于"functest"组,别的两个办法归于组"checkintest":


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

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="example1.Test1"/  
  /classes  
/test  

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

将运转在类中的一切测验办法,假如运用checkintest调用则将只运转testMethod1()和testMethod2().
这儿由其他比方,这次运用正则表达式。假定某些测验办法或许无法在Linux上运转,测验将是相似如此:


@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 
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="Test1"  
  groups  
    run  
      include name="windows.*"/  
    /run  
  /groups  
  classes  
    class name="example1.Test1"/  
  /classes  
/test  

test name="Test1"  
  groups  
    run  
      include name="windows.*"/  
    /run  
  /groups  
  classes  
    class name="example1.Test1"/  
  /classes  
/test  
 
留意:TestNG运用正则表达,而不是wildmats。留意这个不同。

Method groups
相同能够包括或扫除单个办法:


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

test name="Test1"  
  classes  
    class name="example1.Test1"  
      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 file:
组能够包括其他组。这些组被称为"MetaGroups"。例如,你或许想界说一个"all"组,包括"checkintest"和"functest"。"functest"本身将包括组 "windows" 和 "linux",而"checkintest"将包括"windows".


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  

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  
 
5.3 - Exclusion groups

TestNG 容许包括组也容许扫除组.

例如,当由由于最近的修正而暂时损坏的测验而又没有时刻去修正它们时十分有用。无论怎么,你想要洁净的运转功用性测验,因而你想要是这些测验失效,可是记住它们从头被激活。
一个简略的处理这个问题的办法是创立一个称为"broken"的组并让这些测验办法归属它。例如,在上面的比方中,我知道testMethod2() 现在被损坏了,一切我想封闭它:


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

@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 name="Simple example"  
  groups  
    run  
      include name="checkintest"/  
      exclude name="broken"/  
    /run  
  /groups  
  
  classes  
    class name="example1.Test1"/  
  /classes  
/test  
 
用这种办法,我将得到一个洁净的测验运转,一起记录了那些被损坏并想要后续修正的测验。
留意:你也能够经过运用在@Test and @Before/After annotations上的"enabled"特点在个别的层面上封闭测验,

5.4 - Partial groups
你能够在类的等级上界说组,然后在办法的层次上添加组:


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

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

 
在这个类中,method2() 归于组"checkin-test",在类的等级界说。而method1() 一起归于 "checkin-test" 和 "func-test".
5.5 - Parameters

测验办法不要求是无参数的。你能够在每个测验办法上运用恣意数量的参数,并指示testNG传递正确的参数。
有两种办法用于设置参数:运用testng.xml或许编程式。

  5.5.1 - Parameters from testng.xml
假如你要为你的参数运用简略值,你能够在你的testng.xml中明晰指定:


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

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

在这个代码中,咱们明晰指定java办法的参数“firstName”应该接纳名为“first-name”xml参数的值。 这个xml参数在testng.xml中界说:

suite name="My suite"
  parameter name="first-name"  value="Cedric"/
  test name="Simple example"
   
相同的办法能够用于注解@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; 

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

这次,两个java参数ds和driver将别离接纳被设置给特点datasource和jdbc-driver的值。
参数能够经过可选注解来声明为可选:
@Parameters("db")
@Test
public void testNonExistentParameter(@Optional("mysql") String db) {  }
假如在testng.xml文件中没有找到名为"db"的参数,测验办法将承受在@Optional注解中指定的默许值:"mysql"
@Parameters 注解能够在下面方位运用:
    * 在任何有@Test, @Before/After或许@Factory注解的办法上
    * 在测验类的最多一个结构函数上。这种状况下,当TestNG需求实例化测验类时,他将调用这个特别的带有初始化为testng.xml中指定的值的参数的结构函数。这个特性能够被用于初始化类内部的值域为将用于测验办法的值。
    留意:
        * xml参数被以在注解中呈现的相同次序映射到java参数,假如参数数量不匹配testNG将发作过错。
        * 参数是有规模的。在testng.xml中,你能够在 suite 标签或许 test 标签下声明参数。假如两个参数同名,在 test 标签下界说的参数优先。十分适用于这样的场合:需求指定一个应用于一切测验的参数,可是又期望在特定测验用掩盖它的值。

  5.5.2 - Parameters with DataProviders

在testng.xml中指定参数,关于以下状况是不行的:
    * 不运用testng.xml
    * 需求传递杂乱参数,或许参数需求从java中创立(杂乱目标,从特点文件或许数据库中读取的目标)在这种状况下,你能够运用Data Provider来供给你测验需求的数值。Data Provider是类中的一个回来目标数组的数组的办法。这个办法带有@DataProvider注解:

//这个办法将供给数据给任何声明它的Data Provider名为"test1"的测验办法


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

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

 
//这个办法声明它的数据将由名为"test1"的Data Provider供给


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

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

 
将打印
    Cedric 36
    Anne 37
@Test办法用dataProvider特点来指定它的Data Provider。这个姓名有必要契合同一个类顶用@DataProvider(name="...")注解的办法,它们要运用同一个匹配的姓名。
默许,将在当时类或许它的基类中查找data provider。假如你想将data provider放置到另一个类中,需求将这个data provider办法设置为静态办法,并在dataProviderClass特点中指定在哪个类中能够找到这个办法。


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

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[][]) ,外围数据的巨细是测验办法将被调用的次数,而内层数组的巨细和类型有必要和测验办法的参数列表匹配。好像上面举例阐明的。
    * Object[] 的Iterator,和Object[][]的仅有不同在于Iterator容许推迟创立测验数据。testNG将一个接一个的调用iterator,再用iterator回来的参数调用测验办法。假如有许多参数调集需求传递给办法而又不想一开端就创立一切参数,会十分有用。

Here is an example of this feature for both JDK 1.4 and JDK5 (note that the JDK 1.4 example does not use Generics):
这儿有一个一起适用于JDK 1.4和JDK5的比方(留意JDK 1.4的比方不运用注解):


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

@DataProvider(name = "test1") 
public Iterator createData() { 
  return new MyIterator(DATA); 

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

@DataProvider(name = "test1") 
public Iterator createData() { 
  return new MyIterator(DATA); 

 
假如将测验办法的第一个参数声明为java.lang.reflect.Method,TestNG将运用这个第一个参数来传递当时测验办法。当多个测验办法运用同一个@DataProvider而需求依当时请求数据的办法而定来回来不同值时特别有用。
举例阐明,下面的代码在@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) { 

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

 
将会显现:
    test1
    test2

5.6 - Dependent methods

有些时分,你需求你的测验办法依照一个特定的次序被调用。这十分有用,比方:
    * 在运转更多测验办法前承认特定数量的测验办法调用完结而且成功
    * 初始化测验并期望这个初始化办法也作为测验办法(被符号为@Before/After的办法将不作为终究陈述的一部分)

为了做到这点,需求运用@Test注解的dependsOnMethods特点或许dependsOnGroups特点。
有两种依靠:
    * 强依靠。在运转你的测验办法前一切依靠办法有必要运转而且成功。哪怕有一个依靠办法失利,测验办法都不会被调用,在陈述中将被符号为SKIP。
    * 软依靠。测验办法在依靠办法运转后总是会被运转,即便某些依靠办法失利。关于只想承认测验办法是依照特定次序运转,而测验办法并不真实依靠其他办法是否成功的状况,十分有用。软依靠经过在@Test注解中添加"alwaysRun=true"来完结。

这儿有一个强依靠的比方:

@Test
public void serverStartedOk() {}

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

在这个比方中,method1()被声明依靠于办法serverStartedOk(),这确保serverStartedOk() 办法将总是首要被调用。
也能够让办法依靠于完好的测验组:

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

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

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

在这儿比方中,method1()被声明依靠于任何匹配正则表达式"init.*"的组,这确保了办法serverStartedOk()和initEnvironment()总是在method1()前被调用。

留意:前面阐明说,在测验运转期间,归于同一个组的办法的调用次序并不确保相同。假如一个办法的依靠失利了,而且是强依靠(默许alwaysRun=false),这个办法将不被符号为FAIL而是SKIP。被越过的办法在终究的陈述中陈述(在HTML顶用红和绿之外的其他色彩),这很重要,由于被越过的办法并纷歧定是失利。

dependsOnGroups和dependsOnMethods都承受正则表达式作为参数。关于dependsOnMethods, 假如你依靠的办法偶然有多个重载的版别,一切装载的办法都将被调用。假如你只想调用重载的办法中的一个,请运用dependsOnGroups。

有关办法依靠的更高档的比方,请参阅本文档,将运用承继来供给一个高雅的处理方案来处理多重依靠的问题。

5.7 - Factories

工厂类容许你动态创立测验事例。例如,幻想你需求创立一个测验办法,拜访一个web站点上的页面许屡次,而你期望用不同的值来调用它:

 


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

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

 
testng.xml:


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

test name="T1"  
  parameter name="number-of-times" value="10"/  
  class name= "TestWebServer" /  
/test  
test name="T2"  
  parameter name="number-of-times" value="20"/  
  class name= "TestWebServer"/  
/test  
test name="T3"  
  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 i++) { 
      result[i] = new WebTest(i * 10); 
    return result; 
  } 

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

 
而新的测验类是这样:


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 
    } 
  } 

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 
    } 
  } 

 
testng.xml只需求引证简略引证这个包括factory办法的类,由于测验实例将在运转时被创立。

class name="WebTestFactory" /
工厂类将像@Test和@Before/After相同接纳参数,有必要回来Object[]。回来的目标能够是任何类(纷歧定要求是和factory类相同),而且他们乃至都不需求包括TestNG的注解(这种状况下他们将被testNG疏忽)。

5.8 - Class level annotations

@Test注解能够放置在类上:


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

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

 
类等级注解的作用是将这个类的一切的public办法都变成测验办法,即便他们没有被注解。还能够在需求添加特点的办法上重复@Test注解。

例如:


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

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

 
将办法test1()和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"
    * parallel="methods": TestNG将在独自的线程中运转测验办法,除了那些依靠其他测验办法的,这些将在同一个线程中运转,以确保他们的履行次序。

    * parallel="tests": TestNG将在一个线程中运转一切在同一个 test 标签中的测验办法,可是每个 test 标签将在独自的线程中运转。这种办法容许把一切不是线程安全的类分组到相同的 test 标签中,确保他们将在相同的线程中运转,有利于TestNG运用尽或许多的线程来运转测验。

    此外,thread-count特点容许指定运转时将分配多少线程。
   
    留意:@Test的特点timeOut在并发和非并发模型下都能够作业。

    也能够指定@Test办法在不同的线程中被调用。能够运用threadPoolSize特点来完结这样的成果:

@Test(threadPoolSize = 3, invocationCount = 10,  timeOut = 10000)
public void testServer() {
}
在这个比方中,办法testServer将被3个不同线程调用10次。此外,10秒种的time-out特点确保任何线程都不会长时刻堵塞。


5.10 - Rerunning failed tests

套件中的测验失利时,每次testNG都会在输出目录中创立一个名为testng-failed.xml的文件。这个xml文件包括只从头运转这些失利的测验办法的必要信息,容许只运转这些失利的测验而不用运转悉数测验。因而,一种典型的状况将是这样:

java -classpath testng.jar;%CLASSPATH% org.testng.TestNG -d test-outputs testng.xml
java -classpath testng.jar;%CLASSPATH% org.testng.TestNG -d test-outputs test-outputs/testng-failed.xml
留意testng-failed.xml将包括一切必要的依靠办法,所以能够确保运转失利的办法而不运转任何被越过的(失利)办法。

5.11 - JUnit tests

TestNG能够运转junit测验。所需求的只是在testng.classNames特点中指定junit测验类,并设置testng.junit特点为true。

test name="Test1"   junit="true"
  classes
    ! 
这种状况下TestNG的行为相似jnit:

    * 类中一切以test*最初的办法将被运转。
    * 假如测验类中有办法setUp(), 将在每次测验办法调用前被履行。
    * 假如测验类中有办法tearDown(),将在每次测验办法调用后被履行。

5.12 - JDK 1.4

TestNG也能够在JDK1.4下作业。在这种状况下,需求运用发布的jdk1.4的jar文件(名为testng-...-jdk14.jar)。仅有的不同是在于注解,jdk1.4下运用盛行的XDoclet javadoc注解语法:

public class SimpleTest {


 /**
  * @testng.before-class = "true"
  */ 
  public void setUp() { 
    // code that will be invoked when this test is instantiated 
 } 
 /**
  * @testng.test groups = "functest" dependsOnGroups = "group1,group2"
  */ 
  public void testItWorks() { 
    // your test code 
 } 

 /**
  * @testng.before-class = "true"
  */ 
  public void setUp() { 
    // code that will be invoked when this test is instantiated 
 } 
 /**
  * @testng.test groups = "functest" dependsOnGroups = "group1,group2"
  */ 
  public void testItWorks() { 
    // your test code 
 } 

javadoc语法的规矩十分简练,和jdk1.5注解的仅有不同是数组串数组需求特别写成独自的,逗号或空格分隔的字符串。尽管值周围的双引号是可选的,但仍是主张在任何状况下都运用双引号,以确保将来迁移到jdk1.5时能够比较简略。
相同需求在 testng 的ant使命中指明sourcedir特点(或许在指令行中运用-sourcedir),以便testNG能够找到你的测验文件的源代码来解析javadoc注解。

这儿是jdk1.4和jdk5注解的语法对照表:

    (表格在blog中欠好排版,不在这儿发了,具体内容请参阅官方文档的原文:http://testng.org/doc/documentation-main.html#jdk-14。)

更多jdk1.4的支撑典范,请参阅发行包中的test-14文件夹,这儿包括悉数的JDK 1.5测验对应的运用javadoc注解的内容。


5.13 - Running TestNG programmatically

在自己的程序中调用testNG也很简略:

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

这个典范创立了一个TestNG目标并运转测验类Run2。还添加了一个TestListener。你能够运用适配器类org.testng.TestListenerAdapter或自己完结org.testng.ITestListener。这个接口包括多个回调办法,使得能够追寻测验的开端,成功,失利等等。

相似的,能够运用testng.xml文件调用TestNG或许自己创立一个虚拟的testng.xml文件。为了做到这点,需求运用org.testng.xml包的类:XmlClass, XmlTest, 等等。每个类对应他们xml标签。

例如,假定你想创立下面的虚拟文件:

suite name="TmpSuite"
  test name="TmpTest"
    classes
      class name="test.failures.Child"  /
    classes
    /test
/suite
你将运用下面的代码:

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) ;
然后你能够将XmlSuite传递给TestNG:

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

完好的API请参阅javadoc。


5.14 - BeanShell and advanced group selection

假如testng.xml中的 include 和 exclude 标签还不满意满意你的需求,你能够运用BeanShell表达式来决议是否需求将一个特定的测验办法包括在测验操作中。只需求在 test 标签下指定这个表达式:


test name="BeanShell test"  
  method-selectors  
   method-selector  
     mce:script language="beanshell" !
       groups.containsKey("test1")
  /mce:script  
   /method-selector  
  /method-selectors  
!   

test name="BeanShell test"  
  method-selectors  
   method-selector  
     mce:script language="beanshell" !
       groups.containsKey("test1")
  /mce:script  
   /method-selector  
  /method-selectors  
!   

当发现testng.xml中有 script 标签,TestNG将疏忽当时 test 标签中的今后的组和办法的 include 和 exclude 标签:BeanShell表达式将是决议一个测验办法是否包括的仅有办法。
这儿有一些BeanShell脚本的额定信息:

    * 有必要回来boolean值。除了这个束缚,任何有用的BeanShell代码都被容许.(例如,你或许想在作业日回来true而在周末回来false,这将容许你愈加日期不同差异性的运转测验。

    * TestNG为了便当界说了以下变量:

        java.lang.reflect.Method method:  当时测验办法
        org.testng.ITestNGMethod testngMethod:  当时测验办法的描绘
        java.util.Map String, String groups:  当时测验办法所属组的Map

    * 你或许需求在你的表达式前后添加CDATA声明(如上面所示)以防止厌烦的xml转义字符

版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表AG环亚娱乐集团立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章