testng多线程并行执行测试

testng多线程并行执行测试

并行（多线程）技术在软件术语里被定义为软件、操作系统或者程序可以并行地执行另外一段程序中多个部分或者子组件的能力。TestNG允许我们以并行（多线程）的方式来执行测试。这就意味着基于TestNG测试组件的配置，多个线程可以被同时启动然后分别执行各自的测试方法。相对于传统的单线程执行测试的方式，这种多线程方式拥有很大的优势，主要是它可以减少测试运行时间，并且可以验证某段代码在多线程环境中运行的正确性。

invocationCount----表示执行的次数

threadPoolSize-----表示线程池的内线程的个数

timeOut-------超时时间-毫秒

目录

  1. 并行执行测试的优势
  2. 如何并行地执行测试方法
  3. 如何并行地执行测试类
  4. 如何并行地执行同一测试套件内的各个测试组件
  5. 如何配置需要在多线程环境中执行的测试方法

并行执行测试的优势

并行（多线程）执行测试可以给用户带来很多好处，主要包括以下两点：

1）减少了执行时间：并行测试也就意味着多个测试可以在同一时间被同时执行，从而减少了整体测试所花费的时间。

2）允许多个线程并行地测试同一个测试组件：有了这个特性，我们就能够写出相应的测试用例来验证应用程序中包含多线程部分的代码的正确性。

以上特性被广泛地应用在QA领域的自动化功能测试方面。通过简单的配置，QA人员就可以很轻松地使得他们的测试用例在多个浏览器或者操作系统中并行地执行。

TestNG提供了三种不同类型的配置方案来实现并行测试。

如何并行地执行测试方法

TestNG为我们提供了多种方式来实现并行测试，其中一种就是每一个独立的线程分别执行各自的测试方法。这种方式能够显著地减少测试执行时间，这是因为当有越多的测试方法被并行执行时，总体测试消耗时间将会越少。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.howtodoinjava.parallelism;
 
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
 
public class ParallelMethodTest
{
    @BeforeMethod
    public void beforeMethod() {
        long id = Thread.currentThread().getId();
        System.out.println("Before test-method. Thread id is: " + id);
    }
 
    @Test
    public void testMethodsOne() {
        long id = Thread.currentThread().getId();
        System.out.println("Simple test-method One. Thread id is: " + id);
    }
 
    @Test
    public void testMethodsTwo() {
        long id = Thread.currentThread().getId();
        System.out.println("Simple test-method Two. Thread id is: " + id);
    }
 
    @AfterMethod
    public void afterMethod() {
        long id = Thread.currentThread().getId();
        System.out.println("After test-method. Thread id is: " + id);
    }
}

上述测试类包含了两个测试方法，每个测试方法在执行时都会在控制台中打印出一条信息。每个测试方法以及它们各自的beforeMehod、afterMethod方法都会通过Thread.currentThread.getId()这段代码打印出执行该测试方法的线程的ID。

在项目中新建一个名为methods-test-testng.xml的文件并将下述代码写入该文件中。

1
2
3
4
5
6
7
<suite name="Test-method Suite" parallel="methods" thread-count="2" >
  <test name="Test-method test" group-by-instances="true">
    <classes>
      <class name="com.howtodoinjava.parallelism.ParallelMethodTest" />
    </classes>
  </test>
</suite>

在Eclipse中选中该文件并且以TestNG测试套件方式运行它。你将会在控制台中看到以下输出信息：

1
2
3
4
5
6
Before test-method. Thread id is: 10
Before test-method. Thread id is: 9
Simple test-method Two. Thread id is: 10
Simple test-method One. Thread id is: 9
After test-method. Thread id is: 10
After test-method. Thread id is: 9

注意：上述截图中的ThreadId可能与你本地控制台中输出的ThreadId不同，这是因为ThreadId的值是在程序运行时由JVM动态指派的。

从上述测试结果中我们可以很清晰地看出：上述两个测试方法以及各自相应的beforeMethod和afterMethod方法是在两个独立的线程中执行的。我们可以通过在控制台中输出的ThreadId来证明这一点。

如何并行地执行测试类

在下个例子中，我们会说明如何并行地执行测试类：同一个测试组件（test execution）中的各个测试类将会在独立的线程中并行地执行。

