Java 一遍又一遍地运行相同的junit测试的简单方法？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1492856/
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
Easy way of running the same junit test over and over?
提问by Stefan Thyberg
Like the title says, I'm looking for some simple way to run JUnit 4.x tests several times in a row automatically using Eclipse.
正如标题所说，我正在寻找一些简单的方法来使用 Eclipse 自动连续多次运行 JUnit 4.x 测试。
An example would be running the same test 10 times in a row and reporting back the result.
一个例子是连续运行 10 次相同的测试并报告结果。
We already have a complex way of doing this but I'm looking for a simple way of doing it so that I can be sorta sure that the flaky test I've been trying to fix stays fixed.
我们已经有一种复杂的方法来做到这一点，但我正在寻找一种简单的方法来做到这一点，以便我可以确定我一直试图修复的片状测试保持不变。
An ideal solution would be an Eclipse plugin/setting/feature that I am unaware of.
一个理想的解决方案是我不知道的 Eclipse 插件/设置/功能。
采纳答案by Yishai
The easiest (as in least amount of new code required) way to do this is to run the test as a parametrized test (annotate with an @RunWith(Parameterized.class)and add a method to provide 10 empty parameters). That way the framework will run the test 10 times.
最简单的（至少需要最少的新代码）方法是将测试作为参数化测试运行（用 an 注释@RunWith(Parameterized.class)并添加一个方法以提供 10 个空参数）。这样框架将运行测试 10 次。
This test would need to be the only test in the class, or better put all test methods should need to be run 10 times in the class.
这个测试需要是类中唯一的测试，或者最好把所有测试方法都需要在类中运行 10 次。
Here is an example:
下面是一个例子：
@RunWith(Parameterized.class)
public class RunTenTimes {
@Parameterized.Parameters
public static Object[][] data() {
return new Object[10][0];
}
public RunTenTimes() {
}
@Test
public void runsTenTimes() {
System.out.println("run");
}
}
With the above, it is possible to even do it with a parameter-less constructor, but I'm not sure if the framework authors intended that, or if that will break in the future.
有了上面的内容，甚至可以使用无参数构造函数来做到这一点，但我不确定框架作者是否打算这样做，或者将来是否会中断。
If you are implementing your own runner, then you could have the runner run the test 10 times. If you are using a third party runner, then with 4.7, you can use the new @Ruleannotation and implement the MethodRuleinterface so that it takes the statement and executes it 10 times in a for loop. The current disadvantage of this approach is that @Beforeand @Afterget run only once. This will likely change in the next version of JUnit (the @Beforewill run after the @Rule), but regardless you will be acting on the same instance of the object (something that isn't true of the Parameterizedrunner). This assumes that whatever runner you are running the class with correctly recognizes the @Ruleannotations. That is only the case if it is delegating to the JUnit runners.
如果您正在实现自己的运行器，那么您可以让运行器运行测试 10 次。如果您使用的是第三方运行器，那么在 4.7 中，您可以使用新的@Rule注释并实现MethodRule接口，以便它接受语句并在 for 循环中执行 10 次。这种方法目前的缺点是@Before和@Afterget 只运行一次。这可能会在 JUnit 的下一个版本中发生变化（@Before将在 之后运行@Rule），但无论如何您将在对象的同一实例上执行操作（对于运行程序而言并非如此Parameterized）。这假设您运行课程的任何跑步者都能正确识别@Rule注释。只有当它委托给 JUnit 运行器时才会出现这种情况。
If you are running with a custom runner that does not recognize the @Ruleannotation, then you are really stuck with having to write your own runner that delegates appropriately to that Runner and runs it 10 times.
如果您正在使用无法识别@Rule注释的自定义运行器运行，那么您真的不得不编写自己的运行器，该运行器适当地委托给该运行器并运行 10 次。
Note that there are other ways to potentially solve this (such as the Theories runner) but they all require a runner. Unfortunately JUnit does not currently support layers of runners. That is a runner that chains other runners.
请注意，还有其他方法可以解决这个问题（例如 Theories runner），但它们都需要一个 runner。不幸的是，JUnit 目前不支持运行器层。那是一个链接其他跑步者的跑步者。
回答by laura
I've found that Spring's repeat annotation is useful for that kind of thing:
我发现 Spring 的重复注释对这类事情很有用：
@Repeat(value = 10)
Latest (Spring Framework 4.3.11.RELEASE API) doc:
最新（Spring Framework 4.3.11.RELEASE API）文档：
回答by soru
Anything wrong with:
有什么问题：
@Test
void itWorks() {
// stuff
}
@Test
void itWorksRepeatably() {
for (int i = 0; i < 10; i++) {
itWorks();
}
}
Unlike the case where you are testing each of an array of values, you don't particularly care which run failed.
与测试每个值数组的情况不同，您并不特别关心哪个运行失败。
No need to do in configuration or annotation what you can do in code.
不需要在配置或注释中做你可以在代码中做的事情。
回答by Toby
There's an Intermittent annotation in the tempus-fugitlibrary which works with JUnit 4.7's @Ruleto repeat a test several times or with @RunWith.
tempus-fugit库中有一个 Intermittent 注释，它与 JUnit 4.7@Rule一起工作以重复多次测试或使用@RunWith.
For example,
例如，
@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {
private static int testCounter = 0;
@Test
@Intermittent(repition = 99)
public void annotatedTest() {
testCounter++;
}
}
After the test is run (with the IntermittentTestRunner in the @RunWith), testCounterwould be equal to 99.
测试运行后（在 中使用 IntermittentTestRunner @RunWith），testCounter将等于 99。
回答by Qualk
This works much easier for me.
这对我来说更容易。
public class RepeatTests extends TestCase {
public static Test suite() {
TestSuite suite = new TestSuite(RepeatTests.class.getName());
for (int i = 0; i < 10; i++) {
suite.addTestSuite(YourTest.class);
}
return suite;
}
}
回答by R. Oosterholt
Inspired by the following resources:
灵感来自以下资源：
Example
例子
Create and use a @Repeatannotation as follows:
创建和使用@Repeat注释如下：
public class MyTestClass {
@Rule
public RepeatRule repeatRule = new RepeatRule();
@Test
@Repeat(10)
public void testMyCode() {
//your test code goes here
}
}
Repeat.java
重复.java
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention( RetentionPolicy.RUNTIME )
@Target({ METHOD, ANNOTATION_TYPE })
public @interface Repeat {
int value() default 1;
}
RepeatRule.java
重复规则.java
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
public class RepeatRule implements TestRule {
private static class RepeatStatement extends Statement {
private final Statement statement;
private final int repeat;
public RepeatStatement(Statement statement, int repeat) {
this.statement = statement;
this.repeat = repeat;
}
@Override
public void evaluate() throws Throwable {
for (int i = 0; i < repeat; i++) {
statement.evaluate();
}
}
}
@Override
public Statement apply(Statement statement, Description description) {
Statement result = statement;
Repeat repeat = description.getAnnotation(Repeat.class);
if (repeat != null) {
int times = repeat.value();
result = new RepeatStatement(statement, times);
}
return result;
}
}
PowerMock
电源模拟
Using this solution with @RunWith(PowerMockRunner.class), requires updating to Powermock 1.6.5(which includes a patch).
使用此解决方案@RunWith(PowerMockRunner.class)需要更新到Powermock 1.6.5（其中包括一个补丁）。
回答by Anderson Marques
I build a module that allows do this kind of tests. But it is focused not only in repeat. But in guarantee that some piece of code is Thread safe.
我构建了一个允许进行此类测试的模块。但它不仅专注于重复。但是为了保证某些代码是线程安全的。
https://github.com/anderson-marques/concurrent-testing
https://github.com/anderson-marques/concurrent-testing
Maven dependency:
Maven 依赖：
<dependency>
<groupId>org.lite</groupId>
<artifactId>concurrent-testing</artifactId>
<version>1.0.0</version>
</dependency>
Example of use:
使用示例：
package org.lite.concurrent.testing;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import ConcurrentTest;
import ConcurrentTestsRule;
/**
* Concurrent tests examples
*/
public class ExampleTest {
/**
* Create a new TestRule that will be applied to all tests
*/
@Rule
public ConcurrentTestsRule ct = ConcurrentTestsRule.silentTests();
/**
* Tests using 10 threads and make 20 requests. This means until 10 simultaneous requests.
*/
@Test
@ConcurrentTest(requests = 20, threads = 10)
public void testConcurrentExecutionSuccess(){
Assert.assertTrue(true);
}
/**
* Tests using 10 threads and make 20 requests. This means until 10 simultaneous requests.
*/
@Test
@ConcurrentTest(requests = 200, threads = 10, timeoutMillis = 100)
public void testConcurrentExecutionSuccessWaitOnly100Millissecond(){
}
@Test(expected = RuntimeException.class)
@ConcurrentTest(requests = 3)
public void testConcurrentExecutionFail(){
throw new RuntimeException("Fail");
}
}
This is a open source project. Feel free to improve.
这是一个开源项目。随意改进。
回答by César Alberca
With JUnit 5 I was able to solve this using the @RepeatedTestannotation:
使用 JUnit 5，我能够使用@RepeatedTest注释解决这个问题：
@RepeatedTest(10)
public void testMyCode() {
//your test code goes here
}
Note that @Testannotation shouldn't be used along with @RepeatedTest.
请注意，@Test注释不应与@RepeatedTest.
回答by silver_mx
You could run your JUnit test from a main method and repeat it so many times you need:
您可以从 main 方法运行 JUnit 测试，并根据需要重复多次：
package tests;
import static org.junit.Assert.*;
import org.junit.Test;
import org.junit.runner.Result;
public class RepeatedTest {
@Test
public void test() {
fail("Not yet implemented");
}
public static void main(String args[]) {
boolean runForever = true;
while (runForever) {
Result result = org.junit.runner.JUnitCore.runClasses(RepeatedTest.class);
if (result.getFailureCount() > 0) {
runForever = false;
//Do something with the result object
}
}
}
}
回答by smac89
With IntelliJ, you can do this from the test configuration. Once you open this window, you can choose to run the test any number of times you want,.
使用 IntelliJ，您可以从测试配置中执行此操作。打开此窗口后，您可以选择运行任意次数的测试。
when you run the test, intellij will execute all tests you have selected for the number of times you specified.
当您运行测试时，intellij 将按照您指定的次数执行您选择的所有测试。
Example running 624 tests 10 times:
运行 624 次测试 10 次的示例：
