JUnit में विफलता और त्रुटि के बीच अंतर क्या है?

Question

मैं एक बड़े कोड बेस पर JUnit परीक्षण चला रहा हूं, और मुझे एहसास हो रहा है कि कभी-कभी मुझे "त्रुटियां" मिलती हैं, जबकि अन्य बार मुझे "विफलताएं" मिलती हैं। क्या फर्क पड़ता है?

Answer 1

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

Comments

यद्यपि यदि कुछ भी विस्तारित किया java.lang.AssertionErrorजाता है तो उसे परीक्षण त्रुटि के बजाय परीक्षण विफलता के रूप में दिखाया जाएगा। आपको अपने स्वयं के उत्तर को स्वीकार करने पर विचार करना चाहिए क्योंकि यह सही है।

— पोन्जाओ

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

— जेफ ग्रिग

और अगर अपवाद की उम्मीद है, तो आपको इसके @Testसाथ टिप्पणी करनी चाहिए expected = SomeException.class।

— डाउनहिल्स्की

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

— RonJRH

org.junit.Assert.assertEquals () विफल होने पर JUnit4 HTML रिपोर्ट द्वारा ERROR माना जाता है। यह आपके कथन का खंडन करता है (जिसे मैं अब तक जानता था)। क्या आप कृपया इस पर और प्रकाश डाल सकते हैं?

— कृष्णोम

Answer 2

यदि आपका परीक्षण एक अपवाद फेंकता है जो जूनिट में जोर ढांचे के माध्यम से बुदबुदा नहीं पाता है, तो यह एक त्रुटि के रूप में रिपोर्ट किया जाता है। उदाहरण के लिए, NullPointer, या ClassNotFound अपवाद एक त्रुटि की रिपोर्ट करेगा:

String s = null;
s.trim();

या,

try {

    // your code
} catch(Exception e) {
    // log the exception
    throw new MyException(e);
}

निम्नलिखित ने कहा कि, निम्नलिखित विफलता की रिपोर्ट करेगा:

Assert.fail("Failure here");

या,

Assert.assertEquals(1, 2);

या और भी:

throw new AssertionException(e);

यह आपके द्वारा उपयोग किए जा रहे जूनिट संस्करण पर निर्भर करता है। Junit 4- विफलता और त्रुटि के बीच अंतर कर देगा, लेकिन Junit 4 इसे केवल विफलताओं के रूप में सरल करता है।

निम्नलिखित लिंक अधिक रोचक जानकारी प्रदान करता है:

http://www.devx.com/Java/Article/31983/1763/page/2

Comments

यह सटीक नहीं है। टेस्ट असफलता और परीक्षण त्रुटि के बीच अंतर JUnit 4 में नहीं गया है। मैंने अभी इसका परीक्षण किया है। जुड़ा हुआ लेख भ्रामक था। इसमें कहा गया है "JUnit 4 केवल विफलताओं का उपयोग करके इसे सरल बनाता है" लेकिन यह जोर देना चाहिए कि JUnit 4 java.lang.AssertionError को परीक्षण विफलताओं में बदल देता है, इसलिए आपको junit .framework.ssertionFailedError का उपयोग करने की आवश्यकता नहीं है। लाभ यह है कि आप JUnit से जुड़े प्रोजेक्ट के बिना उत्पादन कोड में परीक्षण दावे लिखना शुरू कर सकते हैं। परीक्षण त्रुटि और परीक्षण विफलता के बीच का अंतर भी बेहद उपयोगी है और यदि हटा दिया जाता है तो यह एक कदम पीछे होगा।

— रोंजेरह

RonJRH, क्या आप अपनी डिफ़ॉल्ट जूनिट रिपोर्ट में त्रुटियों को देख पा रहे हैं?

— नील

हाँ नील। मैंने बस कोशिश की। निश्चित रूप से यहाँ छवि जोड़ने की प्राचीनता नहीं है, लेकिन यह मेरे परीक्षण का परिणाम दिखाता है: imagebucket.net/abpxucddkvn1/Capture.PNG

— RonJRH

Answer 3

