TestNG基本注解（二）

1. Before类别和After类别注解

@BeforeSuite
@AfterSuite
@BeforeTest
@AfterTest
@BeforeClass
@AfterClass
@BeforeMethod
@AfterMethod

上述的注解分为Before类别和After类，我们可以在Before类别的注解方法里面做一些初始化动作，如实例化数据库连接、新建数据库连接池、创建线程池、打开文件流等等。然后，我们可以在After类别的注解方法里面做一些销毁动作，如释放数据库连接、销毁数据库连接池、销毁线程池或者关闭文件流等等。同一类别的不同注解会在不同的位置被调用，下面我们逐个介绍:

1.1 @BeforeSuite

被@BeforeSuite注解的方法，将会在testng定义的xml根元素里面的所有执行之前运行。

1.2 @AfterSuite

被@AfterSuite注解的方法，将会在testng定义的xml根元素里面的所有执行之后运行。

1.3 @BeforeTest

被@BeforeTest注解的方法，将会在一个元素定义的所有里面所有测试方法执行之前运行。

1.4 @AfterTest

被@AfterTest注解的方法，将会在一个元素定义的所有里面所有的测试方法执行之后运行。

1.5 @BeforeClass

被@BeforeClass注解的方法，将会在当前测试类的第一个测试方法执行之前运行。

1.6 @AfterClass

被@AfterClass注解的方法，将会在当前测试类的最后一个测试方法执行之后运行。

1.7 @BeforeMethod

被@BeforeMethod注解的方法，将会在当前测试类的每一个测试方法执行之前运行。

1.8 @AfterMethod

被@AfterMethod注解的方法，将会在当前测试类的每一个测试方法执行之后运行。

上面的说明，很抽象，也很乱，我们以一个例子来说明上面这些注解的用法:

新建TestNGAnnotationTest和TestNGAnnotationTest2(TestNGAnnotationTest2与TestNGAnnotationTest内容一致)

public class TestNGAnnotationTest {

    @BeforeSuite
    public void beforeSuite() {
        System.out.println(this.getClass().getName() + " beforeSuite");
    }

    @AfterSuite
    public void afterSuite() {
        System.out.println(this.getClass().getName() + " afterSuite");
    }

    @BeforeTest
    public void beforeTest() {
        System.out.println(this.getClass().getName() + " beforeTest");
    }

    @AfterTest
    public void afterTest() {
        System.out.println(this.getClass().getName() + " afterTest");
    }

    @BeforeClass
    public void beforeClass() {
        System.out.println(this.getClass().getName() + " beforeClass");
    }

    @AfterClass
    public void afterClass() {
        System.out.println(this.getClass().getName() + " afterClass");
    }

    @BeforeMethod
    public void beofreMethod() {
        System.out.println(this.getClass().getName() + " beforeMethod");
    }

    @AfterMethod
    public void afterMethod() {
        System.out.println(this.getClass().getName() + " afterMethod");
    }

    @Test
    public void test1() {
        System.out.println(this.getClass().getName() + " test1");
    }

    @Test
    public void test2() {
        System.out.println(this.getClass().getName() + " test2");
    }

}

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
49
50
51
52
53

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
49
50
51
52
53

testng.xml里面加入:

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="Suite1" verbose="1" >
  <test name="test1" >
    <classes>
       <class name="com.crazypig.testngdemo.TestNGAnnotationTest" />
       <class name="com.crazypig.testngdemo.TestNGAnnotationTest2" />
    </classes>
  </test>
</suite>

1
2
3
4
5
6
7
8
9

1
2
3
4
5
6
7
8
9

运行testng测试，得到以下结果：

com.crazypig.testngdemo.TestNGAnnotationTest beforeSuite
com.crazypig.testngdemo.TestNGAnnotationTest2 beforeSuite
com.crazypig.testngdemo.TestNGAnnotationTest beforeTest
com.crazypig.testngdemo.TestNGAnnotationTest2 beforeTest
com.crazypig.testngdemo.TestNGAnnotationTest beforeClass
com.crazypig.testngdemo.TestNGAnnotationTest beforeMethod
com.crazypig.testngdemo.TestNGAnnotationTest test1
com.crazypig.testngdemo.TestNGAnnotationTest afterMethod
com.crazypig.testngdemo.TestNGAnnotationTest beforeMethod
com.crazypig.testngdemo.TestNGAnnotationTest test2
com.crazypig.testngdemo.TestNGAnnotationTest afterMethod
com.crazypig.testngdemo.TestNGAnnotationTest afterClass
com.crazypig.testngdemo.TestNGAnnotationTest2 beforeClass
com.crazypig.testngdemo.TestNGAnnotationTest2 beforeMethod
com.crazypig.testngdemo.TestNGAnnotationTest2 test1
com.crazypig.testngdemo.TestNGAnnotationTest2 afterMethod
com.crazypig.testngdemo.TestNGAnnotationTest2 beforeMethod
com.crazypig.testngdemo.TestNGAnnotationTest2 test2
com.crazypig.testngdemo.TestNGAnnotationTest2 afterMethod
com.crazypig.testngdemo.TestNGAnnotationTest2 afterClass
com.crazypig.testngdemo.TestNGAnnotationTest afterTest
com.crazypig.testngdemo.TestNGAnnotationTest2 afterTest
com.crazypig.testngdemo.TestNGAnnotationTest afterSuite
com.crazypig.testngdemo.TestNGAnnotationTest2 afterSuite

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这里给出一张图，方便更好地理解这些注解方法的执行位置:
show-testng-annotation-run-position

我们可以根据自身需求，选择特定的位置去执行一些初始化动作，以及一些销毁动作。假如你需要针对整个测试suite做初始化动作，那么应该选择在被@BeforeSuite注解的方法里面执行。如果需要针对一个<test>里面的所有测试类做初始化动作，那么可以选择在被@BeforeTest注解的方法里面执行。如果需要针对一个特定的测试类做初始化动作，那么应该选择在被@BeforeClass注解的方法里面执行。最后，假如你想在每一个测试方法执行前做初始化动作，那么应该选择@BeforeMethod。销毁的选择与初始化类似，这里不再赘述。

2. @Test 注解

@Test 注解是TestNG的核心注解，被打上该注解的方法，表示为一个测试方法，类比JUnit是一个道理(JUnit也是用了这个注解，在使用TestNG时候注意导包别导错)。

这个注解有多个配置属性，用法为:

@Test(param1 = ..., param2 = ...)

1

1

常见取值说明如下:

alwaysRun : 如果=true,表示即使该测试方法所依赖的前置测试有失败的情况，也要执行
dataProvider : 选定传入参数的构造器。(@DataProvider注解将在后面章节介绍)
dataProviderClass : 确定参数构造器的Class类。(参数构造器首先会在当前测试类里面查找，如果参数构造器不在当前测试类定义，那么必须使用该属性来执行它所在的Class类)
dependsOnGroups : 确定依赖的前置测试组别。
dependsOnMethods : 确定依赖的前置测试方法。
description ：测试方法描述信息。(建议为每个测试方法添加有意义的描述信息，这将会在最后的报告中展示出来)
enabled : 默认为true，如果指定为false，表示不执行该测试方法。
expectedExceptions ：指定期待测试方法抛出的异常，多个异常以逗号(,)隔开。
groups : 指定该测试方法所属的组，可以指定多个组，以逗号隔开。组测试的用法将在后面文章单独介绍。
invocationCount ：指定测试方法需要被调用的次数。
invocationTimeOut：每一次调用的超时时间，如果invocationCount没有指定，该参数会被忽略。应用场景可以为测试获取数据库连接，超时就认定为失败。单位是毫秒。
priority ：指定测试方法的优先级，数值越低，优先级越高，将会优先与其他数值高的测试方法被调用。(注意是针对一个测试类的优先级)
timeout : 指定整个测试方法的超时时间。单位是毫秒。

下面我们写一个简单的测试类，说明@Test注解的使用以及属性的配置方式:

package com.crazypig.testngdemo;

import org.testng.annotations.Test;

public class TestAnnotationPropertiesTest {

    @Test(priority = 1, invocationCount = 3)
    public void test1() {
        System.out.println("invoke test1");
    }

