Giống như tiêu đề đã nói, tôi đang tìm một số cách đơn giản để chạy các bài kiểm tra JUnit 4.x nhiều lần liên tiếp bằng Eclipse.

Một ví dụ sẽ chạy cùng một bài kiểm tra 10 lần liên tiếp và báo cáo lại kết quả.

Chúng tôi đã có một cách phức tạp để thực hiện việc này nhưng tôi đang tìm một cách đơn giản để thực hiện nó để tôi có thể chắc chắn rằng bài kiểm tra bị bong tróc mà tôi đang cố gắng khắc phục vẫn được khắc phục.

Một giải pháp lý tưởng sẽ là một plugin / cài đặt / tính năng Eclipse mà tôi không biết.

Cách dễ nhất (với số lượng ít nhất là yêu cầu mã mới) để làm điều này là chạy thử nghiệm dưới dạng thử nghiệm tham số hóa (chú thích bằng một @RunWith(Parameterized.class)và thêm một phương thức để cung cấp 10 tham số trống). Bằng cách đó, khuôn khổ sẽ chạy thử nghiệm 10 lần.

Bài kiểm tra này cần phải là bài kiểm tra duy nhất trong lớp, hay tốt hơn là tất cả các phương pháp kiểm tra cần được chạy 10 lần trong lớp.

Đây là một ví dụ:

@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");
    }
}

Với những điều trên, bạn thậm chí có thể làm điều đó với một hàm tạo ít tham số, nhưng tôi không chắc liệu các tác giả khung có ý định như vậy hay không, hoặc liệu điều đó có bị phá vỡ trong tương lai hay không.

Nếu bạn đang thực hiện người chạy của riêng mình, thì bạn có thể để người chạy thử nghiệm 10 lần. Nếu bạn đang sử dụng trình chạy bên thứ ba, thì với 4.7, bạn có thể sử dụng @Rulechú thích mới và triển khai MethodRulegiao diện để nó nhận câu lệnh và thực thi nó 10 lần trong một vòng lặp for. Nhược điểm hiện tại của phương pháp này là @Beforevà chỉ @Afterđược chạy một lần. Điều này có thể sẽ thay đổi trong phiên bản tiếp theo của JUnit ( @Beforesẽ chạy sau @Rule), nhưng bất kể bạn sẽ hành động trên cùng một phiên bản của đối tượng (điều gì đó không đúng với trình Parameterizedchạy). Điều này giả định rằng bất kỳ người chạy nào bạn đang chạy lớp với nó đều nhận ra chính xác các @Rulechú thích. Đó chỉ là trường hợp nếu nó được ủy quyền cho những người chạy JUnit.

Nếu bạn đang chạy với một trình chạy tùy chỉnh không nhận ra @Rulechú thích, thì bạn thực sự gặp khó khăn với việc phải viết trình chạy của riêng mình ủy quyền thích hợp cho Trình chạy đó và chạy nó 10 lần.

Lưu ý rằng có những cách khác để giải quyết vấn đề này (chẳng hạn như Trình chạy theo lý thuyết) nhưng tất cả đều yêu cầu người chạy. Rất tiếc, JUnit hiện không hỗ trợ các lớp người chạy. Đó là một vận động viên chạy dây chuyền các vận động viên khác.

Với IntelliJ, bạn có thể thực hiện việc này từ cấu hình thử nghiệm. Khi bạn mở cửa sổ này, bạn có thể chọn chạy thử nghiệm bất kỳ số lần nào bạn muốn ,.

khi bạn chạy thử nghiệm, intellij sẽ thực hiện tất cả các thử nghiệm bạn đã chọn cho số lần bạn chỉ định.

Ví dụ chạy 624 bài kiểm tra 10 lần:

Tôi nhận thấy rằng chú thích lặp lại của Spring rất hữu ích cho những việc đó:

@Repeat(value = 10)

Tài liệu mới nhất (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Kiểm tra đơn vị vào mùa xuân

Lấy cảm hứng từ các nguồn sau:

• bài viết trên blog
• giải pháp này
• phiên bản bình luận

Thí dụ

Tạo và sử dụng @Repeatchú thích như sau:

public class MyTestClass {

    @Rule
    public RepeatRule repeatRule = new RepeatRule();

    @Test
    @Repeat(10)
    public void testMyCode() {
        //your test code goes here
    }
}

Repeat.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

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

Sử dụng giải pháp này với @RunWith(PowerMockRunner.class), yêu cầu cập nhật lên Powermock 1.6.5 (bao gồm một bản vá ).

Với JUnit 5, tôi có thể giải quyết vấn đề này bằng cách sử dụng chú thích @RepeatedTest :

@RepeatedTest(10)
public void testMyCode() {
    //your test code goes here
}

Lưu ý rằng @Testkhông nên sử dụng chú thích cùng với @RepeatedTest.

Có gì sai với:

@Test
void itWorks() {
    // stuff
}

@Test
void itWorksRepeatably() {
    for (int i = 0; i < 10; i++) {
        itWorks();
    }
}

Không giống như trường hợp bạn đang kiểm tra từng mảng giá trị, bạn không đặc biệt quan tâm đến việc chạy không thành công.

Không cần phải làm trong cấu hình hoặc chú thích những gì bạn có thể làm trong mã.

Điều này làm việc dễ dàng hơn nhiều đối với tôi.

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;
    }
}

Có một chú thích ngắt quãng trong thư viện tempus-fugit hoạt động với JUnit 4.7 @Ruleđể lặp lại một bài kiểm tra nhiều lần hoặc với @RunWith.

Ví dụ,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

   @Test
   @Intermittent(repition = 99)
   public void annotatedTest() {
      testCounter++;
   }
}

Sau khi chạy thử nghiệm (với IntermittentTestRunner trong @RunWith), testCountersẽ bằng 99.

Tôi xây dựng một mô-đun cho phép thực hiện loại thử nghiệm này. Nhưng nó không chỉ được tập trung lặp lại. Nhưng đảm bảo rằng một số đoạn mã là Thread an toàn.

https://github.com/anderson-marques/concurrent-testing

Sự phụ thuộc của Maven:

<dependency>
    <groupId>org.lite</groupId>
    <artifactId>concurrent-testing</artifactId>
    <version>1.0.0</version>
</dependency>

Ví dụ sử dụng:

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");
    }
}

Đây là một dự án mã nguồn mở. Hãy tự do cải thiện.

Bạn có thể chạy thử nghiệm JUnit của mình từ một phương thức chính và lặp lại nó nhiều lần bạn cần:

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

            }
        }

    }

}

Đây thực chất là câu trả lời mà Yishai đã cung cấp ở trên, được viết lại bằng Kotlin:

@RunWith(Parameterized::class)
class MyTest {

    companion object {

        private const val numberOfTests = 200

        @JvmStatic
        @Parameterized.Parameters
        fun data(): Array<Array<Any?>> = Array(numberOfTests) { arrayOfNulls<Any?>(0) }
    }

    @Test
    fun testSomething() { }
}