ParallelClassesTestOne.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ParallelClassesTestOne
{
    @BeforeClass
    public void beforeClass() {
        long id = Thread.currentThread().getId();
        System.out.println("Before test-class. Thread id is: " + id);
    }
 
    @Test
    public void testMethodOne() {
        long id = Thread.currentThread().getId();
        System.out.println("Sample test-method One. Thread id is: " + id);
    }
 
    @Test
    public void testMethodTwo() {
        long id = Thread.currentThread().getId();
        System.out.println("Sample test-method Two. Thread id is: " + id);
    }
 
    @AfterClass
    public void afterClass() {
        long id = Thread.currentThread().getId();
        System.out.println("After test-class. Thread id is: " + id);
    }
}

ParallelClassesTestTwo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ParallelClassesTestTwo
{
    @BeforeClass
    public void beforeClass() {
        long id = Thread.currentThread().getId();
        System.out.println("Before test-class. Thread id is: " + id);
    }
 
    @Test
    public void testMethodOne() {
        long id = Thread.currentThread().getId();
        System.out.println("Sample test-method One. Thread id is: " + id);
    }
 
    @Test
    public void testMethodTwo() {
        long id = Thread.currentThread().getId();
        System.out.println("Sample test-method Two. Thread id is: " + id);
    }
 
    @AfterClass
    public void afterClass() {
        long id = Thread.currentThread().getId();
        System.out.println("After test-class. Thread id is: " + id);
    }
}

在项目中新建一个名为classes-test-testng.xml的文件并将下述代码写入该文件中：

1
2
3
4
5
6
7
8
<suite name="Test-class Suite" parallel="classes" thread-count="2" >
  <test name="Test-class test" >
    <classes>
      <class name="com.howtodoinjava.parallelism.ParallelClassesTestOne" />
      <class name="com.howtodoinjava.parallelism.ParallelClassesTestTwo" />
    </classes>
  </test>
</suite>

或者可以在测试用例的每一个被测的方法的注释@Test后面加上具体的线程信息如下：（只是举例并没有参与实际的eclipse运行）

@Test(threadPoolSize = 2, invocationCount = 10, timeOut = 1000)

@BeforeClass(threadPoolSize = 2, invocationCount = 10, timeOut = 1000)

    public void beforeClass() {

        long id = Thread.currentThread().getId();

        System.out.println("Before test-class. Thread id is: " + id);

    }

    @Test(threadPoolSize = 2, invocationCount = 10, timeOut = 1000)

    public void testMethodOne() {

        long id = Thread.currentThread().getId();

        System.out.println("Sample test-method One. Thread id is: " + id);

    }

    @Test(threadPoolSize = 2, invocationCount = 10, timeOut = 1000)

    public void testMethodTwo() {

        long id = Thread.currentThread().getId();

        System.out.println("Sample test-method Two. Thread id is: " + id);

    }

    @AfterClass(threadPoolSize = 2, invocationCount = 10, timeOut = 1000)

    public void afterClass() {

        long id = Thread.currentThread().getId();

        System.out.println("After test-class. Thread id is: " + id);

    }

在Eclipse中选中该文件并且以TestNG测试套件方式运行它。你将会在控制台中看到以下输出信息：

1
2
3
4
5
6
7
8
Before test-class. Thread id is: 10
Before test-class. Thread id is: 9
Sample test-method One. Thread id is: 9
Sample test-method One. Thread id is: 10
Sample test-method Two. Thread id is: 10
After test-class. Thread id is: 10
Sample test-method Two. Thread id is: 9
After test-class. Thread id is: 9

从上述测试结果中我们可以很清晰地看出：上述两个测试类以及各自相应的beforeClass和afterClass方法是在独立的两个线程中执行的。我们可以通过在控制台中输出的ThreadId来证明这一点。

如何并行地执行同一测试套件内的各个测试组件

接下来我们会一起学习如何并行地执行同一个测试套件内的各个测试组件，即各个测试组件会分别在独立的线程中执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.howtodoinjava.parallelism;
 
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;
 
public class ParallelSuiteTest
{
    String testName = "";
 
    @BeforeTest
    @Parameters({ "test-name" })
    public void beforeTest(String testName) {
        this.testName = testName;
        long id = Thread.currentThread().getId();
        System.out.println("Before test " + testName + ". Thread id is: " + id);
    }
 
    @BeforeClass
    public void beforeClass() {
        long id = Thread.currentThread().getId();
        System.out.println("Before test-class " + testName + ". Thread id is: "
                + id);
    }
 
