@Before, @BeforeClass, @BeforeEach और @BeforeAll के बीच अंतर

Question

मुख्य अंतर क्या है

• @Before तथा @BeforeClass
  • और JUnit 5 @BeforeEachऔर में@BeforeAll
• @After तथा @AfterClass

JUnit Api के अनुसार @Beforeनिम्नलिखित मामले में प्रयोग किया जाता है:

परीक्षण लिखते समय, यह पता लगाना आम है कि कई परीक्षणों को चलाने से पहले समान वस्तुओं की आवश्यकता होती है।

जबकि @BeforeClassएक डेटाबेस कनेक्शन स्थापित करने के लिए इस्तेमाल किया जा सकता है। लेकिन ऐसा नहीं @Beforeकर सका ?

Answer 1

चिह्नित किए गए कोड को @Beforeप्रत्येक परीक्षण से पहले निष्पादित किया जाता है, जबकि @BeforeClassपूरे परीक्षण स्थिरता से पहले एक बार चलता है। यदि आपके परीक्षण वर्ग में दस परीक्षण हैं, तो @Beforeकोड को दस बार @BeforeClassनिष्पादित किया जाएगा , लेकिन केवल एक बार निष्पादित किया जाएगा।

सामान्य तौर पर, आप उपयोग @BeforeClassकरते हैं जब कई परीक्षणों को समान कम्प्यूटेशनल रूप से महंगा सेटअप कोड साझा करने की आवश्यकता होती है। डेटाबेस कनेक्शन स्थापित करना इस श्रेणी में आता है। आप से कोड स्थानांतरित कर सकते हैं @BeforeClassमें @Beforeहै, लेकिन अपने परीक्षण चालन समय लग सकता है। ध्यान दें कि चिह्नित कोड @BeforeClassको स्टेटिक इनिशियलाइज़र के रूप में चलाया जाता है, इसलिए यह आपके टेस्ट फिक्सचर के क्लास इंस्टेंस बनने से पहले चलेगा।

में JUnit 5 , टैग @BeforeEachऔर @BeforeAllके समकक्ष हैं @Beforeऔर @BeforeClass'एक बार सभी परीक्षणों से पहले' 'प्रत्येक परीक्षण से पहले' और: JUnit में 4. उनके नाम में थोड़ा और अधिक, जब वे चलाने का संकेत शिथिल व्याख्या कर रहे हैं।

Comments

आह, अब DB कनेक्शन के साथ उदाहरण समझ में आता है। धन्यवाद!

— user1170330

@pacoverflow @BeforeClasस्थिर है। यह टेस्ट क्लास के इंस्टेंस बनने से पहले चलता है।

— dasblinkenlight 15

ध्यान रखें कि जब आप

— @BeforeClass का

यह सीधे तौर पर संबंधित नहीं है, लेकिन यह 'टेस्ट बाई कैटिगरी' काउंटर की गणना करने का एक तरीका है ।

— Bsquare

मैं केवल वही जोड़ूंगा जो @BeforeAllगैर-स्थिर हो सकता है और हर नए परीक्षण-इंस्टेंस रन पर कॉल कर सकता है। इसी उत्तर को देखें stackoverflow.com/a/55720750/1477873

— सर्गेई

Answer 2

प्रत्येक एनोटेशन के बीच अंतर हैं:

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

दोनों संस्करणों में अधिकांश एनोटेशन समान हैं, लेकिन कुछ अलग हैं।

संदर्भ

निष्पादन का आदेश।

डैश बॉक्स -> वैकल्पिक एनोटेशन।

Answer 3

JUnit में और इससे पहले किक्लास

फ़ंक्शन @Beforeएनोटेशन को क्लास में @Testएनोटेशन वाले प्रत्येक परीक्षण फ़ंक्शन से पहले निष्पादित किया जाएगा, लेकिन फ़ंक्शन के साथ @BeforeClassफ़ंक्शन क्लास में सभी परीक्षण कार्यों से केवल एक समय पहले निष्पादित किया जाएगा।

इसी प्रकार @Afterएनोटेशन के साथ फ़ंक्शन को एनोटेशन वाले कक्षा में प्रत्येक परीक्षण फ़ंक्शन के बाद निष्पादित किया जाएगा, @Testलेकिन क्लास में @AfterClassसभी परीक्षण कार्यों के बाद फ़ंक्शन केवल एक बार निष्पादित किया जाएगा।

SampleClass

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

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

नमूना जाँच

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

जूनत में ५

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

Comments

बहुत अच्छा उदाहरण है।

— कणपार्तिकिरन

Answer 4

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