java TestNG 中的 DataProvider 和 Factory 有什么区别？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/5368516/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
What's the difference between DataProvider and Factory in TestNG?
提问by why
When to use DataProvider and when to use Factory ?
何时使用 DataProvider 以及何时使用 Factory ？
回答by Sreya P.K
TestNG factory is used to create instances of test classes dynamically. This is useful if you want to run the test class any no of times. For example, if you have a test to login into a site and you want to run this test multiple times,then its easy to use TestNG factory where you create multiple instances of test class and run the tests.
TestNG 工厂用于动态创建测试类的实例。如果您想多次运行测试类，这将非常有用。例如，如果您有一个登录站点的测试，并且您想多次运行此测试，那么可以轻松使用 TestNG 工厂，您可以在其中创建测试类的多个实例并运行测试。
public class WebTestFactory {
//createInstances method will create 10 objects of WebTest class
@Factory
public Object[] createInstances() {
Object[] result = new Object[10];
for (int i = 0; i < 10; i++) {
result[i] = new WebTest(i);
}
return result;
}
and the test class is now:
测试类现在是：
public class WebTest {
private int m_numberOfTimes;
public WebTest(int numberOfTimes) {
m_numberOfTimes = numberOfTimes;
}
@Test
public void testServer() {
//Code to test the application
}
}
Your testng.xml only needs to reference the class that contains the factory method, since the test instances themselves will be created at runtime:
你的 testng.xml 只需要引用包含工厂方法的类，因为测试实例本身将在运行时创建：
<class name="WebTestFactory" />
The factory method can receive parameters just like @Test and @Before/After and it must return Object[]. The objects returned can be of any class (not necessarily the same class as the factory class).
工厂方法可以像@Test 和@Before/After 一样接收参数，它必须返回Object[]。返回的对象可以是任何类（不一定与工厂类相同）。
Whereas, dataprovider is used to provide parameters to a test. If you provide dataprovider to a test, the test will be run taking different sets of value each time. This is useful for a scenario like where you want to login into a site with different sets of username and password each time.
而 dataprovider 用于为测试提供参数。如果您向测试提供数据提供者，则每次测试都会使用不同的值集运行。这对于您希望每次使用不同的用户名和密码组登录站点的场景非常有用。
public class DataProviderTest {
@Test(dataProvider= "data")
public void TestUltimatixFromExcelData(String userName,String password) {
WebDriver driver;
driver=new FirefoxDriver();
//Test to login into a site
}
@DataProvider(name="data")
public static Object[][] dataProviderTest() throws Exception{
Object[][] returnArray={new Object[]{"username1","password1"},new Object[]{"username2","password2"},new Object[]{"username3","password3"}
};
return returnArray;
}
}
回答by Kozio?ek
Data provider always create the same data set. So if you need Person instance you will always get person called John Wayne from data provider. They provide static data. This is good for test parametrization when you supply your test with two objects - first is method input, second that you expect.
数据提供者始终创建相同的数据集。所以如果你需要 Person 实例，你总是会从数据提供者那里得到一个叫 John Wayne 的人。他们提供静态数据。当您为测试提供两个对象时，这对测试参数化很有用 - 第一个是方法输入，第二个是您期望的。
Factories allow you to create tests dynamically.. They provide dynamic data like random content or if you want call some method with diffrend parameters.
工厂允许您动态创建测试。. 它们提供动态数据，如随机内容，或者如果您想使用不同的参数调用某些方法。
回答by seetha
Factory implementation executes the test method for each individual instance of the test class. Where as DataProvider executes the test method for a single instance of the test class.
工厂实现为测试类的每个单独实例执行测试方法。其中 DataProvider 为测试类的单个实例执行测试方法。
回答by Andrejs
TLDR:
TLDR:
@DataProvider-> params for a SINGLE method@Factory-> params for ALL methods in a Class
@DataProvider-> 单个方法的参数@Factory-> 类中所有方法的参数
Let me start with using DataProviders:
让我从使用开始DataProviders：
public class VeryImportantTest {
@DataProvider
public static Object[][] numberProvider() {
return new Object[][]{
{1},
{2}
};
}
// DataProvider provides data to a SINGLE method
@Test(dataProvider = "numberProvider")
public void test1(int num){
Assert.assertNotEquals(3, num);
}
@Test(dataProvider = "numberProvider")
public void test2(int num){
// ...
}
@Test(dataProvider = "numberProvider")
public void test3(int num){
// ...
}
// Hmmm... I still have 10 tests to write here,
// and it's getting annoying to specify the dataprovider everytime...
}
But not with the @Factory:
但不是@Factory：
public class FactoryExample {
@Factory
public Object[] factoryMethod() {
return new Object[] {
new FactoryExample(0),
new FactoryExample(1)
};
}
private int number;
private FactoryExample(){}
private FactoryExample(int number) {
this.number = number;
}
// Now there's no need to specify dataproviders everywhere, nice
@Test
public void test1(){
Assert.assertNotEquals(3, number);
}
@Test
public void test2(){ // <-- No need to specify params in each method either
// ...
}
}
DO note two things when using Factory:
使用时请注意两件事Factory：
1) You have to specify a no-arg constructoror make fields + methods static. See more here
1）您必须指定一个无参数构造函数或使 fields + methods static。在这里查看更多
2) With @DataProvider, your @BeforeClasswill be executed once. With @Factoryit will be executed with every iteration.
2) 使用@DataProvider，您@BeforeClass将被执行一次。随着@Factory它会与被执行每次迭代。
