Java 如何重复参数化JUnit5测试？

有没有办法将

@RepeatedTest

注释与

@TestTemplate

一起使用

目标是为每种类型的

依赖项

运行多次测试，这些依赖项由

扩展

类注入

    @TestTemplate
    @RepeatedTest(100)
    @Timeout(1)
    void test(final Dependency dep) throws Exception {
        .... 
    }

---

注意：下面的示例提供了使用自定义依赖类实现的自定义@TestTemplate的实现

考虑这一点：

import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.extension.*;

import java.util.Collections;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class RepeatedParametrizedTest {

  @TestTemplate
  @ExtendWith(MyTemplate.class)
  @Timeout(1)
  void test(final Dependency dep) {
    assertEquals(true, true);
  }
}

class Dependency {

  private final String name;

  public Dependency(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

  @Override
  public String toString() {
    return name;
  }

}

class MyTemplate implements TestTemplateInvocationContextProvider {

  @Override
  public boolean supportsTestTemplate(ExtensionContext context) {
    return true;
  }

  @Override
  public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
    // here goes your implementation of all possible Dependency objects wrapped in invocationContext()
    return IntStream.range(0, 100)
        .flatMap(n -> IntStream.range(1, 10))
        .mapToObj(n -> invocationContext(new Dependency("dependency" + n)));
  }

  private TestTemplateInvocationContext invocationContext(Dependency dependency) {
    return new TestTemplateInvocationContext() {
      @Override
      public String getDisplayName(int invocationIndex) {
        return dependency.getName();
      }

      @Override
      public List<Extension> getAdditionalExtensions() {
        return Collections.singletonList(new ParameterResolver() {
          @Override
          public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
            return parameterContext.getParameter().getType().equals(Dependency.class);
          }

          @Override
          public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
            return dependency;
          }
        });
      }
    };
  }
}

import org.junit.jupiter.api.TestTemplate；
导入org.junit.jupiter.api.Timeout；
导入org.junit.jupiter.api.extension.*；
导入java.util.Collections；
导入java.util.List；
导入java.util.stream.IntStream；
导入java.util.stream.stream；
导入静态org.junit.jupiter.api.Assertions.assertEquals；
公共类重复参数化测试{
@测试模板
@ExtendWith（MyTemplate.class）
@超时（1）
无效测试（最终依赖项dep）{
assertEquals（真，真）；
}
}
类依赖{
私有最终字符串名；
公共依赖项（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
@凌驾
公共字符串toString（）{
返回名称；
}
}
类MyTemplate实现TestTemplateInvocationContextProvider{
@凌驾
公共布尔支持stTemplate（ExtensionContext上下文）{
返回true；
}
@凌驾
公共流提供TestTemplateInvocationContext（ExtensionContext上下文）{
//下面是在invocationContext（）中包装的所有可能的依赖项对象的实现
返回IntStream.range（0，100）
.flatMap（n->IntStream.range（1,10））
.mapToObj（n->invocationContext（新依赖项（“依赖项”+n））；
}
私有TestTemplateInvocationContext调用上下文（依赖项）{
返回新的TestTemplateInvocationContext（）{
@凌驾
公共字符串getDisplayName（int调用索引）{
返回dependency.getName（）；
}
@凌驾
公共列表getAdditionalExtensions（）{
return Collections.singletonList（新参数resolver（）{
@凌驾
公共布尔支持参数（ParameterContext ParameterContext，ExtensionContext ExtensionContext）{
返回parameterContext.getParameter（）.getType（）.equals（Dependency.class）；
}
@凌驾
公共对象resolveParameter（ParameterContext ParameterContext，ExtensionContext ExtensionContext）{
返回依赖；
}
});
}
};
}
}

对于将产生以下结果的10*10个实例：

---

您的案例将需要修改/复制现有测试模板，并与上述代码合并