@Factory注解从字面意思上来讲就是采用工厂的方法来创建测试数据并配合完成测试，其主要应对的场景是：对于某一个测试用例或方法，我们需要输入多个测试数据进行测试，并且这些测试数据可以是有一定关系(可以通过代码控制)，此时，我们就可以把自动化或者手动测试时的遇到的只因测试数据不同的多个测试用例合并成一个测试用例，来进行更方便和快捷的测试。
策略：一般我们会在标有@Factory注解的方法中对测试类进行调用，这时TestNg会自动调用测试类中带有@Test注解的方法
配置文件：只需要配置带有@Factory注解的类即可
@Factory必须放在一个返回对象数组的顶部，所有的这些对象都包含测试类的实例，testng会确保@Factory只被调用一次。
@Factory方法是首先被调用的，在@Test方法和配置方法之前，只有当所有的@Factory方法被调用之后，testng才开始执行配置和测试方法。
@Factory允许在运行时动态测试。
简单的使用：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class SimpleTest {
@Test
public void simpleTest1(){
System.out.println("simple test one");
}
@Test
public void simpleTest2(){
System.out.println("simple test two");
}
} public class SimpleTestFactory
{ @Factory
public Object[] factoryMethod() {
return new Object[] { new SimpleTest(), new SimpleTest() };
}
} |
SimpleTestFactory工厂类，在带有@Factory注解的方法中调用被执行的测试类，TestNg会自动调用被执行类中带有@Test注解的方法被执行的测试类为：SimpleTestFactory。
输出结果会：
simple test one
simple test one
simple test two
simple test two
PASSED: simpleTest1
PASSED: simpleTest1
PASSED: simpleTest2
PASSED: simpleTest2
===============================================
Default test
Tests run: 4, Failures: 0, Skips: 0
===============================================
由以上可知所有的test方法都被调用了。
使用@Factory最大的好处就是可以在初始化的时候将参数传给测试类：
|
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
|
public class SimpleTest {
private int para;
public SimpleTest(int para) {
this.para = para;
}
@Test
public void testMethodOne(){
int value = para + 1;
System.out.println("Test method one output: " + value);
}
@Test
public void testMethodTwo(){
int value = para + 2;
System.out.println("Test method two output: " + value);
}
}public class SimpleTestFactory {
@Factory
public Object[] factoryMethod(){
return new Object[] { new SimpleTest(0), new SimpleTest(10)};
}
} |
运行SimpleTestFactory，可以得到以下输出：
Test method one output: 1
Test method one output: 11
Test method two output: 2
Test method two output: 12
PASSED: testMethodOne
PASSED: testMethodOne
PASSED: testMethodTwo
PASSED: testMethodTwo
可以知道测试中的每个方法都执行了两遍。
@Factory更适合于同一类型的参数变化性的测试，那么如果参数值没有特定的规律时，我们可以采用@Factory和@DataProvider相结合的方式进行测试
注意要点：测试方法将被一共执行的次数，因为@Factory本身就属于循环测试的类型，@DataProvider也是属于测试整体循环的类型
|
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 DataProviderTest
{ private int param;
@Factory(dataProvider = "dataMethod")
public DataProviderTest(int param) {
this.param = param;
}
@DataProvider
public static Object[][] dataMethod() {
return new Object[][] { new Object[]{ 0 }, new Object[]{ 10 } };
}
@Test
public void testMethodOne() {
int opValue = param + 1;
System.out.println("Test method one output: " + opValue);
}
@Test
public void testMethodTwo() {
int opValue = param + 2;
System.out.println("Test method two output: " + opValue);
}
} |
dataMethod会返回一个二维数组，维数表示迭代的次数，第二个值表示传入的参数。
使用@Factory的依赖测试，在会先执行所有的依赖方法，然后在执行测试方法。
|
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
|
public class DependencyTest
{ private int param;
public DependencyTest(int param) {
this.param = param;
}
@Test(dependsOnMethods = { "testMethodTwo" })
public void testMethodOne() {
System.out.println("Test method one with param values: " + this.param);
}
@Test
public void testMethodTwo() {
System.out.println("Test method two with param values: " + this.param);
}
}public class SimpleTestFactory
{ @Factory
public Object[] factoryMethod()
{
return new Object[] { new DependencyTest(1), new DependencyTest(2) };
}
} |
结果：
Test method two with param values: 2
Test method two with param values: 1
Test method one with param values: 2
Test method one with param values: 1
PASSED: testMethodTwo
PASSED: testMethodTwo
PASSED: testMethodOne
PASSED: testMethodOne