क्या यह "व्यवस्था-अभिकार-अधिनियम-अभिकारक" होना चाहिए?

Question

अरेंज-एक्ट-एस्टर के क्लासिक परीक्षण पैटर्न के बारे में , मैं अक्सर अपने आप को एक्ट से पहले एक जवाबी कार्रवाई जोड़कर पाता हूं। इस तरह से मुझे पता है कि क्रिया के परिणाम के रूप में गुजरता जोर वास्तव में गुजर रहा है।

मुझे लगता है कि यह लाल-हरा-रिफलेक्टर में लाल रंग के अनुरूप है, जहां केवल अगर मैंने अपने परीक्षण के दौरान लाल पट्टी देखी है तो क्या मुझे पता है कि हरे रंग की पट्टी का मतलब है कि मैंने कोड लिखा है जो एक अंतर बनाता है। यदि मैं एक उत्तीर्ण परीक्षा लिखता हूं, तो कोई भी कोड इसे संतुष्ट करेगा; इसी तरह, अरेंज-एस्टर-एक्ट-एस्टर के संबंध में, यदि मेरा पहला दावा विफल हो जाता है, तो मुझे पता है कि किसी भी एक्ट ने अंतिम एस्टर को पारित किया होगा - ताकि यह वास्तव में एक्ट के बारे में कुछ भी सत्यापित नहीं कर रहा था।

क्या आपके परीक्षण इस पैटर्न का पालन करते हैं? क्यों या क्यों नहीं?

अद्यतन स्पष्टीकरण: प्रारंभिक दावा मूल रूप से अंतिम दावे के विपरीत है। यह दावा नहीं है कि अरेंज ने काम किया; यह दावा है कि अधिनियम ने अभी तक काम नहीं किया है।

Answer 1

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

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

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

Comments

+1, बहुत अच्छा जवाब। अंतिम भाग विशेष रूप से महत्वपूर्ण है, क्योंकि यह दर्शाता है कि आप चीजों को एक अलग इकाई परीक्षण के रूप में रख सकते हैं।

— मुर्रेकटैट

मैंने आम तौर पर इसे इस तरह से भी किया है, लेकिन पूर्व-भुगतान सुनिश्चित करने के लिए एक अलग परीक्षण होने के साथ एक समस्या है (विशेष रूप से बदलती आवश्यकताओं के साथ एक बड़े कोडबेस के साथ) - पूर्व शर्त परीक्षण समय के साथ संशोधित हो जाएगा और 'मुख्य' के साथ सिंक से बाहर निकल जाएगा परीक्षण जो उन पूर्व शर्तों को निर्धारित करता है। तो पूर्व शर्त सभी ठीक और हरे रंग की हो सकती हैं, लेकिन मुख्य परीक्षा में उन पूर्व शर्त को संतुष्ट नहीं किया जाता है, जो अब हमेशा हरा और ठीक दिखाता है। लेकिन अगर पूर्व-परीक्षाएँ मुख्य परीक्षा में होतीं, तो वे असफल हो जाते। क्या आप इस समस्या को लेकर आए हैं और इसके लिए एक अच्छा समाधान खोज रहे हैं?

— नचौद

यदि आप अपने परीक्षणों को बहुत बदल देते हैं, तो आपको अन्य समस्याएं हो सकती हैं , क्योंकि यह आपके परीक्षणों को कम भरोसेमंद बनाने की प्रवृत्ति होगी। यहां तक ​​कि बदलती आवश्यकताओं के बावजूद, एक परिशिष्ट केवल फैशन में कोड डिजाइन करने पर विचार करें ।

— मार्क सेमैन

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

— रेक्सिनो

Answer 2

इसे Arrange- Assume -Act-Assert के रूप में भी निर्दिष्ट किया जा सकता है ।

NUnit में इसके लिए एक तकनीकी संभाल है, जैसा कि यहाँ उदाहरण में दिया गया है: http://nunit.org/index.php?p=theory&r=2.5.7

Comments

अच्छा! मुझे एक चौथा पसंद है - और अलग - और सटीक - "ए"। धन्यवाद!

— कार्ल मैनस्टर

+1, @ ठीक है! मुझे यह भी पसंद है, कुछ विशेष मामलों के लिए भी! मै उसे करने की एक कोशिश तो करूंगा!

— जॉन टोबलर 16'11

Answer 3

यहाँ एक उदाहरण है।

public void testEncompass() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7));
    range.encompass(7);
    assertTrue(range.includes(7));
}

