1.TestNG的运行方式如下：

1 With a testng.xml file           直接run as test suite
2 With ant                         使用ant
3 From the command line            从命令行
4 IDE                              直接在IDE中执行

在IDEA中直接运行的时候，需要说明的是：可以运行一个测试类，也可以单独运行一个测试的方法。

在IDEA里执行，只需要右键，点击 Run xxx 即可。 如果是在某一个方法的代码块里右键，出现的是 Run methodName ，即只运行当前的方法； 如果是在类的代码块里右键，出现的是 Run className ，即运行当前类中的所有Test方法； 也可以创建testng.xml，右键出现的 Run path/testng.xml ，即运行该配置文件中需要运行的方法。

2.TestNG常见的注解：

另外还有一些属性，

alwaysRun：对于每个bufore方法(beforeSuite, beforeTest, beforeTestClass 和 beforeTestMethod, 但是不包括 beforeGroups):
                　  如果设置为true，被配置的方法将总是运行而不管它属于哪个组。
                　  对于after方法(afterSuite, afterClass, ...): 如果设置为true，被配置的方法甚至在一个或多个先调用的方法失败或被忽略时也将运行。

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

dependsOnMethod：这个方法依赖的方法列表

enabled：这个类的方法是否激活

groups：这个类或方法所属的分组列表

inheritGroups：如果设置为true，这个方法被属于在类级别被@Test annotation指定的组例如：

  @Test(enabled = false)    //表示该测试用例不被执行
     public Object runTest() {
        xxxxxx
 }

3.testNG.xml配置详解：

testng.xml的基本格式可以在官网上查看，基本格式如下：

以下详细XML结构规则

suite
--tests
----parameters
----groups
------definitions
------runs
----classes
--parameters

比较详细的结构如下：

  <test name="xxxx">
  　　<!-- 参数定义的方法 -->
  　　<parameter name="first-name" value="Cedric"/>

  　　<!-- groups的用法，前提是需要存在classes的组，否则所有方法不被运行 -->
  　　<groups>
  　　<!-- 定义组中组的方法 -->
  　　　　<define name="groups_name">
  　　　　　　<include name="group1"/>
 　　　　　　<include name="group2"/>
 　　　　</define>

 　　　　<run>
 　　　　　　<!-- 此处用组名来区别 -->
 　　　　　　<inclue name="groups_name" />
 　　　　　　<exclue name="groups_name" />
 　　　　　　</run>
 　　</groups>

 　　<!-- classes的用法，classes中包含类名，类名底下可以包含方法名或排除方法名 -->
 　　<classes>
 　　　　<class name="class1">
 　　　　　　<methods>
 　　　　　　　　<!-- 此处用方法名来区别 -->
 　　　　　　　　<inclue name="method_name" />
 　　　　　　　　<exclue name="method_name" />
 　　　　　　</methods>
 　　　　</class>
 　　</classes>
 </test>

具体的元素说明：

<suite>   testng.xml文档中最上层的元素

说明：一个xml文件只能有一个<suites>,，是一个xml文件的根级

<suite>由<test>和<parameters>组成

参数说明：

parallel

　　该参数的值false，methods，tests，classes，instances。默认false

　　parallel必须和thread-count配套使用，否则相当于无效参数，thread-count决定了并行测试时开启的线程数量

　　parallel="mehods"  TestNG将并行执行所有的测试方法在不同的线程里

　　parallel="tests"  TestNG将并行执行在同一个<test>下的所有方法在不同线程里

　　parallel="classes"  TestNG将并行执行在相同<class>下的方法在不同线程里

　　parallel="instances"  TestNG将并行执行相同实例下的所有方法在不同的县城里

parent-module和guice-stage和Guice框架有关，testNG 6对Guice框架提供了支持，我没用过这个框架，所以这两个参数没看懂╮(╯▽╰)╭

-<suite-file>

说明：引入外部的xml文件（地址由path参数决定，path必填项），将引入的xml与当前的xml文件一起使用

声明方法：

 <suite-files>
      <suite-file path="/path/suitefile1"></suite-file>
 </suite-files>

-<test>

说明：一个<suite>下可以有多个<test>，可以通过<suite>的parallel="tests"来进行并行测试，必须和thread-count配套使用，否则是无效参数

<test>由<parameters>、<groups>、<classes>三部分组成

参数说明：

--<parameter>

说明：提供测试数据，有name和value两个参数

声明方法：<parameter name = "parameter_name" value = "parameter_value "/>

