दिलचस्प पोस्ट
सीएसएस संक्रमण प्रभाव छवि blurry बनाता है / छवि 1px चाल, क्रोम में? एपीआई का इस्तेमाल करते हुए instagram के लिए चित्रों को कैसे पोस्ट करें सी ++ को मॉलोक () के लिए एक कलाकार की आवश्यकता क्यों है, लेकिन सी नहीं है? हनोई के टॉवर: पुनरावर्ती अल्गोरिदम क्या मैं ASP.NET MVC में "विचारों की खोज" के लिए एक कस्टम स्थान निर्दिष्ट कर सकता हूं? Jquery AJAX का उपयोग कर HTML फ़ॉर्म सबमिट करना एंड्रॉइड 6.0 मार्शमोलो (एपीआई 23) पर पदावनत हो चुके कॉन्ट्रैक्ट (इंट आईडी) एसवीजी फाइलों में परिवर्तन हटा रहा है पदावनत आकार के लिए प्रतिस्थापनफ़ोथफॉन्ट: IOS 7 में? Dijkstra के एल्गोरिथ्म और ए-स्टार की तुलना कैसे होती है? कैसे अनारक्षित सूची में कन्वर्ट करने के लिए अच्छी तरह से स्टाइल <चयन> ड्रॉपडाउन jquery का उपयोग कर? रूबी में snake_case से CamelCase में स्ट्रिंग परिवर्तित करना NumPy के einsum को समझना रेल 3 में बंदर पैचिंग उद्देश्य-सी 2.0 में अंडरस्कोर के साथ इंस्टेंस व्हेरिएबल्स और @ सिंटेटेज़ के साथ नाम बदलने से एक्सकोड 4 के 'एनालिस' टूल द्वारा अनुकूलन चेतावनियों की ओर जाता है

क्या घटकों और सेटर्स के लिए यूनिट टेस्ट लिखना चाहिए?

क्या हम अपने गेटर्स और सेटर्स के लिए परीक्षण लिखना चाहते हैं या क्या यह उपरांत है?

Solutions Collecting From Web of "क्या घटकों और सेटर्स के लिए यूनिट टेस्ट लिखना चाहिए?"

मैं नहीं कहूंगा

@ आपको कहा जाएगा कि आपको 100% कोड कवरेज का लक्ष्य होना चाहिए, लेकिन मेरी राय में यह एक खतरनाक व्याकुलता है। आप यूनिट परीक्षणों को लिख सकते हैं जिनके पास 100% कवरेज है, और फिर भी बिल्कुल कुछ भी नहीं परीक्षण करें।

आपके कोड के व्यवहार को एक अभिव्यंजक और सार्थक तरीके से परीक्षण करने के लिए यूनिट टेस्ट होते हैं, और गेटर्स / सेटर्स केवल एक अंत के लिए एक साधन हैं यदि आप "वास्तविक" कार्यक्षमता के परीक्षण के अपने लक्ष्य को प्राप्त करने के लिए गेटर्स / सेटर्स का उपयोग करते हैं, तो यह काफी अच्छा है

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

टीडीडी के साथ एक बढ़िया हाँ


नोट : यह उत्तर अपवोट हो रहा है, यद्यपि संभावित रूप से एक बुरी सलाह। समझने के लिए, अपनी छोटी बहन को देखो।

यदि आप अपने विश्वासों को मजबूत करने के लिए यहां हैं – तो हम सभी को सुदृढीकरण जैसे लेकिन अगर आप समझदार बनना चाहते हैं, तो बहन को देखें


विवादास्पद ठीक है, लेकिन मैं तर्क करता हूं कि इस प्रश्न के लिए 'नहीं' का उत्तर देने वाला कोई भी व्यक्ति टीडीडी की मौलिक अवधारणा खो रहा है।

मेरे लिए, जवाब एक शानदार हाँ है अगर आप टीडीडी का पालन करते हैं। यदि आप नहीं हैं तो कोई जवाब नहीं है।

टीडीडी में डीडीडी

टीडीडी को अक्सर मुख्य लाभ होने के रूप में उद्धृत किया जाता है

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

कार्यान्वयन से अलग जिम्मेदारी

प्रोग्रामर के रूप में, विशेषताओं और गेटर्स और सेटर के रूप में किसी प्रकार के ऊपरी हिस्से के रूप में गुणों के बारे में सोचना बहुत ही मोहक है।

लेकिन विशेषताओं का एक कार्यान्वयन विवरण होता है, जबकि सेटर्स और गेटर्स संविदात्मक इंटरफ़ेस हैं जो वास्तव में कार्यक्रमों को काम करते हैं।

यह जादू करना अधिक महत्वपूर्ण है कि वस्तु चाहिए:

अपने ग्राहकों को अपनी स्थिति बदलने की अनुमति दें

तथा

अपने ग्राहकों को इसकी स्थिति पूछने के लिए अनुमति दें

तो यह राज्य वास्तव में कैसे संग्रहीत होता है (जिसके लिए एक विशेषता सबसे आम है, लेकिन एकमात्र तरीका नहीं है)।

एक परीक्षण जैसे कि

(The Painter class) should store the provided colour 

टीडीडी के दस्तावेज भाग के लिए महत्वपूर्ण है

तथ्य यह है कि अंतिम कार्यान्वयन तुच्छ (विशेषता) है और जब आप परीक्षण लिखते हैं तो आपके पास कोई रक्षा लाभ नहीं होना चाहिए।

दौर की यात्रा इंजीनियरिंग की कमी …

प्रणाली के विकास की दुनिया में प्रमुख समस्याओं में से एक राउंड-ट्रिप इंजीनियरिंग की कमी है 1 – एक प्रणाली का विकास प्रक्रिया विसंगत उप-प्रक्रियाओं में विखंडित है, जिनमें से कलाकृतियों (दस्तावेज़ीकरण, कोड) अक्सर असंगत हैं।

1 ब्रोडी, माइकल एल। "जॉन मायलोपोलोस: वैचारिक मॉडलिंग के सिलाई बीज।" संकल्पनात्मक मॉडलिंग: नींव और अनुप्रयोग स्प्रिंगर बर्लिन हीडलबर्ग, 200 9। 1- 9

… और कैसे टीडीडी इसे हल करता है

यह टीडीडी का दस्तावेज़ीकरण भाग है जो यह सुनिश्चित करता है कि सिस्टम की विशिष्टताओं और इसके कोड हमेशा अनुरूप होते हैं।

पहले डिजाइन, बाद में लागू करें

टीडीडी के भीतर हम पहले स्वीकृति परीक्षण में असफलता लिखते हैं, केवल तब कोड लिखते हैं जो उन्हें पास करते हैं

उच्चतर स्तर वाली बीडीडी के भीतर, हम परिदृश्यों को पहले लिखते हैं, फिर उन्हें पास करें

आप सेटर्स और कैटर को क्यों छोड़ दें?

सिद्धांत रूप में, एक व्यक्ति को परीक्षण लिखने के लिए टीडीडी के भीतर पूरी तरह से संभव है, और दूसरे कोड को कार्यान्वित करने के लिए जो इसे पास करता है

तो अपने आप से पूछिए:

क्या किसी वर्ग के लिए परीक्षण लिखने वाला व्यक्ति गेटर्स और सेटर का उल्लेख करता है

चूंकि गेटर्स और सेटर्स एक वर्ग के लिए एक सार्वजनिक इंटरफ़ेस हैं, इसलिए इसका जवाब हां है , या किसी ऑब्जेक्ट की स्थिति को सेट करने या क्वेरी करने का कोई तरीका नहीं होगा। हालांकि , ऐसा करने का तरीका अलगाव में प्रत्येक पद्धति का परीक्षण करके जरूरी नहीं है, मुझे और अधिक के लिए अन्य जवाब देखें।