यह हो सकता है कि मैंने Range.includes()केवल सच लिखने के लिए लिखा था । मैंने नहीं किया, लेकिन मैं सोच सकता हूं कि मेरे पास हो सकता है। या मैं इसे किसी भी अन्य तरीके से गलत लिख सकता था। मैं आशा करता हूं और उम्मीद करता हूं कि TDD के साथ मुझे वास्तव में यह सही मिला - यह includes()सिर्फ काम करता है - लेकिन शायद मैंने नहीं किया। तो पहला जोर एक पवित्रता जांच है, यह सुनिश्चित करने के लिए कि दूसरा जोर वास्तव में सार्थक है।

खुद ही पढ़ें, assertTrue(range.includes(7));कह रहा है: "जोर देकर कहा कि संशोधित रेंज में 7 शामिल हैं"। पहले दावे के संदर्भ में पढ़ें, यह कह रहा है: "जोर देने वाले एंकोमपास () का कारण बनता है। इसमें 7. शामिल है और चूंकि एंकोमपास वह इकाई है जिसका हम परीक्षण कर रहे हैं, मुझे लगता है कि कुछ (छोटे) मूल्य हैं।

मैं अपना जवाब स्वीकार कर रहा हूं; बहुत से लोगों ने सेटअप के परीक्षण के बारे में मेरे प्रश्न को गलत बताया। मुझे लगता है कि यह थोड़ा अलग है।

Comments

एक उदाहरण के साथ वापस आने के लिए धन्यवाद, कार्ल। ठीक है, टीडीडी चक्र के लाल हिस्से में, जब तक कि एनकॉम्ब () वास्तव में कुछ करता है; पहला जोर व्यर्थ है, यह केवल दूसरे का दोहराव है। हरे रंग में, यह उपयोगी होने लगता है। रिफैक्टरिंग के दौरान यह समझ में आ रहा है। यह एक UT फ्रेमवर्क होना अच्छा हो सकता है जो यह स्वचालित रूप से करता है।

— दार्शनिक

मान लीजिए कि आप उस श्रेणी को TDD करते हैं, तो जब आप इसे तोड़ेंगे, तो रेंज ctor का परीक्षण करने में एक और असफल परीक्षण नहीं होगा?

— दार्शनिक

@ एफिलिप: मुझे यकीन नहीं है कि मैं इस सवाल को समझ सकता हूं। रेंज कंस्ट्रक्टर और शामिल () की अपनी इकाई परीक्षण हैं। क्या आप कृपया विस्तार से बता सकते हैं?

— कार्ल मैनस्टर

पहले मुखर के लिए (range.includes (7)) जोर देने के लिए आपको रेंज कंस्ट्रक्टर में दोष होने की आवश्यकता है। तो मेरा मतलब यह है कि क्या रेंज कंस्ट्रक्टर के लिए परीक्षण उस दावे के समान समय पर नहीं टूटेंगे। और अधिनियम के बाद एक और मूल्य पर जोर देने के बारे में क्या है : उदाहरण के लिए assertFalse (range.includes (6))?

— तत्व

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

— कार्ल मैनस्टर

Answer 4

एक Arrange-Assert-Act-Assertपरीक्षण को हमेशा दो परीक्षणों में बदला जा सकता है:

1. Arrange-Assert

तथा

2. Arrange-Act-Assert

पहला परीक्षण केवल उस पर जोर देगा जो व्यवस्था के चरण में स्थापित किया गया था, और दूसरा परीक्षण केवल उसी के लिए जोर देगा जो अधिनियम चरण में हुआ था।

यह इस बात पर अधिक सटीक प्रतिक्रिया देने का लाभ है कि क्या यह व्यवस्था या अधिनियम का चरण है जो विफल हो गया, जबकि मूल में Arrange-Assert-Act-Assertइन को जब्त कर लिया गया है और आपको गहराई से जांच करनी होगी कि वास्तव में क्या दावा विफल हुआ और क्यों यह जानने में विफल रहा यह व्यवस्था या अधिनियम था जो विफल हो गया।

यह इकाई परीक्षण के इरादे को भी बेहतर बनाता है, क्योंकि आप अपने परीक्षण को छोटी स्वतंत्र इकाइयों में अलग कर रहे हैं।

अंत में, ध्यान रखें कि जब भी आप अलग-अलग टेस्ट में समान अरेंजमेंट सेक्शन देखते हैं, तो आपको इन्हें साझा सहायक विधियों में खींचने की कोशिश करनी चाहिए, ताकि आपके टेस्ट भविष्य में अधिक DRY और अधिक रख-रखाव वाले हों।

Answer 5

