यूनिट टेस्ट कैसे लिखें?

Question

मेरे पास एक जावा क्लास है जो द्विआधारी राशि करता है, मैं अब भी यह पता लगाने की कोशिश कर रहा हूं कि इकाई परीक्षण कैसे करें, लेकिन मुझे नहीं पता कि यह कैसे करना है। मैंने चारों ओर गुमराह किया है और सबसे अच्छा स्पष्टीकरण मेरे पास विकिपीडिया: http://en.wikipedia.org/wiki/Unit_testing

से पृष्ठ था लेकिन मुझे अभी भी यह सुनिश्चित नहीं है कि इस कार्यक्रम के लिए मेरा परीक्षण कैसे करें। कार्यक्रम क्या करता है मूल रूप से 2 बाइट [] लेते हैं और उन्हें जोड़ते हैं और नई बाइनरी सरणी वापस करते हैं। जावा में लिखा है। मैं इसका परीक्षण कैसे कर सकता हूं?

Answer 1

1. सही इनपुट के साथ, सामान्य मामले के लिए अपेक्षित और वांछित आउटपुट को परिभाषित करें।

2. अब, एक वर्ग की घोषणा के द्वारा परीक्षण लागू नाम यह कुछ भी (आमतौर पर TestAddingModule की तरह कुछ), और (यानी नीचे एक) की तरह यह करने के लिए testAdd पद्धति जोड़ें:

   • एक विधि लिखें, और इसके ऊपर @Test एनोटेशन जोड़ें।
   • विधि में, अपनी बाइनरी राशि और assertEquals(expectedVal,calculatedVal) चलाएं।

   • इसे चलाने के द्वारा अपनी विधि का परीक्षण करें (ग्रहण में, राइट क्लिक करें, → JUnit परीक्षण के रूप में चलाएं चुनें)।

     //for normal addition 
     @Test 
     public void testAdd1Plus1() 
     { 
         int x = 1 ; int y = 1; 
         assertEquals(2, myClass.add(x,y)); 
     } 
     

3. अन्य मामलों के रूप में वांछित जोड़ें।

   • परीक्षण करें कि एक पूर्णांक ओवरफ़्लो होने पर आपकी बाइनरी राशि अप्रत्याशित अपवाद नहीं फेंकती है।

   • परीक्षण करें कि आपकी विधि सुस्त इनपुट को सुदृढ़ रूप से संभालती है (नीचे उदाहरण)।

     //if you are using 0 as default for null, make sure your class works in that case. 
     @Test 
     public void testAdd1Plus1() 
     { 
         int y = 1; 
         assertEquals(0, myClass.add(null,y)); 
     } 
     

Answer 2

यह एक बहुत ही सामान्य सवाल है और वहाँ तरीके यह जवाब दिया जा सकता का एक बहुत है।

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

1. दो सकारात्मक संख्या के बीच एक सरल इसके अलावा:

   अपने विशिष्ट उदाहरण में, आप उदाहरण के लिए निम्नलिखित का परीक्षण कर सकता है। उन्हें जोड़ें, फिर परिणाम सत्यापित करें कि आप क्या उम्मीद करेंगे।

2. सकारात्मक और नकारात्मक संख्या के बीच एक अतिरिक्त (जो पहले तर्क के संकेत के साथ परिणाम देता है)।
3. सकारात्मक और नकारात्मक संख्या के बीच एक अतिरिक्त (जो दूसरे तर्क के संकेत के साथ परिणाम देता है)।
4. दो नकारात्मक संख्याओं के बीच एक जोड़ा।
5. एक अतिरिक्त जो एक ओवरफ्लो में परिणाम देता है।

परिणामों की पुष्टि करने के लिए आपको org.junit.Assert वर्ग से विभिन्न assertXXX तरीकों का उपयोग कर सकते हैं (सुविधा के लिए, आप कर सकते हैं 'आयात स्थिर org.junit.Assert। *')। ये विधियां किसी विशेष स्थिति का परीक्षण करती हैं और परीक्षण में असफल होती हैं यदि यह मान्य नहीं होती है (वैकल्पिक संदेश के साथ, वैकल्पिक रूप से)। आपके मामले में

उदाहरण testcase वर्ग (बिना तरीकों सामग्री परिभाषित):

import static org.junit.Assert.*; 

public class AdditionTests { 
    @Test 
    public void testSimpleAddition() { ... } 


    @Test 
    public void testPositiveNegativeAddition() { ... } 


    @Test 
    public void testNegativePositiveAddition() { ... } 


    @Test 
    public void testNegativeAddition() { ... } 


    @Test 
    public void testOverflow() { ... } 
} 

आप इकाई परीक्षण लेखन के लिए इस्तेमाल नहीं कर रहे हैं, लेकिन इसके बजाय तदर्थ परीक्षण है कि आप तो मान्य लिख कर अपने कोड का परीक्षण " दृष्टि से "(उदाहरण के लिए, आप एक साधारण मुख्य विधि लिखते हैं जो कुंजीपटल का उपयोग करके दर्ज किए गए तर्क स्वीकार करता है और फिर परिणामों को प्रिंट करता है - और फिर आप मान दर्ज करते हैं और परिणाम सही होने पर स्वयं को सत्यापित करते हैं), तो आप ऐसे परीक्षण लिखकर शुरू कर सकते हैं मैन्युअल रूप से करने के बजाय उपरोक्त प्रारूप में और सही assertXXX विधि के साथ परिणामों को मान्य करना। इस तरह, यदि आप मैन्युअल परीक्षण करना चाहते हैं तो आप परीक्षण को फिर से चला सकते हैं।

Answer 3

@CoolBeans की तरह उल्लेख किया गया है, jUnit पर एक नज़र डालें। Junit 4.x

अंत में, यदि आप वास्तव में परीक्षण और परीक्षण-संचालित विकास (टीडीडी) के बारे में अधिक जानना चाहते हैं तो मैं आपको निम्न पुस्तक पर एक नज़र डालने की सलाह देता हूं, इसके बाद आप एक संक्षिप्त tutorial भी शुरू कर सकते हैं। केंट बेक: Test-Driven Development By Example।

Answer 4

अपनी परियोजना के लिए इकाई परीक्षण बनाने के लिए, कृपया (इस परीक्षण लिखने के लिए मैं ग्रहण का उपयोग कर रहा) निम्न चरणों का पालन:

1- नई पर क्लिक करें -> जावा परियोजना।

2- नीचे अपने प्रोजेक्ट के नाम लिखें और खत्म पर क्लिक करें। अपनी परियोजना पर

3- क्लिक करें। फिर, नई -> कक्षा पर क्लिक करें।

4- नीचे अपने वर्ग के नाम लिखें और खत्म पर क्लिक करें।

फिर, इस तरह वर्ग को पूरा करें:

public class Math { 
    int a, b; 
    Math(int a, int b) { 
     this.a = a; 
     this.b = b; 
    } 
    public int add() { 
     return a + b; 
    } 
} 

5- फ़ाइल पर क्लिक करें -> नई -> JUnit टेस्ट केस।

6- चेक सेटअप() और खत्म पर क्लिक करें। SetUp() वह जगह होगी जहां आप अपना परीक्षण शुरू करेंगे।

7- ठीक पर क्लिक करें।

8- यहाँ, मैं बस 7 जोड़ सकते हैं और 10 तो, मैं इस सवाल का जवाब 17 होने की उम्मीद।पैकेज एक्सप्लोरर में अपने परीक्षण वर्ग पर क्लिक

import org.junit.Assert; 
import org.junit.Before; 
import org.junit.Test; 
public class MathTest { 
    Math math; 
    @Before 
    public void setUp() throws Exception { 
     math = new Math(7, 10); 
    } 
    @Test 
    public void testAdd() { 
     Assert.assertEquals(17, math.add()); 
    } 
} 

9- लिखें और के रूप में चलाएं पर क्लिक करें -> JUnit परीक्षण: इस तरह अपने परीक्षण वर्ग को पूरा करें।

10- इस परीक्षा का परिणाम है।

मुझे आशा है कि यह मदद करता है।

Answer 5

public class FirtJunit { 

    @BeforeClass 
    public static void startUp() { 
     System.out.println("BeforeClass"); 
    } 
    @AfterClass 
    public static void shutDown() { 
     System.out.println("AfterClass"); 
    } 
    @Before 
    public void setup() { 
     System.out.println("Before"); 
    } 
    @After 
    public void tearDown() { 
     System.out.println("After"); 
    } 
    @Test 
    public void mul() { 
     System.out.println("Test for mul"); 
    } 
    @Test 
    public void div() { 
     System.out.println("Test for div"); 
    } 




}