जाहिर है, यदि आप कोड को पहले लिखते हैं, तो इसका जवाब स्पष्ट नहीं हो सकता है

रॉय ओसहेरोव ने अपनी प्रसिद्ध पुस्तक 'दी आर्ट ऑफ यूनिट टेस्टिंग' में कहा:

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

tl; dr: हाँ, आपको चाहिए , और ओपन पीजो के साथ यह तुच्छ है

  1. आपको अपने गेटर्स और सेटर्स में कुछ वैल्यूशन करना चाहिए ताकि आपको इसका परीक्षण करना चाहिए। उदाहरण के लिए, setMom(Person p) को अपने माता के रूप में खुद को छोटा करने की अनुमति नहीं देना चाहिए

  2. यहां तक ​​कि अगर आप उसमें से कोई भी नहीं कर रहे हैं, तो आप भविष्य में बाधाएं देंगे, फिर यह प्रतिगमन विश्लेषण के लिए अच्छा होगा। यदि आप माताओं को null करने की अनुमति देना चाहते हैं, तो आपको एक परीक्षण होना चाहिए, जिसे किसी को बाद में बदल लेना चाहिए, यह आपकी मान्यताओं को सुदृढ़ करेगा

  3. एक सामान्य बग void setFoo( Object foo ){ foo = foo; } void setFoo( Object foo ){ foo = foo; } जहां यह void setFoo( Object foo ){ this.foo = foo; } होना चाहिए void setFoo( Object foo ){ this.foo = foo; } void setFoo( Object foo ){ this.foo = foo; } (पहले मामले में उस foo को लिखे जा रहा है, पैरामीटर ऑब्जेक्ट पर foo फील्ड नहीं है)।

  4. अगर आप किसी सरणी या संग्रह को वापस कर रहे हैं तो आपको यह जांच करनी चाहिए कि वापस आने से पहले सेटर में पास किए गए डेटा की रक्षात्मक प्रतियां प्राप्त करने वाले या नहीं।

  5. अन्यथा, यदि आपके पास सबसे बुनियादी सेटर्स / गेटर्स हैं तो यूनिट-टेस्टिंग उनका अधिकतम प्रति-ऑब्जेक्ट में लगभग 10 मिनट जोड़ देगा, तो क्या नुकसान है? यदि आप व्यवहार जोड़ते हैं तो आपके पास पहले से एक कंकाल परीक्षण है और आप इस प्रतिगमन परीक्षण को निःशुल्क प्राप्त कर सकते हैं। यदि आप जावा का उपयोग कर रहे हैं, तो आपके पास कोई बहाना नहीं है क्योंकि वहाँ ओपनपोओओ है । मौजूदा नियमों का एक सेट है जो आप सक्षम कर सकते हैं और फिर अपने पूरे प्रोजेक्ट को स्कैन कर सकते हैं यह सुनिश्चित करने के लिए कि वे आपके कोड में लगातार लागू होते हैं।

उनके उदाहरणों से :

 final PojoValidator pojoValidator = new PojoValidator(); //create rules pojoValidator.addRule( new NoPublicFieldsRule () ); pojoValidator.addRule( new NoPrimitivesRule () ); pojoValidator.addRule( new GetterMustExistRule () ); pojoValidator.addRule( new SetterMustExistRule () ); //create testers pojoValidator.addTester( new DefaultValuesNullTester () ); pojoValidator.addTester( new SetterTester () ); pojoValidator.addTester( new GetterTester () ); //test all the classes for( PojoClass pojoClass : PojoClassFactory.getPojoClasses( "net.initech.app", new FilterPackageInfo() ) ) pojoValidator.runValidation( pojoClass ); 