मैं अब यह कर रहा हूं। एक अलग तरह का AAAA

Arrange - setup
Act - what is being tested
Assemble - what is optionally needed to perform the assert
Assert - the actual assertions

अद्यतन परीक्षण का उदाहरण:

Arrange: 
    New object as NewObject
    Set properties of NewObject
    Save the NewObject
    Read the object as ReadObject

Act: 
    Change the ReadObject
    Save the ReadObject

Assemble: 
    Read the object as ReadUpdated

Assert: 
    Compare ReadUpdated with ReadObject properties

इसका कारण यह है कि अधिनियम में रीडअपडेट का वाचन शामिल नहीं है क्योंकि यह अधिनियम का हिस्सा नहीं है। अधिनियम केवल परिवर्तन और बचत है। तो वास्तव में, ARRANGE जोर के लिए पढ़ें, मैं जोर के लिए कह रहा हूँ। यह ARRANGE अनुभाग को भ्रमित करने से रोकने के लिए है

ASSERT में केवल दावे होने चाहिए। वह अधिनियम और ASSERT के बीच ASSEMBLE को छोड़ देता है जो मुखर को सेट करता है।

अंत में, यदि आप व्यवस्था में असफल हो रहे हैं, तो आपके परीक्षण सही नहीं हैं क्योंकि आपके पास इन तुच्छ बगों को रोकने / खोजने के लिए अन्य परीक्षण होने चाहिए । क्योंकि जो परिदृश्य मैं प्रस्तुत करता हूं, उसके लिए पहले से ही अन्य परीक्षण होने चाहिए जो READ और CREATE का परीक्षण करते हैं। यदि आप एक "गार्ड अभिकथन" बनाते हैं, तो आप DRY को तोड़ सकते हैं और रखरखाव बना सकते हैं।

Answer 6

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

Answer 7

मैंने पहले ही इस तकनीक के बारे में पढ़ा है - संभवतः आप btw से - लेकिन मैं इसका उपयोग नहीं करता हूं; ज्यादातर इसलिए क्योंकि मैं अपने यूनिट परीक्षणों के लिए ट्रिपल ए फॉर्म का उपयोग कर रहा हूं।

अब, मैं उत्सुक हो रहा हूं, और कुछ प्रश्न हैं: आप अपना परीक्षण कैसे लिखते हैं, क्या आप इस दावे को विफल करने का कारण बनते हैं, लाल-हरे-लाल-हरे-रिफ्लेक्टर चक्र के बाद, या आप इसे बाद में जोड़ते हैं?

क्या आप कभी-कभी असफल हो जाते हैं, शायद आपके द्वारा कोड को रिफलेक्टर करने के बाद? यह आपको क्या कहता है ? शायद आप एक उदाहरण साझा कर सकते हैं जहाँ इसने मदद की। धन्यवाद।

Comments

मैं आमतौर पर प्रारंभिक दावे को विफल करने के लिए मजबूर नहीं करता - आखिरकार, यह विफल नहीं होना चाहिए, जिस तरह से एक TDD अभिकथन करना चाहिए, इससे पहले कि इसकी विधि लिखी जाए। मैं इसे लिखता हूं , जब मैं इसे लिखता हूं, इससे पहले , परीक्षण लिखने के सामान्य पाठ्यक्रम में, बाद में नहीं। ईमानदारी से कहूं तो मुझे यह याद नहीं आ रहा है कि शायद - यह सुझाव है कि यह समय की बर्बादी है। मैं एक उदाहरण के साथ आने की कोशिश करूंगा, लेकिन मेरे पास वर्तमान में कोई भी नहीं है। सवालों के लिए धन्यवाद; वे मददगार हैं।

— कार्ल मैनस्टर

Answer 8

मैंने ऐसा पहले किया है जब एक परीक्षण की जांच की जो विफल रही।

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

मुझे लगता है कि अगर टेस्ट का अरेंज पार्ट बहुत लंबा और जटिल है, तो यहां एक कोड गंध भी है।

Comments

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

— कार्ल मैनस्टर

Answer 9

सामान्य तौर पर, मैं "अरेंज, एक्ट, एस्टर" को बहुत पसंद करता हूं और इसे अपने व्यक्तिगत मानक के रूप में उपयोग करता हूं। एक बात यह है कि मुझे करने के लिए याद दिलाने में विफल रहता है, हालांकि, यह सुनिश्चित करने के लिए कि मैंने क्या व्यवस्था की है जब दावे किए जाते हैं। ज्यादातर मामलों में, यह बहुत अधिक कष्टप्रद नहीं होता है, क्योंकि अधिकांश चीजें ऑटो-जादुई रूप से कचरा संग्रह के माध्यम से चली जाती हैं, आदि यदि आपने बाहरी संसाधनों से कनेक्शन स्थापित किया है, हालांकि, आप संभवतः उन कनेक्शनों को बंद करना चाहेंगे जब आप काम कर रहे हों। अपने दावे के साथ या आपके पास बहुत से सर्वर या महंगे संसाधन हैं जो कहीं न कहीं कनेक्शन या महत्वपूर्ण संसाधनों को धारण करते हैं कि यह किसी और को देने में सक्षम होना चाहिए। यह विशेष रूप से महत्वपूर्ण है यदि आप उन डेवलपर्स में से एक हैं जो TearDown या TestFixtureTearDown का उपयोग नहीं करते हैंएक या अधिक परीक्षणों के बाद सफाई करना। बेशक, "अरेंज, एक्ट, एस्सर" मेरी असफलता के लिए जिम्मेदार नहीं है जो मैं खोलता हूं; मैं केवल इस "गोच" का उल्लेख करता हूं क्योंकि मुझे अभी तक सिफारिश करने के लिए "निपटाने" के लिए एक अच्छा "ए-शब्द" पर्यायवाची नहीं मिला है! कोई सुझाव?

Comments

@ ऑरलमैनस्टर, आप वास्तव में मेरे लिए काफी करीब हैं! मैं इसे अपने अगले टेस्टफिक्सचर में आकार के लिए आज़माने के लिए चिपका रहा हूँ। यह उस छोटे से अनुस्मारक की तरह है जो आपकी मां ने आपको सिखाया होगा: "यदि आप इसे बंद करते हैं! यदि आप इसे गड़बड़ करते हैं, तो इसे साफ करें!" शायद कोई और उस पर सुधार कर सकता है लेकिन कम से कम यह "ए!" से शुरू होता है। तुम्हारे सुझाव के लिए धन्यवाद!

— जॉन टॉबलर

@carlmanaster, मैंने "ऐनुल" एक कोशिश की। यह "अशांति," और इस तरह के कार्यों से बेहतर है, लेकिन मैं अभी भी एक और "ए" शब्द की तलाश कर रहा हूं जो मेरे सिर में "अरेंज, एक्ट, एस्टर" के रूप में पूरी तरह से चिपक जाता है। शायद "अनहिलेट!"

— जॉन टोबलर 16'11

तो अब, मेरे पास "अरेंज, एश्यूम, एक्ट, एसर, एनहाइलेट।" हममम! बेनाम: मैं बातें, हुह overcomplicating हूँ? शायद मैं बेहतर बस चुंबन और करने के लिए वापस जाना चाहते हैं "की व्यवस्था, अधिनियम, और जोर!"

— जॉन टोबलर

शायद रीसेट के लिए एक आर का उपयोग करें? मुझे पता है कि यह ए नहीं है, लेकिन यह एक समुद्री डाकू की तरह लगता है: अरे! और मुखर के साथ गाया जाता है: ओ

— मार्सेल वाल्डेज़ ओरोज़्को

Answer 10

अनुबंध द्वारा डिजाइन पर विकिपीडिया के प्रवेश पर एक नज़र है । अरेंज-एक्ट-एससर पवित्र त्रिमूर्ति कुछ समान अवधारणाओं को एनकोड करने का एक प्रयास है और कार्यक्रम को सही साबित करने के बारे में है। लेख से:

The notion of a contract extends down to the method/procedure level; the
contract for each method will normally contain the following pieces of
information:

    Acceptable and unacceptable input values or types, and their meanings
    Return values or types, and their meanings
    Error and exception condition values or types that can occur, and their meanings
    Side effects
    Preconditions
    Postconditions
    Invariants
    (more rarely) Performance guarantees, e.g. for time or space used

इसे स्थापित करने में खर्च किए गए प्रयासों की मात्रा और इसके मूल्य के बीच एक ट्रेडऑफ़ है। AAA आवश्यक न्यूनतम चरणों के लिए एक उपयोगी अनुस्मारक है, लेकिन किसी को भी अतिरिक्त चरण बनाने से हतोत्साहित नहीं करना चाहिए।

Answer 11

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

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

Answer 12

मैं उस पैटर्न का उपयोग नहीं करता, क्योंकि मुझे लगता है कि ऐसा कुछ करना:

Arrange
Assert-Not
Act
Assert