    @Test
    public void testMethodOne() {
        long id = Thread.currentThread().getId();
        System.out.println("Sample test-method " + testName
                + ". Thread id is: " + id);
    }
 
    @AfterClass
    public void afterClass() {
        long id = Thread.currentThread().getId();
        System.out.println("After test-method  " + testName
                + ". Thread id is: " + id);
    }
 
    @AfterTest
    public void afterTest() {
        long id = Thread.currentThread().getId();
        System.out.println("After test  " + testName + ". Thread id is: " + id);
    }
}

在项目中新建一个名为suite-test-testng.xml的文件并将以下代码写入该文件中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<suite name="Test-class Suite" parallel="tests" thread-count="2">
    <test name="Test-class test 1">
        <parameter name="test-name" value="test-method One" />
        <classes>
            <class name="com.howtodoinjava.parallelism.ParallelSuiteTest" />
        </classes>
    </test>
    <test name="Test-class test 2">
        <parameter name="test-name" value="test-method One" />
        <classes>
            <class name="com.howtodoinjava.parallelism.ParallelSuiteTest" />
        </classes>
    </test>
</suite>

在Eclipse中选中该文件并且以TestNG测试套件方式运行它。你将会在控制台中看到以下输出信息：

1
2
3
4
5
6
7
8
9
10
Before test Test One. Thread id is: 9
Before test Test Two. Thread id is: 10
Before test-class Test One. Thread id is: 9
Before test-class Test Two. Thread id is: 10
Sample test-method Test One. Thread id is: 9
Sample test-method Test Two. Thread id is: 10
After test-method  Test Two. Thread id is: 10
After test-method  Test One. Thread id is: 9
After test  Test One. Thread id is: 9
After test  Test Two. Thread id is: 10

从上述测试结果中我们可以很清晰地看出：上述两个测试组件是在独立的两个线程中分别执行的。我们可以通过在控制台中输出的ThreadId来证明这一点。

如何配置一个需要在多线程环境中执行的测试方法

之前我们讨论了如何并行（多线程）地执行测试方法，测试类以及测试组件。TestNG同时也提供了一种灵活的方式来配置需要在多线程环境下运行的测试方法：只要在该测试方法的@Test注解上配置一些信息，我们就能启用多线程模式。

1
2
3
4
5
6
7
8
9
public class IndependentTest
{
    @Test(threadPoolSize = 3, invocationCount = 6, timeOut = 1000)
    public void testMethod()
    {
        Long id = Thread.currentThread().getId();
        System.out.println("Test method executing on thread with id: " + id);
    }
}

上述测试方法是通过在@Test注解中配置threadPoolSize这个属性来进入多线程模式的。threadPoolSize被设为3，这就说明了该测试方法将会在三个不同的线程中同时执行。剩余两个属性：invocationCount配置的是该测试方法应被执行的总次数，timeOut配置的是每次执行该测试方法所耗费时间的阈值，超过阈值则测试失败。

在项目中新建一个名为independent-test-testng.xml的文件，并写入下述代码：

1
2
3
4
5
6
7
<suite name="Independent test Suite" >
  <test name="Independent test">
    <classes>
     <class name="com.howtodoinjava.parallelism.IndependentTest" />
    </classes>
  </test>
</suite>

在Eclipse中选中该文件并以TestNG测试套件方式运行。你将会在控制台中看到以下输出信息

1
2
3
4
5
6
Test method executing on thread with id: 11
Test method executing on thread with id: 10
Test method executing on thread with id: 9
Test method executing on thread with id: 11
Test method executing on thread with id: 11
Test method executing on thread with id: 10

在这里，我们可以看出该测试方法被执行了多次，而且它的执行次数跟invocationCount所指定的次数相同。而且从输出信息中，我们也可以很清晰地看到该测试方法每次执行都是在不同的线程中完成的。当我们需要按照某一固定次数，在多线程环境下运行某些测试方法时，上述特性会很有帮助，因为它避免了我们把整个测试套件都并行执行多次的代价。

test，class，method级别的并发，可以通过在testng.xml中的suite tag下设置，区别如下：
tests级别：不同test tag下的用例可以在不同的线程执行，相同test tag下的用例只能在同一个线程中执行。
classs级别：不同class tag下的用例可以在不同的线程执行，相同class tag下的用例只能在同一个线程中执行。
methods级别：所有用例都可以在不同的线程去执行。