testng.xml文件中的<parameter>可以声明在<suite>或者<test>级别，在<test>下的<parameter>会覆盖在<suite>下声明的同名变量

--<method-selectors>

说明：方法选择器定义了哪些类的方法需要去执行，类必须继承自org.testng.IMethodSelector

声明方法：

 <method-selectors>
      <method-selector>
           <selector-class name="classname" priority="1"></selector-class>
           <script language="java"></script>    （language还可以用beanshell等）
      </method-selector>
 </method-selectors>

备注：<method-selectors>这个我没用过，所以了解，如果有错的欢迎指出来~

--<groups>

说明：要运行的组，可以自定义一个组，可以包括要执行的，还排除要执行的方法。必须和<classes>配套使用，从下面的类中找到对应名字的方法

<groups>由<difine>和<run>、<dependencies>三部分组成。<diffine>可以将group组成一个新组，包括要执行和不执行的大组；<run>要执行的方法；<dependencies>指定了某group需要依赖的group（比如下面的例子，group1需要依赖group2和group3先执行）。

声明方法：

  <groups>
       <define name ="all">
            <include name ="testgroup1"/>
            <exclude name ="testgroup2‘/>
       </define>
       <run>
            <include name ="all"/>
            <include name ="testmethod1"/>
            <exclude name="testmethod2"/>
      </run>
      <dependencies>
           <group name ="group1" depends-on="goup2 group3"/>
      </dependencies>
 </groups>

--<classes>

说明：方法选择器，要执行的方法写在这里，参数有name和priority。

注释：

1.<classes>下必须写要执行的<class>，否则不会执行任何内容，如果填写了class没有写methods，会按照填写的class的下的注释@Test去执行所有的方法

2.<classes>下的<methods>如果填写了<include>，那只会执行所填写的方法，没有填写的方法不会去执行

声明方法：

 <classes>
      <class name="要执行的class名">
           <methods>
                <include name ="要执行的方法名"></include>
           </methods>
      </class>
 </classes>

--<packages>

说明：<packages>指定包名代替类名。查找包下的所有包含testNG annotation的类进行测试

声明方法：

 <packages>
      <package name="packagename"/>
      <package name="packagename">
           <include name="methodname"/>
           <exclude name="methodname"/>
      </package>
 </packages>

<listener>

说明：指定listeners，这个class必须继承自org.testng.ITestNGListener。在java中使用@Listeners({com.example.MyListener.class,com.example.MyMethodInterceptor.class})的注释也可以有同样效果

声明方法：

 <listeners>
      <listener class-name="com.example.MyListener"/>
      <listener class-name="com.example.MyMehodIntercepor"/>
 </listeners>

（3）一个简单的testng.xml文档

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

  <suite name="Suite" parallel="classes" thread-count="3">
      <test verbose="2" preserve-order="true" name="TestDebug">

          <classes>
              <class name="com.hera.util.MathTest" />

         </classes>
     </test> <!-- Test -->
 </suite> <!-- Suite -->

说明：  suite定义一个测试套件，可以设置是否使用多线程，可包含多个测试用例或者测试group

parallel = classes  每个测试用例class级别多线程

thread-count =3  线程数为5，可同时执行3个case
           
 preserve-order = true   classes和methods按照配置中的顺序执行，false为乱序执行。（If you
want the classes and methods listed in this file to be run in an
unpredictible order, set the preserve-order attribute to false）

parameter 标签传递参数

4.TestNG参数化测试

testng提供测试数据的两个注释：@DataProvide和@Parameter

一、通过testng.xml中设置参数

（实际上testng.xml只是一个名字，可以起任何一个名字，只要是.xml文件，然后文件格式按照testng的文档格式DTD来就可以了）

testng.xml中的内容：

<?xml version="1.0" encoding="UTF-8" ?>
<suite name = "testngframetest">
    <parameter name="para" value="test_para1"/>
    <test name="测试参数赋值">
        <classes>
            <parameters>
                <parameter name="para1" value="test_para1"/>
                <parameter name="para2" value="test_para2"/>
            </parameters>
            <class name = "paramer">
                <methods>
                    <include name ="showparamer"></include>
                </methods>
            </class>
        </classes>
    </test>
</suite>

.java文件的测试用例中通过parameters获得数据

使用方法1：

@Test(parameters="para1")

public void testcase(String para1){

具体的测试用例，参数中的para1自动获取@Test中声明的变量，读取的是testng的xml文件中声明的参数para1的value值

}

如果有多个参数，可以使用这种方式：@Test(parameters={"para1","para2"})

使用方法2：

@Parameter({"para1","para2"})

