Seperti judulnya, saya mencari cara sederhana untuk menjalankan pengujian JUnit 4.x beberapa kali berturut-turut secara otomatis menggunakan Eclipse.

Contoh akan menjalankan pengujian yang sama 10 kali berturut-turut dan melaporkan kembali hasilnya.

Kami sudah memiliki cara yang rumit untuk melakukan ini, tetapi saya sedang mencari cara sederhana untuk melakukannya sehingga saya dapat yakin bahwa tes tak stabil yang saya coba perbaiki tetap diperbaiki.

Solusi ideal adalah plugin / pengaturan / fitur Eclipse yang tidak saya sadari.

Cara termudah (dengan jumlah paling sedikit kode baru yang diperlukan) untuk melakukan ini adalah dengan menjalankan pengujian sebagai pengujian parametrized (beri anotasi dengan @RunWith(Parameterized.class)dan tambahkan metode untuk menyediakan 10 parameter kosong). Dengan begitu framework akan menjalankan pengujian 10 kali.

Pengujian ini harus menjadi satu-satunya pengujian di kelas, atau lebih baik letakkan semua metode pengujian yang harus dijalankan 10 kali di kelas.

Berikut ini contohnya:

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

Dengan hal di atas, bahkan mungkin untuk melakukannya dengan konstruktor tanpa parameter, tetapi saya tidak yakin apakah penulis kerangka bermaksud itu, atau apakah itu akan rusak di masa mendatang.

Jika Anda menerapkan pelari Anda sendiri, Anda dapat meminta pelari menjalankan pengujian 10 kali. Jika Anda menggunakan runner pihak ketiga, maka dengan 4.7, Anda dapat menggunakan @Ruleanotasi baru dan mengimplementasikan MethodRuleantarmukanya sehingga ia mengambil pernyataan dan mengeksekusinya 10 kali dalam perulangan for. Kerugian saat ini dari pendekatan ini adalah @Beforedan @Afterdijalankan hanya sekali. Ini kemungkinan akan berubah di versi JUnit berikutnya (yang @Beforeakan berjalan setelah @Rule), tetapi terlepas dari apa pun Anda akan bertindak pada contoh objek yang sama (sesuatu yang tidak benar dari Parameterizedpelari). Ini mengasumsikan bahwa pelari apa pun yang Anda jalankan dengan kelas mengenali @Ruleanotasi dengan benar . Itu hanya kasus jika itu mendelegasikan ke pelari JUnit.

Jika Anda menjalankan dengan runner kustom yang tidak mengenali @Ruleanotasi, Anda benar-benar harus menulis runner Anda sendiri yang mendelegasikan secara tepat ke Runner tersebut dan menjalankannya 10 kali.

Perhatikan bahwa ada cara lain untuk menyelesaikan masalah ini (seperti pelari Teori) tetapi semuanya membutuhkan pelari. Sayangnya JUnit saat ini tidak mendukung lapisan pelari. Itu adalah pelari yang mengikat pelari lainnya.

Dengan IntelliJ, Anda dapat melakukan ini dari konfigurasi pengujian. Setelah Anda membuka jendela ini, Anda dapat memilih untuk menjalankan pengujian beberapa kali.

ketika Anda menjalankan pengujian, intellij akan menjalankan semua pengujian yang telah Anda pilih untuk berapa kali Anda tentukan.

Contoh menjalankan 624 pengujian 10 kali:

Saya telah menemukan bahwa anotasi berulang Spring berguna untuk hal semacam itu:

@Repeat(value = 10)

Dokumen terbaru (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Pengujian Unit di Musim Semi

Terinspirasi oleh sumber daya berikut:

• posting blog
• solusi ini
• versi yang dikomentari

Contoh

Buat dan gunakan @Repeatanotasi sebagai berikut:

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

Menggunakan solusi ini dengan @RunWith(PowerMockRunner.class), memerlukan pembaruan ke Powermock 1.6.5 (yang menyertakan tambalan ).

Dengan JUnit 5 saya dapat menyelesaikan ini menggunakan anotasi @RepruptedTest :

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

Perhatikan bahwa @Testanotasi tidak boleh digunakan bersama @RepeatedTest.

Ada yang salah dengan:

@Test
void itWorks() {
    // stuff
}

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

Tidak seperti kasus saat Anda menguji setiap larik nilai, Anda tidak terlalu peduli menjalankan mana yang gagal.

Tidak perlu melakukan konfigurasi atau penjelasan apa yang dapat Anda lakukan dalam kode.

Ini bekerja lebih mudah bagi saya.

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

Ada anotasi Intermiten di perpustakaan tempus-fugit yang bekerja dengan JUnit 4.7 @Ruleuntuk mengulangi pengujian beberapa kali atau bersama @RunWith.

Sebagai contoh,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Setelah pengujian dijalankan (dengan IntermittentTestRunner di @RunWith), testCounterakan sama dengan 99.

Saya membangun modul yang memungkinkan melakukan tes semacam ini. Tapi itu difokuskan tidak hanya pada pengulangan. Tetapi untuk menjamin bahwa beberapa bagian kode aman untuk Thread.

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

Ketergantungan Maven:

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

Contoh penggunaan:

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

Ini adalah proyek open source. Silakan perbaiki.

Anda dapat menjalankan pengujian JUnit dari metode utama dan mengulanginya berkali-kali yang Anda butuhkan:

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

            }
        }

    }

}

Ini pada dasarnya adalah jawaban yang diberikan Yishai di atas, ditulis ulang di 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() { }
}