व्यर्थ हो सकता है, क्योंकि माना जाता है कि आप अपने अरेंज पार्ट को सही ढंग से काम करते हैं, जिसका अर्थ है कि अरेंज पार्ट में जो कुछ भी है, उसे अस्वस्थ रूप से परीक्षण किया जाना चाहिए या परीक्षणों की आवश्यकता नहीं होने के लिए पर्याप्त सरल होना चाहिए।

अपने उत्तर के उदाहरण का उपयोग करना:

public void testEncompass() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7)); // <-- Pointless and against DRY if there 
                                    // are unit tests for Range(int, int)
    range.encompass(7);
    assertTrue(range.includes(7));
}

Comments

मुझे डर है कि आप वास्तव में मेरे सवाल को नहीं समझते हैं। प्रारंभिक दावा परीक्षण की व्यवस्था के बारे में नहीं है; यह केवल यह सुनिश्चित कर रहा है कि अधिनियम वह है जो राज्य के बारे में अंत में जोर देता है।

— कार्ल मैनस्टर

और मेरा कहना यह है कि, आप जो भी Assert-Not भाग में रखते हैं, वह पहले से ही Arrange भाग में निहित है, क्योंकि Arrange भाग के कोड का अच्छी तरह से परीक्षण किया गया है और आप पहले से ही जानते हैं कि यह क्या करता है।

— मार्सेल वाल्डेज़ ओरोज्को

लेकिन मेरा मानना ​​है कि एस्टर-नॉट पार्ट में वैल्यू है, क्योंकि आप कह रहे हैं: यह देखते हुए कि अरेंज पार्ट 'दुनिया' को 'इस अवस्था' में छोड़ देता है तो मेरा 'एक्ट' इस 'नए राज्य' में 'दुनिया' छोड़ देगा। ; और यदि कोड का कार्यान्वयन व्यवस्था का हिस्सा निर्भर करता है, बदलता है, तो परीक्षण भी टूट जाएगा। लेकिन फिर से, यह DRY के खिलाफ हो सकता है, क्योंकि आपके पास (जो भी) आपके पास कोड के आधार पर जो भी कोड है, उसके लिए परीक्षण भी होना चाहिए।

— मार्सेल वाल्डेज़ ओरोज़्को

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

— मार्सेल वाल्डेज़ ओरोज़्को

संभवत: इस तरह के क्लॉज इंटीग्रेशन टेस्ट, सिस्टम टेस्ट या एक्सेप्टेंस टेस्ट में बेहतर होंगे, जहां अरेंज पार्ट आमतौर पर एक से अधिक कंपोनेंट पर निर्भर करता है, और ऐसे कई कारक हैं, जो अप्रत्याशित रूप से बदलने के लिए 'दुनिया' की शुरुआती स्थिति का कारण बन सकते हैं। लेकिन मुझे यूनिट परीक्षणों में इसके लिए जगह नहीं दिख रही है।

— मार्सेल वाल्डेज़ ओरोज़्को

Answer 13

यदि आप वास्तव में उदाहरण में सब कुछ परीक्षण करना चाहते हैं, तो अधिक परीक्षण का प्रयास करें ... जैसे:

public void testIncludes7() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7));
}

public void testIncludes5() throws Exception {
    Range range = new Range(0, 5);
    assertTrue(range.includes(5));
}

public void testIncludes0() throws Exception {
    Range range = new Range(0, 5);
    assertTrue(range.includes(0));
}

public void testEncompassInc7() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(7));
}

public void testEncompassInc5() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(5));
}

public void testEncompassInc0() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(0));
}

क्योंकि अन्यथा आप त्रुटि के लिए बहुत सारी संभावनाएँ याद कर रहे हैं ... जैसे कि घेरने के बाद, सीमा केवल 7 अंक, आदि ... सीमा की लंबाई के लिए परीक्षण भी हैं (यह सुनिश्चित करने के लिए कि यह एक यादृच्छिक मान भी शामिल नहीं है), और पूरी तरह से रेंज में 5 को घेरने की कोशिश के लिए परीक्षणों का एक और सेट ... हम क्या उम्मीद करेंगे - एक अपवाद में, या रेंज को अनलॉक करने के लिए?

वैसे भी, बिंदु यह है कि क्या अधिनियम में कोई धारणा है जिसे आप परीक्षण करना चाहते हैं, उन्हें अपने स्वयं के परीक्षण में डाल दें, हाँ?

Answer 14

मैं उपयोग करता हूं:

1. Setup
2. Act
3. Assert 
4. Teardown

क्योंकि एक साफ सेटअप बहुत महत्वपूर्ण है।