testng多线程并行执行测试的更多相关文章

  1. 使用testng多线程来测试成交编号重复的问题

    1.首先编写一个测试用的 function CREATE OR REPLACE FUNCTION getDealmainNo_test(dealdate IN varchar2, productcod ...

  2. Selenium & Webdriver 远程测试和多线程并发测试

    Selenium & Webdriver 远程测试和多线程并发测试 Selenium Webdriver自动化测试,初学者可以使用selenium ide录制脚本,然后生成java程序导入ec ...

  3. 学习使用TestNG进行数据驱动测试

    转自: https://mp.weixin.qq.com/s/8Bd8LEhiC2pu2VMcyNMGlQ 学习使用TestNG进行数据驱动测试 赵吃饭 51Testing软件测试网 前天   学习使 ...

  4. Java接口多线程并发测试 （一）

    本文为作者原创,禁止转载,违者必究法律责任!!! 本文为作者原创,禁止转载,违者必究法律责任!!! Java接口多线程并发测试 一,首先写一个接口post 请求代码: import org.apach ...

  5. testNG之异常测试

    @Test(expectedExceptions = ) 在测试的时候,某些用例的输入条件,预期结果是代码抛出异常,那么这个时候就需要testNG的异常测试,先看一段会抛出异常的代码 exceptio ...

  6. TestNG多线程测试-注解方式实现

    用@Test(invocationCount = x,threadPoolSize = y)声明,invocationCount表示执行次数,threadPoolSize表示线程池大小. packag ...

  7. TestNG 多线程测试

    TestNG以注解的方式实现多线程测试 import org.testng.annotations.Test; public class TreadDemo { // invocationCount ...

  8. 利用Testng注释实现多线程并发测试

    Testng 是一款非常优秀的测试框架,真正从测试角度出发,为测试所想.在测试过程中我们经常会遇到对某一个场景做并发请求,主要想了解该程序在并发时是否会有异常或者没考虑到的其他情况,这时往往不是要做性 ...

  9. TestNG多线程测试-用xml文件实现

    MultiThreadOnXml类: package com.janson.multiThread; import org.testng.annotations.Test; public class ...

随机推荐

  1. Go 内嵌静态资源

    http://fuxiaohei.me/2016/10/1/go-binary-embed-asset.html

  2. Cocos2d-x3.0触摸

    cocos2d-x 3.0開始採用C++11,并開始脱离OC风格,在触摸处理上也作出了改变 C++11带来了Lambda表达式(匿名函数),它将简化程序编写,可使代码更清晰易懂 在旧2.x版本号的触摸 ...

  3. BZOJ 1089 SCOI2003 严格n元树 动态规划+高精度

    题目大意:定义一棵深度为d的严格n元树为根的深度为0,最深的节点深度为d,且每一个非叶节点都有恰好n个子节点的树 给定n和d,求深度为d的严格n元树一共同拥有多少种 此题的递推部分并不难 首先我们设深 ...

  4. Java精选笔记_面向对象(多态、异常)

    多态 概述 可以理解为事物存在的多种体现形态.同样的引用调用同样的方法却做了不同的事情 多态的本质是:一个程序中同名的不同方法. 多态的体现 父类的引用指向子类的对象,父类的引用接收子类的对象. 多态 ...

  5. ios开发之--从相机或相册选取图片，并带删除操作的demo

    多选图片的一个效果,如下图:

  6. leetcode -- permutation 总结

    leetcode上关于permutation有如下几题 Permutation Sequence Next Permutation Permutations Permutations II

  7. Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:compile (default-compile)

    使用maven打包的时候出现如下错误: Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:compil ...

  8. 测试sql语句性能，提高执行效率

    为了让您的程序执行的效率更高,SQL的效率一定不可忽视. 现有以下方法去检测SQL的执行效率. 对于多表查询的效率测试: )直接from ,where方式. SET STATISTICS io ON ...

  9. 【mysql】mysql front 提示Access violation at address 010C9CD0 in module ‘mysql-front.exe’

    1 错误描述: 利用mysql-front 工具新建数据库.提示了一下错误 2 解决办法: 内存越界问题,最好重新注册下Windows的动态链接库 首先“开始”—“cmd” 在打开的dos窗口中运行

  10. (转)从程序员到CTO

    好好努力吧,向优秀的人看齐.文章来自http://blog.csdn.net/smarttony/article/details/6697617