अगर प्राप्तकर्ता और / या सेटर के चक्रवर्ती जटिलता 1 (जो कि वे आम तौर पर होती हैं), तो उत्तर नहीं है, आपको नहीं करना चाहिए

इसलिए जब तक आपके पास कोई एसएलए नहीं है, जिसके लिए 100% कोड कवरेज की आवश्यकता होती है, चिंता न करें और अपने सॉफ़्टवेयर के महत्वपूर्ण पहलू का परीक्षण करने पर ध्यान केंद्रित करें।

पीएस यादगार और सेटर्स को अलग करने के लिए याद रखें, यहां तक ​​कि सी # जैसी भाषाओं में भी जहां गुण एक ही चीज़ की तरह लग सकते हैं सेटर जटिलता प्राप्तकर्ता से अधिक हो सकती है, और इस तरह एक इकाई-परीक्षण को मान्य करता है।

हां, लेकिन हमेशा अलगाव में नहीं

मुझे विस्तृत अनुमति दें:

एक इकाई परीक्षण क्या है?

लीगेसी कोड के साथ प्रभावी ढंग से कार्य करना 1 :

यूनिट टेस्ट शब्द का सॉफ़्टवेयर विकास में लंबा इतिहास है। यूनिट परीक्षणों की अधिकांश अवधारणाओं के लिए आम तौर पर यह विचार होता है कि वे सॉफ्टवेयर के अलग-अलग घटकों के अलगाव में परीक्षण कर रहे हैं। घटकों क्या हैं? परिभाषा में भिन्नता है, लेकिन इकाई परीक्षण में, हम आम तौर पर सिस्टम के सबसे परमाणु व्यवहार इकाइयों से चिंतित होते हैं। प्रक्रियात्मक कोड में, इकाइयां अक्सर कार्य करती हैं ऑब्जेक्ट ओरिएंटेड कोड में, यूनिट्स कक्षाएं हैं I

ध्यान दें कि ओओपी के साथ, जहां आप गेटर्स और सेटर्स पाते हैं, यूनिट क्लास है , जरूरी नहीं कि अलग-अलग तरीके

एक अच्छा परीक्षण क्या है?

सभी आवश्यकताओं और परीक्षणों को हारे तर्क के रूप का पालन करें:

{P} सी {क्यू}

कहा पे:

  • {P} पूर्व शर्त है ( दिए गए )
  • C ट्रिगर स्थिति है ( जब )
  • {Q} बाद की शर्त है ( तब )

फिर कहावत आता है:

परीक्षण व्यवहार, क्रियान्वयन नहीं

इसका मतलब यह है कि आपको यह जांच नहीं करनी चाहिए कि C के बाद की स्थिति कैसे हासिल होती है, आपको यह देखना चाहिए कि {Q} C का नतीजा C

जब यह OOP की बात आती है, तो C एक वर्ग है। तो आपको आंतरिक प्रभाव का परीक्षण नहीं करना चाहिए, केवल बाह्य प्रभाव

क्यों नहीं अलगाव में सेम गेटर्स और सेटर्स का परीक्षण करें

गेटर्स और सेटर्स में कुछ तर्क शामिल हो सकते हैं, लेकिन इतने लंबे समय तक इस तर्क में बाहरी प्रभाव नहीं होता है – उन्हें बीन एक्सेसर्स बनाते हैं) 2 एक परीक्षण को ऑब्जेक्ट के अंदर देखना होगा और न केवल इनकैप्सुलेशन का उल्लंघन करना होगा बल्कि कार्यान्वयन के लिए भी परीक्षण करना होगा।

तो आपको अलगाव में बीन गेस्टर्स और सेटर्स का परीक्षण नहीं करना चाहिए। ये गलत है:

 Describe 'LineItem class' Describe 'setVAT()' it 'should store the VAT rate' lineItem = new LineItem() lineItem.setVAT( 0.5 ) expect( lineItem.vat ).toBe( 0.5 ) 

