TestNG注解（一）

TestNG有大量注解，被不同注解修饰的类、方法具有不同的含义，根据使用场景，注解被分为四类：

1. 前置条件和后置条件

        将租界作为前置条件（或初始化操作）和后置条件（或清理操作）使用

2.数据驱动

        测试用例和测试数据分离，便于维护和管理。是TestNG的特点之一。

3.测试用例

        只有@Test这一个注解。其作用是对测试用例进行控制。

4.监听器

        只有@Listeners注解。用于监控测试过程，如果采用默认监听器，则不需要分配任何配置。

一、前置条件和后置条件

1.1  Suite

@BeforeSuite:在该Suite的所有Test都未运行前运行

@AfterSuite:在该Suite的所有Test都运行后运行

一个Suite对应一个顶级模块。一般结合testng.xml文件中的或使用

1.2 Test

@BeforeTest:在该Test的所有Class都未运行前运行

@AfterTest:在该Test的所有Class都运行后运行

一个Test对应一个子模块。

1.3 Class

@BeforeClass:在该Class的所有@Test都未运行前运行

@AfterClass:在该Class的所有@Test都运行后运行

一个Class对应一个Java类。

1.4 Method

@BeforeMethod:在该Class的每个@Test运行前运行

@AfterMethod:在该Class的每个@Test运行后运行

一个Method对应一个Java方法。

1.5 Group

@BeforeGroups:在该Class第一个分组的@Test运行前运行

@AfterGroups:在该Class最后一个分组的@Test运行后运行

Group的控制粒度在Class和Method之间，一个Class可以包含多个Group，一个Group可以包含多个Method。

代码验证：

package jss.test2;

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 {

  @BeforeSuite
  public void BeforeSuite() {
	  System.out.println("BeforeSuite");
  }
  @AfterSuite
  public void AfterSuite() {
	  System.out.println("AfterSuite");
  }
  @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");
  }
  @BeforeGroups(groups = {"g1"})
  public void BeforeGroups1() {
	  System.out.println("++--++BeforeGroups g1");
  }
  @AfterGroups(groups = {"g1"})
  public void AfterGroups1() {
	  System.out.println("++--++AfterGroups g1");
  }
  @BeforeGroups(groups = {"g2"})
  public void BeforeGroups2() {
	  System.out.println("++--++BeforeGroups g2");
  }
  @AfterGroups(groups = {"g2"})
  public void AfterGroups2() {
	  System.out.println("++--++AfterGroups g2");
  }
  @BeforeMethod
  public void BeforeMethod() {
	  System.out.println("++--++--BeforeMethod");
  }
  @AfterMethod
  public void AfterMethod() {
	  System.out.println("++--++--AfterMethod");
  }
  @Test(groups = "g1")
  public void Test1() {
	  System.out.println("g1 case1");
  }
  @Test(groups = "g2")
  public void Test2() {
	  System.out.println("g2 case1");
  }
  @Test(groups = "g2")
  public void Test3() {
	  System.out.println("g2 case2");
  }
  @Test(groups = {"g1","g2"})
  public void Test4() {
	  System.out.println("g1 g2 case1");
  }
}

运行结果：

BeforeSuite
++BeforeTest
++--BeforeClass
++--++BeforeGroups g1
++--++--BeforeMethod
g1 case1
++--++--AfterMethod
++--++BeforeGroups g2
++--++--BeforeMethod
g2 case1
++--++--AfterMethod
++--++--BeforeMethod
g2 case2
++--++--AfterMethod
++--++--BeforeMethod
g1 g2 case1
++--++--AfterMethod
++--++AfterGroups g2
++--++AfterGroups g1
++--AfterClass
++AfterTest
PASSED: Test1
PASSED: Test2
PASSED: Test3
PASSED: Test4

===============================================
    Default test
    Tests run: 4, Failures: 0, Skips: 0
===============================================

AfterSuite

===============================================
Default suite
Total tests run: 4, Failures: 0, Skips: 0
===============================================

分析可以得到以下结论：

1.Suite、Test、Class控制测试执行的粒度不同:Suite>Test>Class

2.一个测试用例可以同时属于多个Groups，例如例子中的Test4