@Test

具体的测试用例（参数@Parameter写在了@Test前面）

具体代码如下：

import org.testng.annotations.Test;
public class paramer {
    @Test(parameters ={"para1","para2"})
    public  void showparamer(String para11,String para22){
        System.out.println("testng获得的参数para1如下："+para11);
        System.out.println("testng获得的参数para2如下："+para22);;
    }
}

说明：

1.测试用例中设置的参数名随意，但是数量一定要和@Parameter中提供的数量一致，按照testng.xml中定义的顺序来取值的

2.<parameter>可以声明在<suite>或者<test>级别，在<test>下的<parameter>会覆盖在<suite>下声明的同名变量

3..java的测试用例中，可以通过@Optional("参数")来声明变量，如果没有在testng.xml中没有找到参数，会用@Optional("")中声明的参数

例如下面的代码，testng中没有声明para1和para2时，执行用例时会直接复制test1和test2

import org.testng.annotations.Optional;
import org.testng.annotations.Test;
public class paramer {
    @Test(parameters ={"para1","para2"})
    public  void showparamer(@Optional("test1") String para11, @Optional("test2") String para22){
        System.out.println("testng获得的参数para1如下："+para11);
        System.out.println("testng获得的参数para2如下："+para22);;
    }
}

二、通过注释@Dataprovide获得参数

（testng.xml只能传递简单的参数，如果是循环遍历的使用不同的参数则不可以实现。这时可以使用@Dataprovide来提供数据）

提供数据的方法：

@DataProvider(name = "dataprovider1")
public Object[][] dataprovide(){
    return new Object[][]{{1,2,3},{3,2,1}};
}

说明：

[email protected]只能返回Object数组结果

2.Object的行中的每一列标识一个参数（比如上面的例子是3个参数），行数决定了调用的方法要执行的次数（比如上面的例子是执行2次）

调用数据方法：

@Test(dataprovide="XXX")

说明：

1.XXX为@DataProvide声明的一个名字，返回的是一个Object数组

2.方法的执行次数为赋值参数的遍数。比如提供数组为1行，则只执行一次；如果是数组为3行，则执行3次。

其他扩展：

[email protected]写在单独的class里，增强复用性。

这时调用该数据的方法为：@Test(dataprovide="XXX",dataClass=YYY.class)

说明：读取YYY.class下的@DataProvide为XXX的Object数组数据

[email protected]下定义的数组，通过其他文件读取，比如读取excel，返回一个Object数组

[email protected]可以通过parallel实现并行执行线程，默认10个，可以在testng.xml中进行修改（<suite name="XXX" data-provider-thread-count="YYY">）

@DataProvider(name = "dataprovider1",parallel = true)
public Object[][] dataprovide(){
    return new Object[][]{{1,2},{2,1}};
}
@Test(dataProvider = "dataprovide")
public void showDataprovide(int a,int b,Method c){
    System.out.println("DataProvider获得的参数para1如下："+a);
    System.out.println("DataProvider获得的参数para2如下："+b);;
    System.out.println("DataProvider获得的参数para2如下："+c.getName());

}

[email protected]和@Parameters不能同时声明，但是可以通过其他方法实现同时使用。

String testId = context.getCurrentXmlTest().getParameter("test_id");

5.Testng的并发详解

在实际的自动化测试项目中，其实测试人员会遇到很多需要并发执行的情况，testng可以很轻松的解决此类问题，特补充此条

必须要指出的是，通过多线程执行用例时虽然可以大大提升用例的执行效率，但是我们在设计用例时也要考虑到这些用例是否适合并发执行，以及要注意多线程方式的通病：线程安全与共享变量的问题。

建议是在测试代码中，尽可能地避免使用共享变量。如果真的用到了，要慎用synchronized关键字来对共享变量进行加锁同步。否则，难免你的用例执行时可能会出现不稳定的情景

5.1 不同级别的并发

通常，在TestNG的执行中，测试的级别由上至下可以分为suite -> test -> class -> method，箭头的左边元素跟右边元素的关系是一对多的包含关系。

这里的test指的是testng.xml中的test tag，而不是测试类里的一个@Test。测试类里的一个@Test实际上对应这里的method。所以我们在使用@BeforeSuite、@BeforeTest、@BeforeClass、@BeforeMethod这些标签的时候，它们的实际执行顺序也是按照这个级别来的。

　　suite

一般情况下，一个testng.xml只包含一个suite。如果想起多个线程执行不同的suite，官方给出的方法是：通过命令行的方式来指定线程池的容量。