"JUnit के साथ जावा 8 में व्यावहारिक इकाई परीक्षण" से:

JUnit में जोर (या जोर) स्थिर विधि कॉल है जिसे आप अपने परीक्षणों में छोड़ते हैं। प्रत्येक दावा सत्यापित करने का अवसर है कि कुछ शर्त सही है। यदि एक जोरदार स्थिति सही नहीं है, परीक्षण वहीं रुक जाता है, और JUnit एक परीक्षण विफलता की रिपोर्ट करता है।

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

Answer 4

नीचे परीक्षण टेस्ट त्रुटि बनाम टेस्ट विफलता के बीच का अंतर बताते हैं ।

मैंने उस लाइन पर टिप्पणी की है जो परीक्षण त्रुटि और परीक्षण विफलता फेंकता है।

    @Test
    public void testErrorVsTestFailure() {

        final String sampleString = null;

        assertEquals('j', sampleString.charAt(0) );
        //above line throws test error as you are trying to access charAt() method on null reference

        assertEquals(sampleString, "jacob");
        //above line throws Test failure as the actual value-a null , is not equal to expected value-string "jacob"
        }

जब भी आपको अपवाद मिलता है, और जब आपका अपेक्षित परिणाम मान आपके वास्तविक मूल्य से मेल नहीं खाता है, तो जून टेस्ट परीक्षा त्रुटि दिखाता है

Answer 5

स्रोत वर्ग: JUnitReportReporter.java

public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String defaultOutputDirectory) {
//......

            for (ITestResult tr : (Set) entry.getValue()) {
                TestTag testTag = new TestTag();

                boolean isSuccess = tr.getStatus() == 1;
                if (!(isSuccess)) {
                    if (tr.getThrowable() instanceof AssertionError)
                        ++errors;
                    else {
                        ++failures;
                    }
                }
}

जैसा कि आप ऊपर की विधि में नीचे की रेखा देख सकते हैं

tr.getThrowable () Instof AssertionError

त्रुटियों की संख्या बढ़ जाती है जब यह जोर का उदाहरण होता है अन्यथा (किसी भी फेंकने योग्य) को विफलताओं के रूप में गिना जाता है।

Answer 6

आप सही कह रहे हैं कि असफलताएँ जोर-ज़बरदस्ती के तौर-तरीकों से, या एक जोर-ज़बरदस्ती फेंकने से, या एक अपवाद फेंकने @Testसे आती हैं, जिसे आपने अपने एनोटेशन में घोषित किया था , और एरर्स दूसरे, अप्रत्याशित अपवादों से आते हैं। लेकिन उनके बीच एक महत्वपूर्ण अंतर है:

एक विफलता का मतलब है कि आपका परीक्षण सही तरीके से चला, और आपके कोड में एक दोष की पहचान की।

आपके कोड में एक त्रुटि का मतलब बग हो सकता है, लेकिन एक जिसे आप परीक्षण भी नहीं कर रहे थे। इसका मतलब यह भी हो सकता है कि बग परीक्षण में ही है।

संक्षेप में, विफलता का मतलब है कि आपको उस कोड को फिर से लिखना होगा जो परीक्षण किया जा रहा है। एक त्रुटि का मतलब है कि यह इकाई परीक्षण हो सकता है जिसे आपको फिर से लिखना होगा। इसका मतलब यह हो सकता है कि भले ही विफलता आपके कोड में थी, जैसे कि NullPointerException, क्योंकि आपको एक दोष का पता चला है जिसके लिए आप परीक्षण भी नहीं कर रहे थे, इसलिए उसके लिए परीक्षण करना बुद्धिमान हो सकता है।

Answer 7

विडंबना यह है कि जूनिट और अन्य परीक्षण संबंधी चौखटे (टेस्टिंग, हैमरेस्ट) एस्टर संचालन प्रदान करते हैं जो स्थिति को सत्यापित करते हैं और यदि यह विफल रहता है तो एक java.lang.AssertionError को "अंडर-द-हूड" फेंका जा रहा है, जो btw java.lang.Error का विस्तार करता है।

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

Answer 8

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

अधिक जानकारी के लिए, यह देखें ।