Sự khác biệt giữa @B Before, @B BeforeClass, @B BeforeEach và @B Before ALL

Sự khác biệt chính giữa

• @Before và @BeforeClass
  • và trong JUnit 5 @BeforeEachvà@BeforeAll
• @After và @AfterClass

Theo Api JUnit @Before được sử dụng trong trường hợp sau:

Khi viết bài kiểm tra, người ta thường thấy rằng một số bài kiểm tra cần các đối tượng tương tự được tạo trước khi chúng có thể chạy.

Trong khi đó @BeforeClasscó thể được sử dụng để thiết lập kết nối cơ sở dữ liệu. Nhưng không thể @Beforelàm như vậy?

Mã được đánh dấu @Befoređược thực thi trước mỗi thử nghiệm, trong khi @BeforeClasschạy một lần trước toàn bộ lịch thi thử. Nếu lớp kiểm tra của bạn có mười bài kiểm tra, @Beforemã sẽ được thực thi mười lần, nhưng @BeforeClasssẽ chỉ được thực hiện một lần.

Nói chung, bạn sử dụng @BeforeClasskhi nhiều thử nghiệm cần chia sẻ cùng một mã thiết lập tính toán đắt tiền. Thiết lập kết nối cơ sở dữ liệu thuộc loại này. Bạn có thể di chuyển mã từ @BeforeClassvào @Before, nhưng quá trình chạy thử của bạn có thể mất nhiều thời gian hơn. Lưu ý rằng mã được đánh dấu @BeforeClassđược chạy dưới dạng trình khởi tạo tĩnh, do đó, mã sẽ chạy trước khi thể hiện lớp của vật cố kiểm tra của bạn được tạo.

Trong JUnit 5 , các thẻ @BeforeEachvà @BeforeAlllà tương đương @Beforevà @BeforeClasstrong JUnit 4. Tên của chúng có nhiều dấu hiệu hơn khi chúng chạy, diễn giải một cách lỏng lẻo: 'trước mỗi bài kiểm tra' và 'một lần trước tất cả các bài kiểm tra'.

Sự khác biệt giữa mỗi chú thích là:

+-------------------------------------------------------------------------------------------------------+
¦                                       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.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

Hầu hết các chú thích trong cả hai phiên bản đều giống nhau, nhưng ít khác nhau.

Tài liệu tham khảo

Lệnh thi hành án.

Hộp nét đứt -> chú thích tùy chọn.

Before và BeforeClass trong JUnit

@BeforeChú thích chức năng sẽ được thực thi trước mỗi chức năng kiểm tra trong lớp có @Testchú thích nhưng chức năng với @BeforeClasssẽ chỉ được thực hiện một lần trước khi tất cả các chức năng kiểm tra trong lớp.

Hàm tương tự với @Afterchú thích sẽ được thực thi sau mỗi hàm kiểm tra trong lớp có @Testchú thích nhưng hàm với @AfterClasssẽ chỉ được thực hiện một lần sau khi tất cả các hàm kiểm tra trong lớp.

Mẫu kính

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

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

Mẫu thử

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

}

Đầu ra

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

Trong tháng 6

@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())
    }
}

Giống như

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())
    }
}