Perbedaan antara @Before, @BeforeClass, @BeforeEach dan @BeforeAll

Apa perbedaan utama di antara keduanya

• @Before dan @BeforeClass
  • dan dalam JUnit 5 @BeforeEachdan@BeforeAll
• @After dan @AfterClass

Menurut JUnit Api @Before digunakan dalam kasus berikut:

Saat menulis tes, adalah umum untuk menemukan bahwa beberapa tes membutuhkan objek yang sama dibuat sebelum mereka dapat berjalan.

Padahal @BeforeClassbisa digunakan untuk membuat koneksi basis data. Tetapi tidak dapat @Beforemelakukan hal yang sama?

Kode yang ditandai @Beforedieksekusi sebelum setiap tes, sementara @BeforeClassdijalankan sekali sebelum seluruh fixture tes. Jika kelas tes Anda memiliki sepuluh tes, @Beforekode akan dieksekusi sepuluh kali, tetapi @BeforeClassakan dieksekusi hanya sekali.

Secara umum, Anda menggunakan @BeforeClassketika beberapa tes perlu berbagi kode pengaturan yang mahal secara komputasi. Membuat koneksi database termasuk dalam kategori ini. Anda dapat memindahkan kode dari @BeforeClasske @Before, tetapi pengujian Anda mungkin memakan waktu lebih lama. Perhatikan bahwa kode yang ditandai @BeforeClassdijalankan sebagai penginisialisasi statis, oleh karena itu kode tersebut akan berjalan sebelum instance kelas dari perlengkapan pengujian Anda dibuat.

Dalam JUnit 5 , tag @BeforeEachdan @BeforeAllmerupakan padanan dari @Beforedan @BeforeClassdi JUnit 4. Nama mereka sedikit lebih menunjukkan kapan mereka berjalan, secara longgar ditafsirkan: 'sebelum setiap tes' dan 'sekali sebelum semua tes'.

Perbedaan antara masing-masing anotasi adalah:

+-------------------------------------------------------------------------------------------------------+
¦                                       Feature                            ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Execute before all test methods of the class are executed.               ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some initialization code          ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after all test methods in the current class.                     ¦ @AfterClass  ¦ @AfterAll   ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some cleanup code.                ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute before each test method.                                         ¦ @Before      ¦ @BeforeEach ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to reinitialize some class attributes used by the methods.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after each test method.                                          ¦ @After       ¦ @AfterEach  ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to roll back database modifications.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

Sebagian besar anotasi di kedua versi itu sama, tetapi sedikit berbeda.

Referensi

Perintah Eksekusi.

Kotak putus-putus -> anotasi opsional.

Sebelum dan SebelumKelas di JUnit

@BeforeAnotasi fungsi akan dieksekusi sebelum masing-masing fungsi tes di kelas memiliki @Testanotasi tetapi fungsi dengan @BeforeClassakan dieksekusi hanya satu kali sebelum semua fungsi tes di kelas.

Demikian pula fungsi dengan @Afteranotasi akan dieksekusi setelah masing-masing fungsi tes di kelas memiliki @Testanotasi tetapi fungsi dengan @AfterClassakan dieksekusi hanya satu kali setelah semua fungsi tes di kelas.

SampleClass

public class SampleClass {
    public String initializeData(){
        return "Initialize";
    }

    public String processDate(){
        return "Process";
    }
 }

SampleTest

public class SampleTest {

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction(){
        System.out.println("Before Class");
    }

    @Before
    public void beforeFunction(){
        sampleClass=new SampleClass();
        System.out.println("Before Function");
    }

    @After
    public void afterFunction(){
        System.out.println("After Function");
    }

    @AfterClass
    public static void afterClassFunction(){
        System.out.println("After Class");
    }

    @Test
    public void initializeTest(){
        Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() );
    }

    @Test
    public void processTest(){
        Assert.assertEquals("Process check", "Process", sampleClass.processDate() );
    }

}

Keluaran

Before Class
Before Function
After Function
Before Function
After Function
After Class

Di Junit 5

@Before = @BeforeEach
@BeforeClass = @BeforeAll
@After = @AfterEach
@AfterClass = @AfterAll

import org.junit.Assert
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Test

class FeatureTest {
    companion object {
        private lateinit var heavyFeature: HeavyFeature
        @BeforeClass
        @JvmStatic
        fun beforeHeavy() {
            heavyFeature = HeavyFeature()
        }
    }

    private lateinit var feature: Feature

    @Before
    fun before() {
        feature = Feature()
    }

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}

Sama dengan

import org.junit.Assert
import org.junit.Test

 class FeatureTest {
    companion object {
        private val heavyFeature = HeavyFeature()
    }

    private val feature = Feature()

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}