यद्यपि setVAT एक अपवाद फेंक देगा, एक उपयुक्त परीक्षण उचित होगा क्योंकि अब बाहरी प्रभाव है

आप कैसे प्राप्तकर्ता और सेटर्स का परीक्षण कर सकते हैं?

अगर इस तरह के बदलाव का बाद में बाद में प्रभाव पड़ता है, तो इस तरह के बदलाव का बाहरी भाग पर कोई असर नहीं पड़ता है।

तो सेटर्स और गेटर्स के लिए एक परीक्षण इन तरीकों के बाहरी प्रभाव से चिंतित होना चाहिए, आंतरिक रूप से नहीं।

उदाहरण के लिए:

 Describe 'LineItem class' Describe 'getGross()' it 'should return the net time the VAT' lineItem = new LineItem() lineItem.setNet( 100 ) lineItem.setVAT( 0.5 ) expect( lineItem.getGross() ).toBe( 150 ) 

आप खुद को सोच सकते हैं:

एक सेकंड रुको, हम getGross() का परीक्षण कर रहे हैं यहां सेट नहीं है setVAT()

लेकिन अगर setVAT() खराबी यह है कि परीक्षण सभी एक ही विफल हो जाना चाहिए।

1 पंख, एम।, 2004. विरासत कोड के साथ प्रभावी ढंग से कार्य करना। प्रेंटिस हॉल प्रोफेशनल

2 मार्टिन, आरसी, 200 9। क्लीन कोड: चुस्त सॉफ्टवेयर शिल्प कौशल की एक पुस्तिका। पियर्सन एजुकेशन

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

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

ऐसे स्पष्ट कारण हैं, जहां पढ़ें / लिखें गुणों का उपयोग किया जाना चाहिए, जैसे कि इनपुट फील्ड, आदि के लिए सीमित ViewModel गुण हैं।

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

  1. आप ऐसे परीक्षणों को याद कर रहे हैं जो अप्रत्यक्ष रूप से गुणों का उपयोग करते हैं
  2. गुणों अप्रयुक्त हैं

यदि आप गेटर्स और सेटर्स के लिए टेस्ट लिखते हैं, तो आपको कवरेज की झूठी भावना मिलती है और यह निर्धारित नहीं कर पाएगा कि गुण वास्तव में कार्यात्मक व्यवहार द्वारा उपयोग किए गए हैं या नहीं।

एक विनोदी, अभी तक बुद्धिमान ले: टेस्टिविस का रास्ता

"आज की परीक्षा लिखें"

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

मैंने ज्यूनेट कोड में हासिल की गई कवरेज का थोड़ा विश्लेषण किया

खुला वर्ग की एक श्रेणी "परीक्षण करने के लिए बहुत आसान" है इसमें सरल ग्रहण और सेटर्स शामिल हैं, जो कि जेयूनेट के डेवलपर्स का परीक्षण नहीं करते हैं

दूसरी ओर, JUnit में कोई भी (गैर-पदावनत) विधि 3 लाइनों से अधिक लंबे समय तक नहीं है जो कि किसी भी परीक्षण से नहीं आती है।

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

इसके अलावा, अगर आप हमारे जैसे कोड कवरेज रिपोर्ट का उपयोग कर रहे हैं, तो आप जो कुछ कर सकते हैं वह [ExcludeFromCodeCoverage] विशेषता जोड़ देगा हमारा समाधान उन मॉडलों के लिए इसका उपयोग करने के लिए किया गया है, जिनके पास केवल गेटर्स और सेटर्स का उपयोग करने के गुण हैं, या खुद संपत्ति पर। इस प्रकार यह कोड कवरेज रिपोर्ट चलाए जाने पर कुल कोड कवरेज% को प्रभावित नहीं करेगा, यह मानते हुए कि आप अपने कोड कवरेज प्रतिशत की गणना के लिए उपयोग कर रहे हैं। खुश परीक्षण!