@ বিফোর, @ বিফোরক্লাস, @ বিফোরইচ এবং @ বিফোরআল এর মধ্যে পার্থক্য

Question

এর মধ্যে প্রধান পার্থক্য কী

• @Before এবং @BeforeClass
  • এবং জুনে 5 @BeforeEachএবং@BeforeAll
• @After এবং @AfterClass

JUnit মতে অপি@Before নিম্নলিখিত ক্ষেত্রে ব্যবহৃত হয়:

পরীক্ষাগুলি লেখার সময়, এটি সাধারণভাবে দেখা যায় যে বেশ কয়েকটি পরীক্ষাগুলি চালানোর আগে তাদের অনুরূপ বস্তু তৈরি করা দরকার।

যেখানে @BeforeClassডাটাবেস সংযোগ স্থাপনের জন্য ব্যবহার করা যেতে পারে। কিন্তু @Beforeএকি করতে পারলেন না ?

Answer 1

চিহ্নিত কোডটি @Beforeপ্রতিটি পরীক্ষার আগেই কার্যকর করা হয়, যখন @BeforeClassপুরো পরীক্ষার স্থিরতার আগে একবার চালিত হয়। যদি আপনার পরীক্ষার শ্রেণিতে দশটি পরীক্ষা থাকে, @Beforeকোডটি দশবার কার্যকর করা @BeforeClassহবে , তবে কেবল একবার কার্যকর করা হবে।

সাধারণভাবে, আপনি @BeforeClassযখন একাধিক পরীক্ষার জন্য একই গণনা ব্যয়বহুল সেটআপ কোডটি ভাগ করে নেওয়া প্রয়োজন তখন আপনি ব্যবহার করেন । একটি ডাটাবেস সংযোগ স্থাপন করা এই বিভাগে আসে। আপনি থেকে কোড স্থানান্তর করতে পারেন @BeforeClassমধ্যে @Before, কিন্তু আপনার পরীক্ষা রান সময় লাগতে পারে। নোট করুন যে চিহ্নিত কোডটি @BeforeClassস্ট্যাটিক ইনিশিয়ালাইজার হিসাবে চালিত হয়, সুতরাং এটি আপনার পরীক্ষার ফিক্সচারের ক্লাস উদাহরণ তৈরির আগে চলবে run

ইন JUnit 5 , ট্যাগ @BeforeEachএবং @BeforeAllএর সমতুল হয় @Beforeএবং @BeforeClass'একবার সমস্ত পরীক্ষার সামনে' 'প্রতিটি পরীক্ষার আগে' এবং: JUnit মধ্যে 4. তাদের নাম একটি বিট আরো, যখন তারা চালানোর ইঙ্গিত ঢিলেঢালাভাবে ব্যাখ্যা করা হয়।

Comments

আহ, এখন ডিবি সংযোগের সাথে উদাহরণটি বোঝা যায়। ধন্যবাদ!

— ব্যবহারকারী 1170330

@ প্যাকওভারফ্লো অচল @BeforeClas। এটি পরীক্ষা শ্রেণীর উদাহরণ তৈরির আগে চলে।

— dasblinkenlight

মনে রাখবেন যে আপনি যখন @ বিফার ক্লাস ব্যবহার করেন তখন আপনার পদ্ধতি / প্যারামিটারটি স্থিতিশীল হওয়া দরকার

— tiagocarvalho92

এটি সরাসরি সম্পর্কিত নয়, তবে এটি 'বিভাগ অনুসারে টেস্টগুলি' গণনা করার একটি উপায় ।

— বিস্কোয়ার

আমি কেবল এটি যুক্ত করব যা @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.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

উভয় সংস্করণে বেশিরভাগ টীকা একই, তবে কয়েকটি পৃথক।

উল্লেখ

আদেশ কার্যকর

ড্যাশড বাক্স -> alচ্ছিক টীকা।

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

জুনিত 5 এ

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