是否可以在 junit 4 中参数化 TestSuite？
为了将类声明为测试套件，我需要注释@RunWith(Suite.class)，但也需要相同的注释才能将测试声明为参数化：@RunWith(Parameterized.class)所以我不能将两者添加到同一个类中。
我在这个网站上发现了一个类似的问题，但没有多大帮助。到目前为止，我找到的所有示例都解释了如何参数化简单的单元测试，而不是完整的测试 tuite。
我相信
基本答案是否定的，因为正如您所说，@RunsWith只接受一个参数。 我发现了一篇博客文章，在如何处理这种情况方面有点创意。
我们不使用参数化测试，但您可以像我们一样创建一个单独的套件，仅列出测试类，参数化测试可能是其中的一部分。 我修改了我们的测试套件，以将参数化的测试类包含在套件的一部分中，并且运行良好。 我们创建了如下所示的套件，其中PrimeNumberCheckerTest是我从网络上提取的简单套件。
package com.jda.portfolio.api.rest.server;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({ com.mycompany.api.rest.server.resource.TestCartResourceJava.class,
com.mycompany.api.rest.server.resource.TestCustomerResource.class,
com.mycompany.api.rest.server.resource.TestWizardProfileResource.class,
com.mycompany.api.rest.server.interceptor.TestBaseSearchInterceptor.class,
com.mycompany.api.rest.server.resource.TestQueryParameters.class,
com.mycompany.api.rest.server.expression.TestCartExpressionGenerator.class,
com.mycompany.api.rest.server.expression.TestPreferenceExpressionGenerator.class,
com.mycompany.api.rest.server.PrimeNumberCheckerTest.class,
})
public class AllTests {}
下面是参数化测试用例的源;
package com.jda.portfolio.api.rest.server:
import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Parameterized.class)
@SuiteClasses({PrimeNumberCheckerTest.class})
public class PrimeNumberCheckerTest {
private Integer inputNumber;
private Boolean expectedResult;
private PrimeNumberChecker primeNumberChecker;
@Before
public void initialize() {
primeNumberChecker = new PrimeNumberChecker();
}
// Each parameter should be placed as an argument here
// Every time runner triggers, it will pass the arguments
// from parameters we defined in primeNumbers() method
public PrimeNumberCheckerTest(Integer inputNumber,
Boolean expectedResult) {
this.inputNumber = inputNumber;
this.expectedResult = expectedResult;
}
@Parameterized.Parameters
public static Collection primeNumbers() {
return Arrays.asList(new Object[][] {
{ 2, true },
{ 6, false },
{ 19, true },
{ 22, false },
{ 23, true }
});
}
// This test will run five times since we have as many parameters defined
@Test
public void testPrimeNumberChecker() {
System.out.println("Parameterized Number is : " + inputNumber);
assertEquals(expectedResult,
primeNumberChecker.validate(inputNumber));
}
我能够参数化测试套件并在套件的测试类成员中使用其数据，如下所示：
在 JUTsuite 中：
@RunWith(Suite.class)
@Suite.SuiteClasses({
JUT_test1.class,
})
public class JUTSuite{
// Declare all variables/objects you want to share with the test classes, e.g.
protected static List<Fx> globalFxs;
// This is the data list we'll use as parameters
protected static List<Dx> globalDxs;
@Parameters
public static Collection<Object[]> data(){
// Instantiate object list for parameters.
// Note: you must do it here and not in, say, @BeforeClass setup()
// e.g.
globalDxs=new ArrayList<Dx>(serverObj.values());
Collection<Object[]> rows=new ArrayList<Object[]>();
for(Dx d:globalDxs) {
rows.add(new Object[]{d});
}
return rows;
}
@BeforeClass
public static void setUp() throws Exception {
// Instantiate/initialize all suite variables/objects to be shares with test classes
// e.g. globalFxs=new ArrayList<Fx>();
}
@AfterClass
public static void tearDown() throws Exception {
// Clean up....
}
}
接下来，在测试类中：
@RunWith(Parameterized.class)
public class JUT_test1 {
// declare local names (if desired) for suite-wide variable/objects
// e.g.
private static List<Fx> globalFxs;
// This is the test parameter:
private Dx d;
public JUT_test1(Dx d){
this.d=d;
}
@Parameters
public static Collection<Object[]> data(){
// Note: we're calling the suite's data() method which has already executed.
return JUTSuite.data();
}
@BeforeClass
public static void setUpBeforeClass() throws Exception {
// (If desired)initialize local variables by referencing suite variables.
// e.g.globalFxs=JUTSuite.globalFxs;
}
}
我同意，提供的类是不可能的，但是有一些解决方法可以让您大部分时间到达那里，就像@mikemil一样。
我花了一些时间扩展 Suite 并委派给参数化，取得了部分成功;可以构建执行您想要的操作的运行器，并且在这两个类中或多或少地为您编写了代码。 这些类交互的方式（特别是Parameterized#getChildren()的定义）使得扩展或委托给这些类来完成你需要的东西变得困难，但是创建一个全新的类而不是扩展ParentRunner并从其他两个类中提升代码将相当容易。
我会尽量争取更多的时间稍后再谈这个问题。 如果你在我开始之前构建了一个新的运行器，请把它作为一个答案发布，我很想自己使用它。
最好的解决方案是，将西装类单独放在空白类中。例如，我正在测试登录作为参数化测试并穿上西装（用于导航性能测量）
@RunWith(Suite.class)
@Suite.SuiteClasses({
LoginPageTest.class,
HomePageTests.class})
public class PerformanceTests {
}
和登录页面测试实际上是参数化测试
@RunWith(Parameterized.class)
public class LoginPageTest
{...}
如前所述，无法使用 JUnit 4 提供的运行器参数化测试套件。
无论如何，我不建议让你的测试类依赖于一些外部提供的状态。如果要运行单个测试类怎么办？
我建议@Parameterized单独的测试类，并使用实用程序类来提供参数：
@RunWith(Suite.class)
@SuiteClasses({ Test1.class, Test2.class })
public class TestSuite {
// suite
}
@RunWith(Parameterized.class}
public class Test1 {
public Test1(Object param1) { /* ... */ }
@Parameters
public static Collection<Object[]> data() {
return TestParameters.provideTestData()
}
@Test
public void someTest() { /* ... */ }
}
@RunWith(Parameterized.class}
public class Test2 {
public Test2(Object param1) { /* ... */ }
@Parameters
public static Collection<Object[]> data() {
return TestParameters.provideTestData()
}
@Test
public void someOtherTest() { /* ... */ }
}
class TestParameters {
public static Collection<Object[]> provideTestData() {
Collection<Object[]> data = new ...;
// build testdata
return data;
}
你是对的：Suite和Parameterized都是运行器，一次只能使用一个Runner来运行测试。标准 JUnit 4 不提供组合运行器。
您可以实现自己的 Runner，也可以查看这个现成的库，它提供了一个ParameterizedSuite Runner：https://github.com/PeterWippermann/parameterized-suite
参数化测试套件如下所示：
@RunWith(ParameterizedSuite.class)
@SuiteClasses({OneTest.class, TwoTest.class})
public class MyParameterizedTestSuite {
@Parameters(name = "Parameters are {0} and {1}")
public static Object[] params() {
return new Object[][] {{'A',1}, {'B',2}, {'C',3}};
}
也许这个答案有帮助： 参数化单元测试套件
它使用@RunWith(Enclosed.class)，似乎解决了问题。