ความแตกต่างระหว่าง @Before, @BeforeClass, @BeforeEach และ @BeforeAll

ความแตกต่างที่สำคัญระหว่างคืออะไร

• @Before และ @BeforeClass
  • และใน JUnit 5 @BeforeEachและ@BeforeAll
• @After และ @AfterClass

ตามที่JUnit Api @Beforeใช้ในกรณีต่อไปนี้:

เมื่อเขียนการทดสอบเป็นเรื่องปกติที่พบว่าการทดสอบหลายรายการต้องการวัตถุที่คล้ายกันที่สร้างขึ้นก่อนที่จะสามารถเรียกใช้ได้

ในขณะที่@BeforeClassสามารถใช้เพื่อสร้างการเชื่อมต่อฐานข้อมูล แต่@Beforeทำไม่ได้เหมือนกันเหรอ?

รหัสที่ทำเครื่องหมายไว้@Beforeจะถูกเรียกใช้ก่อนการทดสอบแต่ละครั้งในขณะที่@BeforeClassทำงานหนึ่งครั้งก่อนการติดตั้งการทดสอบทั้งหมด หากคลาสทดสอบของคุณมีสิบการทดสอบ@Beforeโค้ดจะถูกดำเนินการสิบครั้ง แต่@BeforeClassจะถูกเรียกใช้งานเพียงครั้งเดียว

โดยทั่วไปคุณใช้@BeforeClassเมื่อการทดสอบหลายครั้งต้องแชร์รหัสการตั้งค่าที่มีราคาแพงเหมือนกัน การสร้างการเชื่อมต่อฐานข้อมูลอยู่ในหมวดหมู่นี้ คุณสามารถย้ายรหัสจาก@BeforeClassลงใน@Beforeแต่การทดสอบของคุณอาจใช้เวลานาน โปรดทราบว่ารหัสที่ทำเครื่องหมาย@BeforeClassจะเรียกใช้เป็น initializer คงที่ดังนั้นมันจะทำงานก่อนที่อินสแตนซ์คลาสของฟิกซ์เจอร์ทดสอบของคุณจะถูกสร้างขึ้น

ในJUnit 5แท็ก@BeforeEachและ@BeforeAllเทียบเท่าของ@Beforeและ@BeforeClassใน JUnit 4 ชื่อของพวกเขาเป็นตัวบ่งชี้ที่มากขึ้นเมื่อพวกเขาเรียกใช้ตีความอย่างหลวม ๆ : 'ก่อนการทดสอบแต่ละครั้ง' และ 'หนึ่งครั้งก่อนการทดสอบทั้งหมด'

ความแตกต่างระหว่างคำอธิบายประกอบแต่ละรายการคือ:

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

คำอธิบายประกอบส่วนใหญ่ในทั้งสองเวอร์ชันเหมือนกัน แต่มีความแตกต่างกันเล็กน้อย

การอ้างอิง

คำสั่งของการดำเนินการ

กล่องประ -> คำอธิบายประกอบที่เป็นตัวเลือก

ก่อนและ BeforeClass ใน JUnit

@Beforeคำอธิบายประกอบฟังก์ชั่นจะถูกดำเนินการก่อนที่แต่ละฟังก์ชั่นการทดสอบในชั้นเรียนที่มี@Testคำอธิบายประกอบ แต่ฟังก์ชั่นด้วย@BeforeClassจะถูกดำเนินการเพียงครั้งเดียวก่อนฟังก์ชั่นการทดสอบทั้งหมดในชั้นเรียน

ในทำนองเดียวกันฟังก์ชั่นที่มี@Afterคำอธิบายประกอบจะถูกดำเนินการหลังจากที่แต่ละฟังก์ชั่นการทดสอบในระดับที่มี@Testคำอธิบายประกอบ แต่ฟังก์ชั่นที่มี@AfterClassจะได้รับการดำเนินการเพียงครั้งเดียวหลังจากที่ทุกฟังก์ชั่นการทดสอบในชั้นเรียน

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

}

เอาท์พุต

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

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

เหมือนกับ

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