टीडीडी के बारे में मैंने जो पाया है वह यह है कि आपके परीक्षणों को स्थापित करने में स्वाभाविक रूप से समय लगता है और स्वाभाविक रूप से आलसी होने के कारण मैं हमेशा जितना संभव हो उतना कम कोड लिखना चाहता हूं। पहली बात जो मुझे लगती है वह यह है कि मेरे निर्माता ने सभी गुणों को निर्धारित किया है लेकिन क्या यह ओवरकिल है?
मेरा सवाल यह है कि आप किस स्तर की ग्रैन्युलैरिटी पर आपको यूनिट टेस्ट लिखते हैं?
..और क्या बहुत ज्यादा परीक्षण का मामला है?
जवाबों:
मुझे उस कोड के लिए भुगतान किया जाता है जो काम करता है, परीक्षणों के लिए नहीं, इसलिए मेरा दर्शन विश्वास के किसी दिए गए स्तर तक पहुंचने के लिए जितना संभव हो उतना कम परीक्षण करना है (मुझे संदेह है कि आत्मविश्वास का यह स्तर उद्योग के मानकों की तुलना में अधिक है, लेकिन यह सिर्फ हब्रीस हो सकता है) । अगर मैं आमतौर पर एक तरह की गलती नहीं करता हूं (जैसे एक कंस्ट्रक्टर में गलत चर सेट करना), तो मैं इसके लिए परीक्षण नहीं करता हूं। मैं परीक्षण त्रुटियों के बारे में समझ बनाने की कोशिश करता हूं, इसलिए जब मैं जटिल परिस्थितियों के साथ तर्क करता हूं तो मैं अतिरिक्त सावधान रहता हूं। एक टीम पर कोडिंग करते समय, मैं अपनी रणनीति को सावधानीपूर्वक परीक्षण कोड में संशोधित करता हूं कि हम, सामूहिक रूप से, गलत हो जाते हैं।
इस दर्शन के आधार पर अलग-अलग लोगों की अलग-अलग परीक्षण रणनीतियाँ होंगी, लेकिन यह मुझे उचित लगता है कि मुझे यह समझने की अपरिपक्व अवस्था दी गई है कि परीक्षण कैसे कोडिंग के आंतरिक पाश में फिट हो सकते हैं। अब से दस या बीस साल बाद, हमारे पास एक और अधिक सार्वभौमिक सिद्धांत होगा कि कौन सा परीक्षण लिखना है, कौन सा परीक्षण लिखना नहीं है, और अंतर कैसे बताना है। इस बीच, प्रयोग क्रम में लगता है।
उन चीजों के लिए इकाई परीक्षण लिखें जिन्हें आप तोड़ने की उम्मीद करते हैं, और किनारे के मामलों के लिए। उसके बाद, टेस्ट मामलों को जोड़ा जाना चाहिए क्योंकि बग रिपोर्ट में - बग के लिए फिक्स लिखने से पहले आते हैं। तब डेवलपर आश्वस्त हो सकता है कि:
संलग्न टिप्पणी के अनुसार - मुझे लगता है कि इकाई परीक्षणों को लिखने के लिए यह दृष्टिकोण समस्याओं का कारण बन सकता है, यदि बहुत सारे बग, समय के साथ, किसी दिए गए वर्ग में खोजे जाते हैं। यह शायद वह जगह है जहाँ विवेक मददगार है - केवल उन बग्स के लिए यूनिट परीक्षण जोड़ना जो फिर से होने की संभावना रखते हैं, या जहां उनकी पुन: घटना गंभीर समस्याएं पैदा करती हैं। मैंने पाया है कि इकाई परीक्षणों में एकीकरण परीक्षण का एक उपाय इन परिदृश्यों में मददगार हो सकता है - कोड कोड को उच्चतर परीक्षण करने से कोडपैथ कम हो सकते हैं।
सब कुछ जितना संभव हो उतना सरल बनाया जाना चाहिए, लेकिन सरल नहीं। - ए। आइंस्टीन
टीडीडी के बारे में सबसे गलत बातों में से एक इसमें पहला शब्द है। परीक्षा। इसलिए बीडीडी साथ आए। क्योंकि लोग वास्तव में यह नहीं समझते थे कि पहला डी महत्वपूर्ण था, अर्थात् प्रेरित। हम सभी परीक्षण के बारे में बहुत कुछ करने के लिए सोचते हैं, और डिजाइन की ड्राइविंग के बारे में थोड़ा बहुत कम करते हैं। और मुझे लगता है कि यह आपके प्रश्न का एक अस्पष्ट उत्तर है, लेकिन आपको संभवतः अपने कोड को चलाने के बारे में विचार करना चाहिए, इसके बजाय कि आप वास्तव में क्या परीक्षण कर रहे हैं; यह एक ऐसी कवरेज-टूल है जिसकी सहायता से आप कुछ कर सकते हैं। डिजाइन एक बहुत बड़ा और अधिक समस्याग्रस्त मुद्दा है।
उन लोगों के लिए जो "सब कुछ" परीक्षण का प्रस्ताव देते हैं: महसूस करते हैं कि "पूरी तरह से परीक्षण" जैसी विधिint square(int x) लिए सामान्य भाषाओं और विशिष्ट वातावरण में लगभग 4 बिलियन परीक्षण मामलों आवश्यकता होती है।
वास्तव में, यह उससे भी बदतर है: एक विधि void setX(int newX)भी आभारी है नहीं के अतिरिक्त कोई अन्य सदस्यों के मूल्यों को बदलने के लिए x- आपको लगता है कि परीक्षण कर रहे हैं obj.y, obj.zआदि सभी बुला के बाद अपरिवर्तित ही रहेंगे obj.setX(42);?
"सब कुछ" के सबसेट का परीक्षण करना केवल व्यावहारिक है। एक बार जब आप इसे स्वीकार करते हैं, तो अविश्वसनीय रूप से बुनियादी व्यवहार का परीक्षण नहीं करने पर विचार करने के लिए यह अधिक स्वादिष्ट हो जाता है। प्रत्येक प्रोग्रामर के पास बग स्थानों की संभावना वितरण है; स्मार्ट दृष्टिकोण यह है कि आप परीक्षण क्षेत्रों पर अपनी ऊर्जा को केंद्रित करें जहां आप बग संभावना को अधिक होने का अनुमान लगाते हैं।
क्लासिक उत्तर "कुछ भी परीक्षण करें जो संभवतः टूट सकता है"। मैं व्याख्या करता हूं कि इसका अर्थ यह है कि परीक्षण बसने वाले और पाने वाले जो सेट के अलावा कुछ भी नहीं करते हैं या संभवतया बहुत अधिक परीक्षण है, समय लेने की आवश्यकता नहीं है। जब तक आपका आईडीई आपके लिए उन्हें नहीं लिखता, तब तक आप भी।
अगर आपका कंस्ट्रक्टर नहीं की स्थापना गुण बाद में त्रुटियों के लिए ले जा सकता है, तो परीक्षण वे कर रहे हैं कि सेट overkill नहीं है।
मैं उन कक्षाओं की मान्यताओं को कवर करने के लिए परीक्षण लिखता हूं जो मैं लिखूंगा। परीक्षण आवश्यकताओं को लागू करते हैं। अनिवार्य रूप से, यदि x कभी 3 नहीं हो सकता है, उदाहरण के लिए, मैं यह सुनिश्चित करने जा रहा हूं कि एक परीक्षण है जो उस आवश्यकता को कवर करता है।
वास्तव में, अगर मैं किसी शर्त को कवर करने के लिए परीक्षण नहीं लिखता हूं, तो यह "मानव" परीक्षण के दौरान बाद में फसल लेगा। मैं एक निश्चित रूप से लिखूंगा, लेकिन मैं उन्हें जल्दी पकड़ूंगा। मुझे लगता है कि परीक्षण थकाऊ (शायद) लेकिन आवश्यक है। मैं पूरा होने के लिए पर्याप्त परीक्षण लिखता हूं लेकिन इससे अधिक नहीं।
सरल परीक्षणों को छोड़ देने के साथ समस्या का एक हिस्सा यह है कि भविष्य में रिफैक्टरिंग बहुत सारे तर्क के साथ उस सरल संपत्ति को बहुत जटिल बना सकती है। मुझे लगता है कि सबसे अच्छा विचार यह है कि आप मॉड्यूल के लिए आवश्यकताओं को सत्यापित करने के लिए टेस्ट का उपयोग कर सकते हैं। यदि आप एक्स पास करते हैं तो आपको वाई वापस मिलनी चाहिए, तो यही आप परीक्षण करना चाहते हैं। फिर जब आप बाद में कोड बदलते हैं, तो आप सत्यापित कर सकते हैं कि X आपको Y देता है, और आप A के लिए एक परीक्षण जोड़ सकते हैं जो आपको B देता है, जब बाद में उस आवश्यकता को जोड़ा जाता है।
मैंने पाया है कि प्रारंभिक विकास लेखन परीक्षणों के दौरान मैं जो समय बिताता हूं वह पहली या दूसरी बग फिक्स में भुगतान करता है। कोड लेने की क्षमता जिसे आपने 3 महीने में नहीं देखा है और यह सुनिश्चित करें कि आपका फिक्स सभी मामलों को कवर करता है, और "शायद" कुछ भी नहीं तोड़ता है बेहद मूल्यवान है। आपको यह भी पता चलेगा कि इकाई परीक्षण, स्टैग ट्रेस से परे ट्राइ बग्स को अच्छी तरह से मदद करेंगे, आदि यह देखते हुए कि ऐप के अलग-अलग टुकड़े कैसे काम करते हैं और असफल होते हैं, इस बात पर भारी अंतर्दृष्टि देते हैं कि वे काम क्यों करते हैं या एक पूरे के रूप में विफल होते हैं।
ज्यादातर उदाहरणों में, मैं कहूंगा, अगर वहाँ तर्क है, तो इसका परीक्षण करें। इसमें कंस्ट्रक्टर और गुण शामिल हैं, खासकर जब संपत्ति में एक से अधिक चीजें सेट हो जाती हैं।
बहुत अधिक परीक्षण के संबंध में, यह बहस का विषय है। कुछ कहेंगे कि सब कुछ मजबूती के लिए परीक्षण किया जाना चाहिए, दूसरों का कहना है कि कुशल परीक्षण के लिए, केवल उन चीजों को तोड़ना चाहिए (यानी तर्क) का परीक्षण किया जाना चाहिए।
मैं व्यक्तिगत अनुभव से सिर्फ दूसरे शिविर की ओर अधिक झुकाव था, लेकिन अगर किसी ने सब कुछ का परीक्षण करने का फैसला किया है, तो मैं यह नहीं कहूंगा कि यह बहुत ज्यादा था ... मेरे लिए थोड़ा ओवरकिल, लेकिन उनके लिए बहुत ज्यादा नहीं।
तो, नहीं - मैं कहूंगा कि केवल सामान्य व्यक्तियों के लिए "बहुत अधिक" परीक्षण के रूप में ऐसी कोई चीज नहीं है।
टेस्ट ड्रिवेन डेवलपमेंट का मतलब है कि जब आपके सारे टेस्ट पास हो जाएंगे तो आप कोडिंग बंद कर देंगे।
यदि आपके पास संपत्ति के लिए कोई परीक्षण नहीं है, तो आपको इसे क्यों लागू करना चाहिए? यदि आप "अवैध" असाइनमेंट के मामले में अपेक्षित व्यवहार का परीक्षण / परिभाषित नहीं करते हैं, तो संपत्ति क्या करना चाहिए?
इसलिए मैं पूरी तरह से हर व्यवहार का परीक्षण करने के लिए एक कक्षा का प्रदर्शन करना चाहिए। जिसमें "आदिम" गुण शामिल हैं।
इस परीक्षण को आसान बनाने के लिए, मैंने एक सरल NUnit बनाया, TestFixtureजो मान प्राप्त करने / प्राप्त करने के लिए विस्तार बिंदु प्रदान करता है और मान्य और अमान्य मानों की सूची लेता है और यह जाँचने के लिए एकल परीक्षण करता है कि संपत्ति सही काम करती है या नहीं। एक एकल संपत्ति का परीक्षण इस तरह दिख सकता है:
[TestFixture]
public class Test_MyObject_SomeProperty : PropertyTest<int>
{
private MyObject obj = null;
public override void SetUp() { obj = new MyObject(); }
public override void TearDown() { obj = null; }
public override int Get() { return obj.SomeProperty; }
public override Set(int value) { obj.SomeProperty = value; }
public override IEnumerable<int> SomeValidValues() { return new List() { 1,3,5,7 }; }
public override IEnumerable<int> SomeInvalidValues() { return new List() { 2,4,6 }; }
}
लैम्ब्डा और विशेषताओं का उपयोग करके इसे और भी अधिक कॉम्पैक्ट रूप से लिखा जा सकता है। मैं इकट्ठा MBUnit भी उस तरह की चीजों के लिए कुछ देशी समर्थन है। हालांकि मुद्दा यह है कि उपरोक्त कोड संपत्ति के इरादे को पकड़ लेता है।
पुनश्च: संभवत: प्रॉपर्टीस्ट के पास यह जांचने का एक तरीका होना चाहिए कि ऑब्जेक्ट पर अन्य गुण नहीं बदले। हम्म .. ड्राइंग बोर्ड पर वापस।
मैं अधिकतम संभव कवरेज तक पहुंचने के लिए इकाई परीक्षण करता हूं। यदि मैं कुछ कोड तक नहीं पहुंच सकता, तो जब तक कवरेज यथासंभव भरा हुआ है, मैं रिफ्लेक्टर करता हूं
लेखन परीक्षण अंधा करने के लिए समाप्त होने के बाद, मैं आमतौर पर प्रत्येक बग को पुन: पेश करने वाला एक परीक्षण मामला लिखता हूं
मुझे कोड परीक्षण और एकीकरण परीक्षण के बीच अलग करने के लिए उपयोग किया जाता है। एकीकरण परीक्षण के दौरान, (जो इकाई परीक्षण भी हैं, लेकिन घटकों के समूहों पर, इसलिए इकाई परीक्षण के लिए वास्तव में क्या नहीं है) मैं आवश्यकताओं को सही ढंग से लागू करने के लिए परीक्षण करूंगा।
इसलिए जितना अधिक मैं परीक्षण लिखकर अपनी प्रोग्रामिंग चलाता हूं, उतना कम मैं परीक्षण के दाने के स्तर के बारे में चिंता करता हूं। पीछे मुड़कर देखें तो ऐसा लगता है कि मैं व्यवहार को सरल बनाने के अपने लक्ष्य को प्राप्त करने के लिए सबसे सरल काम कर रहा हूं । इसका मतलब है कि मैं विश्वास की एक परत पैदा कर रहा हूं कि मेरा कोड वही कर रहा है जो मैं करने के लिए कहता हूं, हालांकि यह पूर्ण गारंटी नहीं माना जाता है कि मेरा कोड बग मुक्त है। मुझे लगता है कि सही संतुलन मानक व्यवहार का परीक्षण करना है और शायद एक किनारे का मामला है या दो तो मेरे डिजाइन के अगले हिस्से पर चलते हैं।
मैं स्वीकार करता हूं कि यह सभी बगों को कवर नहीं करेगा और इन पर कब्जा करने के लिए अन्य पारंपरिक परीक्षण विधियों का उपयोग करेगा।
आम तौर पर, मैं छोटे से शुरू करता हूं, इनपुट और आउटपुट के साथ जो मुझे पता है कि काम करना चाहिए। फिर, जैसा कि मैं बग को ठीक करता हूं, मैं उन चीजों को सुनिश्चित करने के लिए अधिक परीक्षण जोड़ता हूं जो मैंने तय किए हैं। यह जैविक है, और मेरे लिए अच्छा काम करता है।
क्या आप बहुत अधिक परीक्षण कर सकते हैं? शायद, लेकिन यह शायद सामान्य तौर पर सावधानी बरतने के लिए बेहतर है, हालांकि यह इस बात पर निर्भर करेगा कि आपका आवेदन कितना महत्वपूर्ण है।
मुझे लगता है कि आपको अपने व्यापार तर्क के "कोर" में सब कुछ परीक्षण करना होगा। गेट्टर ans सेटर भी क्योंकि वे नकारात्मक मूल्य या शून्य मान को स्वीकार कर सकते हैं जिसे आप स्वीकार नहीं करना चाहते हैं। यदि आपके पास समय है (हमेशा अपने बॉस पर निर्भर रहें) तो अन्य व्यावसायिक तर्क और सभी नियंत्रक का परीक्षण करना अच्छा है जो इन ऑब्जेक्ट को कॉल करते हैं (आप यूनिट टेस्ट से धीरे-धीरे एकीकरण परीक्षण तक जाते हैं)।
मैं सरल सेटर / गेट्टर विधियों का परीक्षण नहीं करता जिनका कोई साइड इफेक्ट नहीं है। लेकिन मैं हर दूसरे सार्वजनिक तरीके से यूनिट टेस्ट करता हूं। मैं अपने अल्गोरिथम में सभी सीमाओं की स्थितियों के लिए परीक्षण बनाने की कोशिश करता हूं और अपनी इकाई परीक्षणों की कवरेज की जांच करता हूं।
इसका बहुत काम है, लेकिन मुझे लगता है कि यह इसके लायक है। मैं एक डिबगर में कोड के माध्यम से चरण के बजाय कोड (यहां तक कि परीक्षण कोड) लिखूंगा। मुझे लगता है कि कोड-बिल्ड-डिप्लॉयमेंट-डिबग चक्र बहुत समय लेने वाला है और जितनी अधिक यूनिट परीक्षण मैंने अपने बिल्ड में एकीकृत किया है, उतना कम समय मैं उस कोड-बिल्ड-तैनाती-डिबग चक्र के माध्यम से खर्च करता हूं।
आपने यह नहीं बताया कि आर्किटेक्चर आप कोडिंग भी क्यों कर रहे हैं। लेकिन Java के लिए मैं Maven 2 , JUnit , DbUnit , Cobertura , और EasyMock का उपयोग करता हूं ।
जितना अधिक मैं इसके बारे में पढ़ता हूं, मुझे लगता है कि कुछ यूनिट परीक्षण कुछ पैटर्न की तरह हैं: अपर्याप्त भाषाओं की गंध।
जब आपको यह जांचने की आवश्यकता होती है कि क्या आपका तुच्छ गटर वास्तव में सही मूल्य देता है, तो इसका कारण यह है कि आप गेटर का नाम और सदस्य चर नाम को इंटरमिक्स कर सकते हैं। माणिक का 'अटर_रीडर: नाम' दर्ज करें, और यह किसी भी अधिक नहीं हो सकता है। सिर्फ जावा में संभव नहीं है।
यदि आपका गेट्टर कभी भी नॉटिवर हो जाता है तो आप इसके लिए फिर भी एक टेस्ट जोड़ सकते हैं।
स्रोत कोड का परीक्षण करें जो आपको इसके बारे में चिंतित करता है।
कोड के कुछ हिस्सों का परीक्षण करना उपयोगी नहीं है जिसमें आप बहुत आश्वस्त हैं, जब तक आप इसमें गलतियाँ नहीं करते हैं।
बगफिक्स का परीक्षण करें, ताकि यह पहली और आखिरी बार आपके बग को ठीक कर सके।
अस्पष्ट कोड भागों का विश्वास पाने के लिए परीक्षण करें, ताकि आप ज्ञान का निर्माण करें।
भारी और मध्यम रीफैक्टरिंग से पहले परीक्षण करें, ताकि आप मौजूदा सुविधाओं को न तोड़ें।
यह उत्तर यह पता लगाने के लिए अधिक है कि किसी इकाई को दिए गए तरीके के लिए उपयोग करने के लिए आप जानते हैं कि आप इसकी महत्वपूर्णता / महत्व के कारण इकाई परीक्षण करना चाहते हैं। मैककेबे द्वारा बेसिस पथ परीक्षण तकनीक का उपयोग करते हुए , आप सरल "स्टेटमेंट कवरेज" या "शाखा कवरेज" की तुलना में बेहतर कोड कवरेज विश्वास मात्रात्मक कर सकते हैं: