JUnit टेस्ट केस @Before @BeforeClass एनोटेशन

JUnit सबसे लोकप्रिय इकाई है परीक्षण ढांचे में Java. यह स्पष्ट रूप से अनुशंसित है इकाई का परीक्षण. JUnit वेब एप्लिकेशन के परीक्षण के लिए सर्वर की आवश्यकता नहीं होती है, जिससे परीक्षण प्रक्रिया तेज हो जाती है।

JUnit फ्रेमवर्क परीक्षण मामलों और परीक्षण डेटा के त्वरित और आसान निर्माण की भी अनुमति देता है। org.जूनिट पैकेज में कई इंटरफेस और क्लास शामिल हैं JUnit परीक्षण जैसे कि टेस्ट, दावा, बाद में, पहले, आदि।

टेस्ट फिक्सचर क्या है?

इससे पहले कि हम समझें कि टेस्ट फिक्सचर क्या है, आइए नीचे दिए गए कोड का अध्ययन करें

यह कोड एक साधारण फ़ाइल पर दो परीक्षण मामलों को निष्पादित करने के लिए डिज़ाइन किया गया है।

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

यहाँ कुछ मुद्दे हैं

  • कोड पठनीय नहीं है
  • कोड को बनाए रखना आसान नहीं है।
  • जब परीक्षण सूट जटिल होता है तो कोड में तार्किक समस्याएं हो सकती हैं।

समान कोड की तुलना करें JUnit

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

कोड कहीं अधिक पठनीय और रखरखाव योग्य है। उपरोक्त कोड संरचना एक है परीक्षण स्थिरता.

टेस्ट फिक्सचर एक ऐसा संदर्भ है जहां JUnit परीक्षण का मामला रन। आम तौर पर, टेस्ट फिक्स्चर में शामिल हैं:

  • वे ऑब्जेक्ट या संसाधन जो किसी भी परीक्षण मामले के लिए उपलब्ध हैं।
  • आवश्यक गतिविधियाँ जो इन वस्तुओं/संसाधनों को उपलब्ध कराती हैं।
  • ये गतिविधियाँ हैं
    1. आवंटन (व्यवस्था)
    2. डी-आवंटन (चीथड़े कर दो).

सेटअप और टियरडाउन

  • आमतौर पर, कुछ दोहराए जाने वाले कार्य होते हैं जिन्हें प्रत्येक परीक्षण मामले से पहले किया जाना चाहिए। उदाहरण: एक डेटाबेस कनेक्शन बनाएँ.
  • इसी प्रकार, प्रत्येक परीक्षण मामले के अंत में कुछ दोहराए गए कार्य हो सकते हैं। उदाहरण: परीक्षण निष्पादन समाप्त होने के बाद सफाई करने के लिए।
  • JUnit सेटअप और टियरडाउन में मदद करने वाले एनोटेशन प्रदान करता है। यह सुनिश्चित करता है कि संसाधन जारी किए गए हैं, और परीक्षण प्रणाली अगले परीक्षण मामले के लिए तैयार स्थिति में है।

इन JUnit एनोटेशन की चर्चा नीचे की गई है-

व्यवस्था

@पहले एनोटेशन में JUnit युक्त विधि पर प्रयोग किया जाता है Java प्रत्येक परीक्षण मामले से पहले चलाने के लिए कोड। यानी यह प्रत्येक परीक्षण निष्पादन से पहले चलता है।

विध्वंस (फैसले की परवाह किए बिना)

@बाद एनोटेशन का उपयोग जावा कोड युक्त विधि पर प्रत्येक परीक्षण मामले के बाद चलाने के लिए किया जाता है। ये विधियाँ तब भी चलेंगी जब परीक्षण मामले में कोई अपवाद फेंका जाता है या अभिकथन विफलताओं के मामले में।

टिप्पणी:

  • इसमें ऊपर सूचीबद्ध किसी भी संख्या में एनोटेशन रखने की अनुमति है।
  • सभी विधियाँ एनोटेट की गई हैं @पहले in JUnit प्रत्येक परीक्षण केस से पहले चलाए जाएंगे, लेकिन वे किसी भी क्रम में चलाए जा सकते हैं।
  • आप सुपर क्लास से @Before और @After विधियों को इनहेरिट कर सकते हैं, निष्पादन इस प्रकार है: यह एक मानक निष्पादन प्रक्रिया है JUnit.
  1. निष्पादित करें JUnit सुपरक्लास में @Before विधियाँ
  2. इस वर्ग में @Before विधियों को निष्पादित करें
  3. इस वर्ग में @Test विधि निष्पादित करें
  4. इस वर्ग में @After विधियों को निष्पादित करें
  5. सुपरक्लास में @After विधियों को निष्पादित करें

उदाहरण: परीक्षण फिक्सचर के रूप में फ़ाइल के साथ एक क्लास बनाना

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

उपरोक्त उदाहरण में निष्पादन की श्रृंखला इस प्रकार होगी-

सेटअप और टियरडाउन

  1. आउटपुट फ़ाइल बनाएं()
  2. टेस्टफ़ाइल1()
  3. आउटपुट फ़ाइल हटाएं()
  4. आउटपुट फ़ाइल बनाएं()
  5. टेस्टफ़ाइल2()
  6. आउटपुट फ़ाइल हटाएं()

कल्पना:

testFile1(), testFile2() से पहले चलता है - जिसकी कोई गारंटी नहीं है।

केवल एक बार सेटअप

  • किसी भी परीक्षण के निष्पादन से पहले, तथा किसी भी परीक्षण से पहले, संपूर्ण परीक्षण वर्ग के लिए केवल एक बार विधि चलाना संभव है। @पहले विधि(याँ)।
  • "केवल एक बार सेटअप" सर्वर शुरू करने, संचार खोलने आदि के लिए उपयोगी है। प्रत्येक परीक्षण के लिए संसाधनों को बंद करना और फिर से खोलना समय लेने वाला है।
  • यह एनोटेशन का उपयोग करके किया जा सकता है @कक्षा से पहले in JUnit.
@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

केवल एक बार फाड़ना

  • एक बार केवल सेटअप के समान, एक बार-केवल क्लीनअप विधि भी उपलब्ध है। यह सभी परीक्षण केस विधियों के बाद चलती है और @बाद एनोटेशन निष्पादित किए गए हैं.
  • यह सर्वरों को रोकने, संचार लिंक बंद करने आदि के लिए उपयोगी है।
  • यह का उपयोग करके किया जा सकता है @कक्षा के बाद टिप्पणी
 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit टेस्ट सूट

यदि हम निर्दिष्ट क्रम में कई परीक्षण निष्पादित करना चाहते हैं, तो सभी परीक्षणों को एक स्थान पर संयोजित करके ऐसा किया जा सकता है। इस स्थान को टेस्ट सूट कहा जाता है। टेस्ट सूट को निष्पादित करने के तरीके और इसका उपयोग कैसे किया जाता है, इस बारे में अधिक जानकारी JUnit इसमें शामिल किया जाएगा ट्यूटोरियल.

जूनिट टेस्ट रनर

JUnit आपके परीक्षण मामलों के निष्पादन के लिए एक उपकरण प्रदान करता है।

  • JUnitमूल इन परीक्षणों को निष्पादित करने के लिए class का उपयोग किया जाता है।
  • एक विधि जिसे रनक्लासेस द्वारा प्रदान की org.junit.रनर.JUnitसार, एक या कई परीक्षण कक्षाएं चलाने के लिए उपयोग किया जाता है।
  • इस विधि का रिटर्न प्रकार है परिणाम वस्तु (org.junit.runner.परिणाम), जिसका उपयोग परीक्षणों के बारे में जानकारी तक पहुँचने के लिए किया जाता है। अधिक स्पष्टता के लिए निम्न कोड उदाहरण देखें।
public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}      

उपरोक्त कोड में "परिणाम" ऑब्जेक्ट को हमारे द्वारा निष्पादित परीक्षण मामलों की विफलताओं और सफल परिणामों को प्राप्त करने के लिए संसाधित किया जाता है।

प्रथम JUnit कार्यक्रम

एसडीएलसी, जावा प्रोग्रामिंग और मूल बातों का उचित ज्ञान सॉफ्टवेयर परिक्षण प्रक्रिया समझने में मदद करती है JUnit कार्यक्रम.

आइए एक लाइव उदाहरण का उपयोग करके यूनिट टेस्टिंग को समझते हैं। हमें एक टेस्ट क्लास बनाने की आवश्यकता है जिसमें टेस्ट विधि एनोटेट हो @परीक्षा जैसा कि नीचे दिया गया है:

MyFirstClassTest.जावा

package guru99.JUnit;		

import static org.JUnit.Assert.*;				

import org.JUnit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

टेस्टरनर.जावा

हमारे परीक्षण विधि (ऊपर) को निष्पादित करने के लिए, हमें एक टेस्ट रनर बनाने की आवश्यकता है। टेस्ट रनर में हमें पैरामीटर के रूप में टेस्ट क्लास जोड़ना होगा JUnitकोर की runclasses() विधि। यह परीक्षण परिणाम लौटाएगा, इस आधार पर कि परीक्षण पास हुआ या असफल।

इस पर अधिक जानकारी के लिए नीचे दिया गया कोड देखें:

package guru99.JUnit;		

import org.JUnit.runner.JUnitCore;		
import org.JUnit.runner.Result;		
import org.JUnit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

उत्पादन

एक बार टेस्टरनर.जावा हमारे परीक्षण विधियों को निष्पादित करने पर हमें विफल या पास के रूप में आउटपुट मिलता है। कृपया नीचे आउटपुट स्पष्टीकरण देखें:

  1. इस उदाहरण में, निष्पादन के बाद MyFirstClassTest.जावा , परीक्षण पास हो गया है और परिणाम हरे रंग में है।
  2. यदि यह विफल हो जाता तो इसका परिणाम लाल होना चाहिए था और विफलता को विफलता ट्रेस में देखा जा सकता है। नीचे देखें JUnit जीयूआई :

JUnit कार्यक्रम आउटपुट

सारांश

  • JUnit एक फ्रेमवर्क है जो एक परीक्षण युक्त विधि की पहचान करने के लिए कई एनोटेशन का समर्थन करता है।
  • JUnit नामक एक एनोटेशन प्रदान करता है @परीक्षा, जो बताता है JUnit जिस सार्वजनिक शून्य विधि में इसका उपयोग किया जाता है, वह परीक्षण मामले के रूप में चल सकती है।
  • टेस्ट फिक्सचर एक संदर्भ है जहां एक टेस्ट केस चलता है
  • एक निर्दिष्ट क्रम में कई परीक्षणों को निष्पादित करने के लिए, सभी परीक्षणों को एक स्थान पर संयोजित करके ऐसा किया जा सकता है। इस स्थान को टेस्ट सूट कहा जाता है।
  • JUnit परीक्षणों के निष्पादन के लिए एक उपकरण प्रदान करता है जहां हम अपने परीक्षण मामलों को चला सकते हैं जिसे टेस्ट रनर के रूप में संदर्भित किया जाता है।