java org.testng.TestNG -suitethreadpoolsize 3 testng1.xml testng2.xml testng3.xml

即可通过三个线程来分别执行testng1.xml、testng2.xml、testng3.xml。

　　test, class, method

test，class，method级别的并发，可以通过在testng.xml中的suite tag下设置，如：

<suite name="Testng Parallel Test" parallel="tests" thread-count="5">
<suite name="Testng Parallel Test" parallel="classes" thread-count="5">
<suite name="Testng Parallel Test" parallel="methods" thread-count="5">

它们的区别如下：

• tests级别：不同test tag下的用例可以在不同的线程执行，相同test tag下的用例只能在同一个线程中执行。
• classs级别：不同class tag下的用例可以在不同的线程执行，相同class tag下的用例只能在同一个线程中执行。
• methods级别：所有用例都可以在不同的线程去执行。

5.2 不同dataprovider的并发

在使用TestNG做自动化测试时，基本上大家都会使用dataprovider来管理一个用例的不同测试数据。而上述在testng.xml中修改suite标签的方法，并不适用于dataprovider多组测试数据之间的并发。

执行时会发现，一个dp中的多组数据依然是顺序执行。解决方式是：在@DataProvider中添加parallel=true。

import org.testng.annotations.DataProvider;
import testdata.ScenarioTestData;

public class ScenarioDataProvider {
    @DataProvider(name = "hadoopTest", parallel=true)
    public static Object [][] hadoopTest(){
        return new Object[][]{
            ScenarioTestData.hadoopMain,
            ScenarioTestData.hadoopRun,
            ScenarioTestData.hadoopDeliverProps
        };
    }

    @DataProvider(name = "sparkTest", parallel=true)
    public static Object [][] sparkTest(){
        return new Object[][]{
            ScenarioTestData.spark_java_version_default,
            ScenarioTestData.spark_java_version_162,
            ScenarioTestData.spark_java_version_200,
            ScenarioTestData.spark_python
        };
    }

    @DataProvider(name = "sqoopTest", parallel=true)
    public static Object [][] sqoopTest(){
        return new Object[][]{
            ScenarioTestData.sqoop_mysql2hive,
            ScenarioTestData.sqoop_mysql2hdfs
        };
    }
}

/***　　默认情况下，dp并行执行的线程池容量为10，如果要更改并发的数量，也可以在suite tag下指定参数data-provider-thread-count：***/<suite name="Testng Parallel Test" parallel="methods" thread-count="5" data-provider-thread-count="20" >

5.3 同一个方法的并发

有些时候，我们需要对一个测试用例，比如一个http接口，执行并发测试，即一个接口的反复调用。TestNG中也提供了优雅的支持方式，在@Test标签中指定threadPoolSize和invocationCount。

@Test(enabled=true, dataProvider="testdp", threadPoolSize=5, invocationCount=10)

• threadPoolSize表明用于调用该方法的线程池容量，该例就是同时起5个线程并行执行该方法；
• invocationCount表示该方法总计需要被执行的次数。该例子中5个线程同时执行，当总计执行次数达到10次时，停止。

注意，该线程池与dp的并发线程池是两个独立的线程池。这里的线程池是用于起多个method，而每个method的测试数据由dp提供，

如果这边dp里有3组数据，那么实际上10次执行，每次都会调3次接口，这个接口被调用的总次数是10*3=30次。

threadPoolSize指定的5个线程中，每个线程单独去调method时，用到的dp如果也是支持并发执行的话，会创建一个新的线程池（dpThreadPool）来并发执行测试数据。

import java.text.SimpleDateFormat;
import java.util.Date;

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

public class TestClass1 {
    private SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
    @BeforeClass
    public void beforeClass(){
        System.out.println("Start Time: " + df.format(new Date()));
    }

    @Test(enabled=true, dataProvider="testdp", threadPoolSize=2, invocationCount=5)
    public void test(String dpNumber) throws InterruptedException{
        System.out.println("Current Thread Id: " + Thread.currentThread().getId() + ". Dataprovider number: "+ dpNumber);
        Thread.sleep(5000);
    }

    @DataProvider(name = "testdp", parallel = true)
    public static Object[][]testdp(){
        return new Object[][]{
            {"1"},
            {"2"}
        };
    }

    @AfterClass
    public void afterClass(){
        System.out.println("End Time: " + df.format(new Date()));
    }
}

原文：https://www.cnblogs.com/Ronaldo-HD/p/9235210.html

原文地址：https://www.cnblogs.com/peachh/p/12013968.html