मुझे पारंपरिक एस्केरएक्सएक्सएक्सएक्सएक्सएक्स () के बजाय हैमरेस्ट-मैचर और एसेटेरटैट () का उपयोग क्यों करना चाहिए

Question

जब मैं एस्टर क्लास JavaDoc में उदाहरणों को देखता हूं

assertThat("Help! Integers don't work", 0, is(1)); // fails:
// failure message:
// Help! Integers don't work
// expected: is <1> 
// got value: <0>
assertThat("Zero is one", 0, is(not(1))) // passes

मुझे बड़ा फायदा नहीं हुआ, आइए बताते हैं, assertEquals( 0, 1 ) ।

संदेशों के लिए शायद यह अच्छा है अगर निर्माण अधिक जटिल हो जाते हैं लेकिन क्या आपको अधिक फायदे मिलते हैं? पठनीयता?

Answer 1

उन मामलों के लिए कोई बड़ा फायदा नहीं है जहां ए assertFoo मौजूद है जो आपके इरादे से मेल खाता है। उन मामलों में वे लगभग समान व्यवहार करते हैं।

लेकिन जब आप जांच करते हैं कि कुछ अधिक जटिल हैं, तो लाभ अधिक दिखाई देता है:

assertTrue(foo.contains("someValue") && foo.contains("anotherValue"));

बनाम

assertThat(foo, hasItems("someValue", "anotherValue"));

एक चर्चा कर सकते हैं कि उनमें से कौन सा पढ़ना आसान है, लेकिन एक बार जब मुखर विफल हो जाता है, तो आपको एक अच्छा त्रुटि संदेश मिलेगा assertThat, लेकिन केवल बहुत कम जानकारी से assertTrue।

assertThatआपको बताएंगे कि क्या दावा था और आपको इसके बदले क्या मिला। assertTrueकेवल आपको बताएगा कि आपको वह स्थान मिला है falseजहाँ आपने अपेक्षा की थी true।

Comments

मेरे मन के पीछे भी यही सवाल था। धन्यवाद, मैंने इस तरह से कभी नहीं सोचा था।

— गेहूँ

यह प्रति परीक्षण एक जोर के "नियम" के साथ भी मदद करता है और BDD- शैली विनिर्देशों के साथ अधिक आसानी से मिश्रण करता है।

— नेल्स वुल्का

और यह जोर से सशर्त तंत्र को अलग करता है (जो कि बेहतर त्रुटि संदेशों की ओर जाता है)।

— स्टीवड

उदाहरण के रूप में शायद ही कोई भी एक के assertTrueसाथ एक एकल का उपयोग करेगा के रूप में प्रयोग करने योग्य है &&। इसे दो स्थितियों में अलग करने से समस्या ज्यूनिट में भी स्पष्ट हो जाती है। मुझे गलत मत समझो; मैं आपसे सहमत हूं, मैं सिर्फ आपके उदाहरण को नापसंद करता हूं।

— Maaartinus 5

Answer 2

संस्करण 4.4 (जहां इसे पेश किया गया था) के लिए JUnit रिलीज नोट चार फायदे हैं:

• अधिक पठनीय और टाइप करने योग्य: यह वाक्यविन्यास आपको विषय, क्रिया, वस्तु (assert "x 3") के संदर्भ में सोचने की अनुमति देता है, बजाय जोर , जो क्रिया, वस्तु, विषय (assert "3 x") का उपयोग करता है।
• संयोजन: किसी भी मिलानकर्ता कथन को नकारा नहीं जा सकता ( नहीं ), संयुक्त ( या तो) .or (t) ), एक संग्रह में मैप किया गया ( प्रत्येक ), या कस्टम संयोजनों ( afterFiveSeconds (s) में उपयोग किया जा सकता है )
• पठनीय विफलता संदेश। (...)
• कस्टम मैचर्स। माचिस इंटरफ़ेस को स्वयं कार्यान्वित करके , आप अपने स्वयं के कस्टम अभिकथन के लिए उपरोक्त सभी लाभ प्राप्त कर सकते हैं।

उस लड़के से अधिक विस्तृत तर्क जिसने नया वाक्यविन्यास बनाया: यहाँ ।

Answer 3

मूल रूप से कोड की पठनीयता बढ़ाने के लिए ।

हैमरेस्ट के अलावा आप फेस्ट अस्सिटन्स का भी उपयोग कर सकते हैं । वे hamcrest के ऊपर कुछ फायदे जैसे:

• वे अधिक पठनीय हैं
  ( assertEquals(123, actual); // reads "assert equals 123 is actual"बनाम
  assertThat(actual).isEqualTo(123); // reads "assert that actual is equal to 123")
• वे खोज योग्य हैं ( आप किसी भी आईडीई के साथ स्वत: पूर्णता का काम कर सकते हैं )।

कुछ उदाहरण

import static org.fest.assertions.api.Assertions.*;

// common assertions
assertThat(yoda).isInstanceOf(Jedi.class);
assertThat(frodo.getName()).isEqualTo("Frodo");
assertThat(frodo).isNotEqualTo(sauron);
assertThat(frodo).isIn(fellowshipOfTheRing);
assertThat(sauron).isNotIn(fellowshipOfTheRing);

// String specific assertions
assertThat(frodo.getName()).startsWith("Fro").endsWith("do")
                           .isEqualToIgnoringCase("frodo");

// collection specific assertions
assertThat(fellowshipOfTheRing).hasSize(9)
                               .contains(frodo, sam)
                               .excludes(sauron);


// map specific assertions (One ring and elves ring bearers initialized before)
assertThat(ringBearers).hasSize(4)
                       .includes(entry(Ring.oneRing, frodo), entry(Ring.nenya, galadriel))
                       .excludes(entry(Ring.oneRing, aragorn));

---

17 अक्टूबर 2016 अपडेट

उत्सव अब सक्रिय नहीं है, इसके बजाय AssertJ का उपयोग करें ।

Comments

लगता है कि फेस्ट की मौत हो गई, लेकिन फोर्क असारज बहुत जीवित है।

— 11:11 बजे एमी वैन गैससे

Answer 4

एक बहुत ही मूल औचित्य यह है कि नए सिंटैक्स को गड़बड़ाना कठिन है।

मान लीजिए कि एक विशेष मान, फू, परीक्षण के बाद 1 होना चाहिए।

assertEqual(1, foo);

--OR--

assertThat(foo, is(1));

पहले दृष्टिकोण के साथ, सही क्रम को भूलना बहुत आसान है, और इसे पीछे की तरफ टाइप करें। फिर यह कहने के बजाय कि परीक्षण विफल हो गया क्योंकि उसे 1 की उम्मीद थी और उसे 2 मिला, संदेश पीछे की ओर है। जब परीक्षा पास हो जाती है तो कोई समस्या नहीं है, लेकिन परीक्षा में असफल होने पर भ्रम की स्थिति पैदा हो सकती है।

दूसरे संस्करण के साथ, यह गलती करना लगभग असंभव है।

Comments

... और जब एक्लिप्स विफलता की रिपोर्ट करता है, यदि आप तर्कों को गलत तरीके से परम्परागत ऐसरटैट () में डालते हैं, तो त्रुटि का कोई मतलब नहीं है।

— श्रीधर सरनोबत

Answer 5

उदाहरण:

assertThat(5 , allOf(greaterThan(1),lessThan(3)));
//  java.lang.AssertionError:
//  Expected: (a value greater than <1> and a value less than <3>)
//       got: <5>
assertTrue("Number not between 1 and 3!", 1 < 5 && 5 < 3);
//  java.lang.AssertionError: Number not between 1 and 3!

1. आप अपने परीक्षणों को और अधिक विशेष बना सकते हैं
2. यदि परीक्षण विफल हो जाते हैं तो आपको अधिक विस्तृत अपवाद प्राप्त होता है
3. टेस्ट पढ़ना आसान

btw: आप assertXXX में भी पाठ लिख सकते हैं ...

Comments

बेहतर अभी तक, मैं assertThatमामले में स्ट्रिंग तर्क को छोड़ दूंगा , क्योंकि आपके द्वारा प्राप्त संदेश स्वचालित रूप से सूचनात्मक है: "अपेक्षित: (<1> से अधिक मूल्य और <3> से कम मूल्य)"

— मैट्रिक्स

हाँ आप सही है। मैं अपना उत्तर संपादित करता हूं। मूल रूप से मैं दोनों (माचिस) और। (माचिस) का उपयोग करना चाहता हूं लेकिन यह काम नहीं किया।

— मार्टिनएल

Answer 6

assertThat(frodo.getName()).isEqualTo("Frodo");

प्राकृतिक भाषा के करीब है।

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

पीएस कोड को अच्छी तरह से लिखित पुस्तक होना चाहिए। स्व दस्तावेज कोड।

Comments

ठीक है और…? मैं आपके तर्क का समर्थन करते हुए समझाता हूं कि यह अच्छी बात क्यों है।

— नाथन तुग्गी

Answer 7

मुखरता पर जोर देने के फायदे हैं -
1) अधिक पठनीय
2) विफलता पर अधिक जानकारी
3) संकलन समय त्रुटियां - चलाने की त्रुटियों के बजाय
4) परीक्षण की स्थिति लिखने के साथ लचीलेपन
5) पोर्टेबल - यदि आप हैमरेस्ट का उपयोग कर रहे हैं - तो आप jUnit का उपयोग कर सकते हैं या अंतर्निहित ढांचे के रूप में TestNG।