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

135

मेरे पास एक जावा वर्ग है। मैं इसका परीक्षण कैसे कर सकता हूं ?

मेरे मामले में, मेरे पास एक द्विआधारी राशि है। यह दो byte[]सरणियों लेता है , उन्हें रकम देता है, और एक नया बाइनरी सरणी देता है।

java unit-testing

— Tsundoku
स्रोत

7

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

— कूलबाइन्स

133

एक सामान्य मामले के लिए अपेक्षित और वांछित आउटपुट को सही इनपुट के साथ परिभाषित करें।
अब, एक कक्षा घोषित करके परीक्षण को लागू करें, इसे कुछ भी नाम दें (आमतौर पर 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));
}
```
अन्य मामलों को इच्छानुसार जोड़ें।
- परीक्षण करें कि यदि एक पूर्णांक अतिप्रवाह है तो आपकी बाइनरी राशि एक अप्रत्याशित अपवाद नहीं फेंकती है।
- परीक्षण करें कि आपका तरीका अशक्त इनपुट को इनायत से संभालता है (उदाहरण के लिए नीचे)।
```
//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));
}
```

— jayunit100
स्रोत

1. क्या @Test नोटेशन की आवश्यकता है? 2. क्यों नहीं aslarNotNull के साथ अशक्त इनपुट के लिए परीक्षण? 3. यूनिट परीक्षणों के परिणाम कहां कैप्चर किए गए हैं? उपयोगकर्ता को परिणाम कैसे बताए जाते हैं?

— user137717

10

हां, @Testसंकेतन की आवश्यकता है। यह इकाई परीक्षण धावक को संकेत देने के लिए किया जाता है कि यह विधि एक इकाई परीक्षण का प्रतिनिधित्व करती है और इसे निष्पादित किया जाना चाहिए। @Testजिन तरीकों से एनोटेट नहीं किया जाता है उन्हें परीक्षण धावक द्वारा निष्पादित नहीं किया जाता है।

— अली शाह अहमद

दूसरे परीक्षण के लिए - सिर्फ आपको देने के nullलिए ए नहीं जोड़ना चाहिए ? yy

— अदजीत

धन्यवाद! मुझे पता है कि staticपरीक्षण विधि के संशोधक में जोड़ने की आवश्यकता क्यों है ।

— लियांग झांग

103

मैं यह पोस्ट IntelliJ और ग्रहण दोनों के लिए प्रदान करता हूं ।

ग्रहण:

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

1- New -> Java Project पर क्लिक करें।

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- पैकेज एक्सप्लोरर में अपने टेस्ट क्लास पर क्लिक करें और रन -> जुनाइट टेस्ट पर क्लिक करें।

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

IntelliJ: ध्यान दें कि मैंने स्क्रीनशॉट के लिए IntelliJ IDEA समुदाय 2020.1 का उपयोग किया था। इसके अलावा, आपको इन चरणों से पहले अपना jre सेट करना होगा। मैं JDK 11.0.4 का उपयोग कर रहा हूं।

1- अपनी परियोजना के मुख्य फ़ोल्डर पर राइट क्लिक करें-> नया -> निर्देशिका। आपको इसे 'परीक्षण' कहना चाहिए। 2- परीक्षण फ़ोल्डर पर राइट-क्लिक करें और उचित पैकेज बनाएं। मैं मूल वर्ग के समान पैकेजिंग नाम बनाने का सुझाव देता हूं। फिर, आप परीक्षण निर्देशिका पर राइट क्लिक करें -> मार्क निर्देशिका के रूप में -> परीक्षण स्रोत रूट। 3- परीक्षण निर्देशिका में सही पैकेज में, आपको एक जावा वर्ग बनाने की आवश्यकता है (मैं Test.java का उपयोग करने का सुझाव देता हूं)। 4- बनाई गई कक्षा में, '@ टेस्ट' टाइप करें। फिर, IntelliJ आपको जो विकल्प देता है, उनमें 'JUnitx' को classpath में चुनें। 5- अपने टेस्ट क्लास में अपना टेस्ट मेथड लिखें। विधि हस्ताक्षर की तरह है:

@Test
public void test<name of original method>(){
...
}

आप अपने दावे नीचे की तरह कर सकते हैं:

Assertions.assertTrue(f.flipEquiv(node1_1, node2_1));

ये आयात हैं जो मैंने जोड़े:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

यह परीक्षण है जो मैंने लिखा है:

आप नीचे दिए गए तरीकों की जाँच कर सकते हैं:

Assertions.assertEquals(<Expected>,<actual>);
Assertions.assertTrue(<actual>);
...

अपने यूनिट परीक्षणों को चलाने के लिए, परीक्षण पर राइट-क्लिक करें और रन पर क्लिक करें।

यदि आपका परीक्षा पास होता है, तो परिणाम नीचे दिया जाएगा:

मुझे उम्मीद है यह मदद करेगा। आप GitHub https://github.com/m-vahidalizadeh/problem_solve_project में प्रोजेक्ट की संरचना देख सकते हैं ।

— मोहम्मद
स्रोत

12

अपने जवाब से प्यार करें, यह सबसे अच्छा "कैसे-करें" है!

— अलिसा

4

मुझे खुशी है कि मेरा जवाब मददगार था। आपकी टिप्पणी के लिये धन्यवाद।

— मोहम्मद

1

यह वही है जो ट्यूटोरियल की तरह दिखना चाहिए; स्वच्छ, संक्षिप्त, पूर्ण उदाहरण। बहुत अच्छा।

— जैक ऑफ ब्लेड्स

1

बहुत बहुत शुक्रिया जैक। मुझे खुशी है कि आपने इसे मददगार पाया।

— मोहम्मद

18

यह एक बहुत ही सामान्य प्रश्न है और इसके बहुत से तरीके हैं जिनका उत्तर दिया जा सकता है।

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

अपने विशिष्ट उदाहरण में, आप उदाहरण के लिए निम्नलिखित परीक्षण कर सकते हैं:

दो सकारात्मक संख्याओं के बीच एक सरल जोड़। उन्हें जोड़ें, फिर परिणाम सत्यापित करें कि आप क्या अपेक्षा करेंगे।
एक सकारात्मक और एक नकारात्मक संख्या के बीच एक जोड़ (जो पहले तर्क के संकेत के साथ एक परिणाम देता है)।
एक सकारात्मक और एक नकारात्मक संख्या के बीच एक जोड़ (जो दूसरे तर्क के संकेत के साथ एक परिणाम देता है)।
दो नकारात्मक संख्याओं के बीच एक जोड़।
एक अतिरिक्त के परिणामस्वरूप एक अतिप्रवाह होता है।

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

उदाहरण आपके मामले में टेस्टकेस क्लास (बिना परिभाषित सामग्री के तरीके):

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 विधि के साथ परिणामों को मान्य करने से शुरू कर सकते हैं। इस तरह, आप परीक्षण को बहुत आसान तरीके से फिर से चला सकते हैं, अगर आपको मैन्युअल परीक्षण करना था।

— Seramme
स्रोत

8

उल्लिखित @CoolBeans की तरह, jUnit पर एक नज़र डालें । यहाँ एक संक्षिप्त ट्यूटोरियल है जिसे आपने jUnit 4.x के साथ शुरू किया है

अंत में, यदि आप वास्तव में परीक्षण और परीक्षण-संचालित विकास (टीडीडी) के बारे में अधिक जानना चाहते हैं, तो मैं आपको केंट बेक द्वारा निम्नलिखित पुस्तक पर एक नज़र डालने की सलाह देता हूं: उदाहरण के लिए परीक्षण-प्रेरित विकास ।

— vladmore
स्रोत

6

अन्य उत्तरों ने आपको दिखाया है कि टेस्ट कक्षाओं को सेट करने के लिए JUnit का उपयोग कैसे करें। JUnit केवल जावा परीक्षण ढांचा नहीं है। एक रूपरेखा का उपयोग करने के तकनीकी विवरण पर ध्यान केंद्रित करना हालांकि सबसे महत्वपूर्ण अवधारणाओं से अलग है जो आपके कार्यों का मार्गदर्शन करना चाहिए, इसलिए मैं उन लोगों के बारे में बात करूंगा।

परीक्षण (सभी प्रकार की सभी प्रकार की) किसी चीज़ के वास्तविक व्यवहार (The System Under Test, SUT) की उसके अपेक्षित व्यवहार से तुलना करती है।
कंप्यूटर प्रोग्राम का उपयोग करके स्वचालित परीक्षण किया जा सकता है। क्योंकि यह तुलना एक अनम्य और अनजाने कंप्यूटर प्रोग्राम द्वारा की जा रही है, अपेक्षित व्यवहार ठीक और स्पष्ट रूप से ज्ञात होना चाहिए।
एक कार्यक्रम (एक वर्ग या विधि) के किसी कार्यक्रम या भाग का क्या करना है, इसकी विशिष्टता है । परीक्षण सॉफ़्टवेयर के लिए आवश्यक है कि आपके पास SUT के लिए एक विनिर्देश हो। यह एक स्पष्ट विवरण, या एक अंतर्निहित विनिर्देश हो सकता है जो आपके लिए अपेक्षित है।
इसलिए स्वचालित इकाई परीक्षण के लिए आपके द्वारा परीक्षण किए जा रहे वर्ग या विधि के सटीक और स्पष्ट विनिर्देश की आवश्यकता होती है।
लेकिन जब आप उस कोड को लिखने के लिए निर्धारित करते हैं तो आपको उस विनिर्देश की आवश्यकता होती है। इससे पहले कि आप SUT की एक पंक्ति लिखने से पहले परीक्षण के बारे में क्या वास्तव में शुरू होता है का हिस्सा है। टेस्ट ड्रिवेन डेवलपमेंट (टीडीडी) की परीक्षण तकनीक उस विचार को चरम पर ले जाती है, और आपने परीक्षण किए जाने वाले कोड को लिखने से पहले यूनिट परीक्षण कोड बनाया है।
यूनिट टेस्टिंग फ्रेमवर्क अभिकथन का उपयोग करके आपके SUT का परीक्षण करते हैं । एक तर्क एक तार्किक अभिव्यक्ति है (एक booleanपरिणाम प्रकार के साथ एक अभिव्यक्ति ; एक विधेय ) जो trueSUT सही ढंग से व्यवहार कर रहा है तो होना चाहिए । इसलिए विनिर्देश को मुखरता के रूप में व्यक्त (या पुनः व्यक्त) किया जाना चाहिए।
एक विशेष तकनीक के रूप में मुखरता व्यक्त करने के लिए एक उपयोगी तकनीक अनुबंध द्वारा प्रोग्रामिंग है । ये विनिर्देश पोस्टकंडिशन के संदर्भ में हैं । एक विधि या एक निर्माता से लौटने के बाद SUT के सार्वजनिक रूप से दिखाई देने वाली स्थिति के बारे में एक अनुमान है। कुछ तरीकों postconditions कि हैं अपरिवर्तनशीलताओं , जो विधेय है कि पहले और विधि के निष्पादन के बाद सत्य हैं कर रहे हैं। एक वर्ग को आक्रमणकारी भी कहा जा सकता है, जो वर्ग के प्रत्येक निर्माता और विधि के उत्तर हैं, और इसलिए हमेशा सच होना चाहिए । पोस्टकंडिशन (और आक्रमणकारी) केवल दृश्यमान स्थिति के संदर्भ में व्यक्त किए जाते हैं: publicऔर protectedफ़ील्ड, द्वारा लौटाए गए मानpublic औरprotected विधियाँ (जैसे गेटर्स), और सार्वजनिक रूप से दिखाई देने वाली वस्तुओं की स्थिति (संदर्भ द्वारा) विधियों के लिए।

कई शुरुआती लोग यहां सवाल पूछते हैं कि वे कुछ कोड का परीक्षण कैसे कर सकते हैं, कोड प्रस्तुत कर सकते हैं लेकिन उस कोड के विनिर्देशन को बताए बिना। जैसा कि इस चर्चा से पता चलता है, किसी के लिए भी इस तरह के प्रश्न का एक अच्छा जवाब देना असंभव है , क्योंकि सर्वोत्तम संभावित उत्तरदाताओं को विनिर्देश का अनुमान लगाना चाहिए , और ऐसा गलत तरीके से हो सकता है। प्रश्नकर्ता सवाल का स्पष्ट रूप से एक विनिर्देश के महत्व को समझते नहीं है, और इस तरह एक नौसिखिया जो बुनियादी बातों मैं यहाँ का वर्णन किया है समझने की जरूरत है इससे पहले कि कुछ परीक्षण कोड लिखने की कोशिश कर।

— Raedwald
स्रोत