Question

Guava对用JUnit3编写的集合实现进行了大量测试，如下所示：

/*
 * Copyright (C) 2008 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
public class CollectionRemoveTester<E> extends AbstractTester<E> {

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
     ...
  }
}

然后使用传递了集合类型的一组特性和生成器的TestSuiteBuilder来测试不同的集合，并且反射性框架标识要运行的测试方法集。

我想在JUnit4中构建类似的东西，但是我不清楚如何去做：构建我自己的Runner？理论？到目前为止，我最好的猜测是编写类似

的内容

abstract class AbstractCollectionTest<E> {
   abstract Collection<E> create(E... elements);
   abstract Set<Feature> features();

   @Test
   public void removePresentValue() {
      Assume.assumeTrue(features().contains(SUPPORTS_REMOVE));
      ...
   }
}

@RunWith(JUnit4.class)
class MyListImplTest<E> extends AbstractCollectionTest<E> {
  // fill in abstract methods
}

一般问题是这样的：在JUnit4中，我可以如何为接口类型构建一套测试，然后将这些测试应用于各个实现？

Answer 1

在Junit中，您可以使用categories。例如，这个套件将从注释为集成的AllTestSuite执行al test：

import org.junit.experimental.categories.Categories;
import org.junit.experimental.categories.Categories.IncludeCategory;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Categories.class)
@IncludeCategory(Integration.class)
@Suite.SuiteClasses ({AllTestsSuite.class} )
public class IntegrationTestSuite {}

您也可以使用@ExcludeCategory。这对于删除慢速测试非常有用。类别类只是普通的旧Java类或接口。例如：

public interface Integration{}
public interface Performance{}
public interface Slow{}
public interface Database{}

您只需要依次调整测试：

@Category(Integration.class)
public class MyTest{

   @Test
   public void myTest__expectedResults(){
   [...]

一个测试可能有多个这样的类别：

   @Category({Integration.class,Database.class})  
   public class MyDAOTest{

为简单起见，我通常使用google toolbox在测试文件夹中创建一个包含所有类的套件：

import org.junit.runner.RunWith;

import com.googlecode.junittoolbox.ParallelSuite;
import com.googlecode.junittoolbox.SuiteClasses;

@RunWith(ParallelSuite.class)
@SuiteClasses({"**/**.class",           //All classes
             enter code here  "!**/**Suite.class" })    //Excepts suites
public class AllTestsSuite {}

这包括在AllTestSuite中包含相同文件夹和子文件夹中的所有类，即使它们没有_Test修复程序也是如此。但是无法看到不在同一文件夹或子文件夹中的测试。 junit-toolbox在Maven中可用：

<dependency>
    <groupId>com.googlecode.junit-toolbox</groupId>
    <artifactId>junit-toolbox</artifactId>
    <version>2.2</version>
</dependency>

现在您只需要执行适合您需求的套件：）

UPDATE ：在Spring中有@IfProfileValue注释，允许您有条件地执行测试：

@IfProfileValue(name="test-groups", values={"unit-tests", "integration-tests"})
@Test
public void testProcessWhichRunsForUnitOrIntegrationTestGroups() {

有关详细信息，请参阅Spring JUnit Testing Annotations

Answer 2

关于是否要建立自己的Runner ...我认为你不应该立即尝试建立自己的但是参数化你的单元测试。

一个选项是使用@RunWith(Parameterized.class)注释您的类，并插入一个用@Parameters注释的静态方法，该方法将使用JUnit测试的构造函数进行实际参数化。在一个例子中，我无耻地从https://github.com/junit-team/junit/wiki/Parameterized-tests获取：

@RunWith(Parameterized.class)
public class FibonacciTest {
    @Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {     
                 { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 }  
           });
    }

    private int fInput;

    private int fExpected;

    public FibonacciTest(int input, int expected) {
        fInput= input;
        fExpected= expected;
    }

    @Test
    public void test() {
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

这将使您的所有测试方法使用相同的参数，因为它们通常会分配给JUnit类中的相应字段。关键是在这个静态方法（Dagger，Guice，工厂，等等）中实例化不同的实现。然后它们将自动传递给构造函数，您将负责将它们分配给您将在测试方法中使用的字段。如您所见，只需将实现的实例放在其中，而不是使用示例的整数数组。有关更多信息，请查看上面的链接。

第二个选项是使用Zohhak和https://github.com/piotrturski/zohhak中的注释@RunWith(ZohhakRunner.class)。这将允许您为每个方法而不是每个类参数化单元测试。对于工厂实例化来说，这可能会比较棘手，但是通过一些工作可以使它变得非常优雅。从Zohhak网站获取的示例：

@TestWith({
    "clerk,      45'000 USD, GOLD",
    "supervisor, 60'000 GBP, PLATINUM"
})
public void canAcceptDebit(Employee employee, Money money, ClientType clientType) {
    assertTrue(   employee.canAcceptDebit(money, clientType)   );
}

我会从第一种方法开始，如果你点击alimit，请转到第二种方法。干杯，祝你好运。

Answer 3

您可以使用JUnit规则有条件地忽略测试（它们最终会在maven报告中跳过，但可能有一种方法可以解决这个问题，我不知道）。

这是基于规则in this article。我稍微更改了规则see here。

public abstract class AbstractCollectionTest {

@Rule
public ConditionalSupportRule rule = new ConditionalSupportRule();

private Collection<String> collection;
private Set<Class<? extends Feature>> features;

public AbstractCollectionTest(Collection<String> collection,
                              Class<? extends Feature> ... features) {
    this.collection = collection;

    this.features = new HashSet<>();
    for (Class<? extends Feature> feature : features) {
        this.features.add(feature);
    }
}

@Test
@ConditionalSupport(condition = SupportsRemove.class)
public void remove() throws Exception {

    // ...
    System.out.println("test run");
}

private interface Feature {}

public class SupportsRemove implements RunCondition, Feature {

    public SupportsRemove() {
    }

    @Override
    public boolean isSatisfied() {
        return features.contains(SupportsRemove.class);
    }
}

数组列表的示例测试：

public class ArrayListTest extends AbstractCollectionTest {

    public ArrayListTest() {
        super(new ArrayList<>(), SupportsRemove.class);
    }

}

一些不支持删除的列表：

public class UnmodifiableListTest extends AbstractCollectionTest {

    public UnmodifiableListTest() {
        super(Collections.unmodifiableList(new ArrayList<>()));
    }
}

如何构建可配置的JUnit4测试套件？

3 个答案: