Testng的简介和使用

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

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

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

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

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

2. TestNG基本注解

1. @Test  标记为一个测试方法
2. @BeforeTest   @AfterTest  
3. @BeforeMethod  @AfterMethod
4. ddd
5. gggg
6. 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为必须属性