我使用JUnit 4中的“参数化”功能，我注意到，@参数方法@BeforeClass方法之前执行。 这是我创造的一个问题，因为我通过@参数传递给测试用例的参数取决于代码初始化的方法@BeforeClass。 例如
@RunWith(Parameterized.class)
public class TestOtherClass {
String argument;
private static boolean initializeThis;
public TestOtherClass(String parameter) throws Exception {
argument=parameter;
}
@BeforeClass
public static void doSetup() {
System.out.println("Doing setup before class...");
initializeThis=true; // true or false, based on some condition
}
@Test
public void otherTest() {
System.out.println("Other test: " + argument);
}
@Parameters
public static Collection<Object[]> getData(){
System.out.println("Inside parameter");
String addThis;
if(initializeThis)
addThis="adding true";
else
addThis="adding false";
Object[] para1 = new Object[]{"First parameter :: " + addThis};
Object[] para2 = new Object[]{"Second parameter :: " + addThis};
Collection<Object[]> classNames = new ArrayList<Object[]>();
classNames.add(para1);
classNames.add(para2);
return classNames;
}
}
现在，我初始化变量“initializeThis”为true @BeforeClass方法，但（奇怪），当我执行的测试情况下，打印
Other test: First parameter :: adding false
Other test: Second parameter :: adding false
那是后话不期望。
我的问题是; 有没有什么办法@参数之前执行的@BeforeClass方法，我们可以做到这一点是在JUnit 4？
我将只使用普通的旧Java静态{..}初始化，而不是@BeforeClass，如：
@RunWith(Parameterized.class)
public class TestOtherClass {
String argument;
private static boolean initializeThis;
public TestOtherClass(String parameter) throws Exception {
argument=parameter;
}
static {
doSetup();
}
// @BeforeClass
public static void doSetup() {
System.out.println("Doing setup before class...");
initializeThis=true; // true or false, based on some condition
}
@Test
public void otherTest() {
System.out.println("Other test: " + argument);
}
@Parameters
public static Collection<Object[]> getData(){
System.out.println("Inside parameter");
String addThis;
if(initializeThis)
addThis="adding true";
else
addThis="adding false";
Object[] para1 = new Object[]{"First parameter :: " + addThis};
Object[] para2 = new Object[]{"Second parameter :: " + addThis};
Collection<Object[]> classNames = new ArrayList<Object[]>();
classNames.add(para1);
classNames.add(para2);
return classNames;
}
}
唯一的缺点，我知道的是，从这个继承类将无法覆盖静态初始化，而@BeforeClass给出了这方面的一些自由;
这是老问题，但最近我有同样的问题。 这让我感到没有任何的解决方案似乎去的最明显的解决方法 - 要求在@参数方法的@BeforeClass方法。 后者是静态的，只执行一次 - 任何测试已运行之前。 因此，它是对所有意图和目的，即使它没有被标注为这样的@BeforeClass方法。 更多详细信息可以在这里找到： http://feraldeveloper.blogspot.co.uk/2013/12/beforeclass-and-parametrized-junit-tests.html
JUnit的创建了一个Runner在参数列表中的每个项， Runner是什么封装测试方法。 所以@Parameters总是会得到@BeforeClass之前执行。
但是，你可以结合@Parameterized 假设 。 你总是包括所有在列表中的参数，你是否不打算执行它。 然后，在测试方法中，添加assumeTrue()哪些测试针对initializeThis值。
@RunWith(Parameterized.class)
public class TestOtherClassAssume {
private final String argument;
private final boolean initializeThisTest;
private static boolean initializeThis;
@Parameters
public static Collection<Object[]> getData(){
System.out.println("Inside parameter");
return Arrays.asList(new Object[][] {
{ false, "First" },
{ true, "Second" },
});
}
public TestOtherClassAssume(boolean initializeThisTest, String argument) {
this.initializeThisTest = initializeThisTest;
this.argument = argument;
}
@BeforeClass
public static void doSetup() {
System.out.println("Doing setup before class...");
initializeThis = true; // true or false, based on some condition
}
@Test
public void otherTest() {
Assume.assumeTrue(initializeThis == initializeThisTest);
System.out.println("Other test: " + argument);
}
}
从这个输出是：
Inside parameter
Doing setup before class...
Other test: Second
然而，这不符合测试套件运行。 特定
@RunWith(Parameterized.class)
public class TogglableParameterizedTest {
static boolean useAllParameters = false;
int parameter;
public TogglableParameterizedTest(int parameter) {
super();
this.parameter = parameter;
}
@Parameters
public static Collection<Object[]> getTestParameters() {
List<Object[]> parameters = new ArrayList<Object[]>();
if(useAllParameters) {
parameters.add(new Object[] { 1 });
parameters.add(new Object[] { 2 });
parameters.add(new Object[] { 3 });
}
else {
parameters.add(new Object[] { 1 });
}
return parameters;
}
@Test
public void test() {
System.out.println("parameter=" + parameter);
}
}
这不起作用：
@RunWith(Suite.class)
@SuiteClasses({ TogglableParameterizedTest.class })
public class NonWorkingTestSuite1 {
@BeforeClass
public static void toggle() {
System.out.println("sets flag to late!");
}
}
输出是
sets flag to late!
parameter=1
也不是说：
@RunWith(Suite.class)
@SuiteClasses({ TogglableParameterizedTest.class })
public class NonWorkingTestSuite2 {
static {
System.out.println("sets flag still to late");
TogglableParameterizedTest.useAllParameters = true;
}
}
的输出是“参数= 1”。 因此，静态初始化不执行的。 我发现下面的解决方法。 扩展“套房”，并插入静态初始化有：
public class TogglingSuite extends Suite {
static {
System.out.println("sets flag early enough!");
TogglableParameterizedTest.useAllParameters = true;
}
public TogglingSuite(Class<?> klass, Class<?>[] suiteClasses)
throws InitializationError {
super(klass, suiteClasses);
}
public TogglingSuite(Class<?> klass, List<Runner> runners)
throws InitializationError {
super(klass, runners);
}
public TogglingSuite(Class<?> klass, RunnerBuilder builder)
throws InitializationError {
super(klass, builder);
}
public TogglingSuite(RunnerBuilder builder, Class<?> klass,
Class<?>[] suiteClasses) throws InitializationError {
super(builder, klass, suiteClasses);
}
public TogglingSuite(RunnerBuilder builder, Class<?>[] classes)
throws InitializationError {
super(builder, classes);
}
}
在您的测试套件使用：
@RunWith(TogglingSuite.class)
@SuiteClasses({ TogglableParameterizedTest.class })
public class WorkingTestSuite {
}
输出是
sets flag early enough!
parameter=1
parameter=2
parameter=3
现在，它的工作原理。