    @Test(priority = 2, invocationCount = 2)
    public void test2() {
        System.out.println("invoke test2");
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

testng.xml配置

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name="Suite1" verbose="1" >
  <test name="test1" >
    <classes>
       <class name="com.crazypig.testngdemo.TestAnnotationPropertiesTest" />
    </classes>
  </test>
</suite>

1
2
3
4
5
6
7
8

1
2
3
4
5
6
7
8

运行结果:

invoke test1
invoke test1
invoke test1
invoke test2
invoke test2

1
2
3
4
5

1
2
3
4
5

3. @Parameters 注解

@Parameters 注解用于为测试方法传递参数，用法如下所示:

package com.crazypig.testngdemo;

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class AnnotationParametersTest {

    @Parameters(value = {"param1", "param2"})
    @Test
    public void test(String arg1, String arg2) {
        System.out.println("use @Parameters to fill method arguments : arg 1 = " + arg1 + ", arg2 = " + arg2);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14

testng.xml配置

<test name="testAnnotationParameters">
    <parameter name="param1" value="value1"></parameter>
    <parameter name="param2" value="value2"></parameter>
    <classes>
        <class name="com.crazypig.testngdemo.AnnotationParametersTest" />
    </classes>
</test>

1
2
3
4
5
6
7

1
2
3
4
5
6
7

运行结果:

use @Parameters to fill method arguments : arg 1 = value1, arg2 = value2

1

1

4. @DataProvider 注解

上面的小结提到@Parameters注解可以为测试方法传递参数，但是这种方式参数值需要配置在testng.xml里面，灵活性不高。而@DataProvider注解同样可以为测试方法传递参数值，并且，它是真正意义上的参数构造器，可以传入多组测试数据对测试方法进行测试。被@DataProvider注解的方法，方法返回值必须为Object[][]或者Iterator<Object[]>。例子如下所示:

package com.crazypig.testngdemo;

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

public class AnnotationDataProviderTest {

    @DataProvider(name="testMethodDataProvider")
    public Object[][] testMethodDataProvider() {

        return new Object[][]{{"value1-1", "value2-1"}, {"value1-2", "value2-2"}, {"value1-3", "value2-3"}};

    }

    @Test(dataProvider="testMethodDataProvider")
    public void test(String arg1, String arg2) {
        System.out.println("use @DataProvider to fill method argument : arg1 = " + arg1 + " , arg2 = " + arg2);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

testng.xml配置：

<test name="testDataProvider">
  <classes>
    <class name="com.crazypig.testngdemo.AnnotationDataProviderTest" />
  </classes>
</test>

1
2
3
4
5

1
2
3
4
5

运行结果:

use @DataProvider to fill method argument : arg1 = value1-1 , arg2 = value2-1
use @DataProvider to fill method argument : arg1 = value1-2 , arg2 = value2-2
use @DataProvider to fill method argument : arg1 = value1-3 , arg2 = value2-3

1
2
3

1
2
3

5. @Factory 注解

在一个方法上面打上@Factory注解，表示该方法将返回能够被TestNG测试的测试类。利用了设计模式中的工厂模式。例子如下所示:

package com.crazypig.testngdemo;

import org.testng.annotations.Factory;

public class AnnotationFactoryTest {

    @Factory
    public Object[] getSimpleTest() {
        return new Object[]{ new SimpleTest("one"), new SimpleTest("two")};
    }

}

1
2
3
4
5
6
7
8
9
10
11
12

1
2
3
4
5
6
7
8
9
10
11
12

package com.crazypig.testngdemo;

import org.testng.annotations.Test;

public class SimpleTest {

    private String param;

    public SimpleTest(String param) {
        this.param = param;
    }

    @Test
    public void test() {
        System.out.println("SimpleTest.param = " + param);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

testng.xml配置:

<test name="testFactory">
    <classes>
        <class name="com.crazypig.testngdemo.AnnotationFactoryTest" />
    </classes>
</test>

1
2
3
4
5

1
2
3
4
5

运行结果:

SimpleTest.param = one
SimpleTest.param = two

1
2

1
2

6. @Listeners 注解

一般我们写测试类不会涉及到这种类型的注解，这个注解必须定义在类、接口或者枚举类级别。实用的Listener包括ISuiteListener、ITestListener和IInvokedMethodListener，他们可以在suite级别、test级别和test method一些执行点执行一些自定义操作，如打印日志。因为很少使用，这里不以例子形式给出，感兴趣的可以自己研究一下。

相关阅读:
Sumdiv POJ
Tallest Cow POJ
P2280 [HNOI2003]激光炸弹（二维前缀和）
Strange Towers of Hanoi POJ
Manjaro （KDE）安装踩坑记录
Petya and Array CodeForces
CodeForces
Philosopher’s Walk（递归）
2018 icpc 青岛网络赛 J.Press the Button
POJ 1003: Hangover

原文地址：https://www.cnblogs.com/alisapan/p/6811356.html