unit-testing - unit - यूनिट टेस्ट क्या है




यूनिट परीक्षण क्या है? (14)

यदि आप को बकवास का ढेर दिया जाता है और आप ऐसा महसूस करते हैं कि आप एक साफ सुथरी स्थिति में फंस गए हैं, तो आप जानते हैं कि किसी भी नई सुविधा या कोड के जुड़ने से करंट सेट टूट सकता है क्योंकि वर्तमान सॉफ्टवेयर एक घर की तरह है पत्ते?

फिर हम यूनिट परीक्षण कैसे कर सकते हैं?

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

अभी हम 40% से अधिक हैं, और हम अधिकतर कम लटकने वाले फलों को लेने में सफल रहे हैं।

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

मैंने एक विशिष्ट भाषा में यूनिट टेस्ट के लिए 'कैसे' से कई सवाल पूछे, लेकिन 'क्या', 'क्यों', और 'कब' से कोई प्रश्न नहीं देखा।

  • यह क्या है?
  • यह मेरे लिए क्या करता है?
  • मुझे क्यों इसका उपयोग करना चाहिए?
  • मुझे इसका उपयोग कब करना चाहिए (जब नहीं भी)?
  • कुछ सामान्य नुकसान और गलतफहमी क्या हैं

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

यदि आप अपने कोड को मैन्युअल रूप से परीक्षण करते हैं, तो यह आपको समझा सकता है कि कोड पूरी तरह से काम कर रहा है - इसकी वर्तमान स्थिति में । लेकिन एक हफ्ते बाद क्या हुआ, जब आपने इसमें थोड़ा संशोधन किया? जब भी आपके कोड में कुछ भी बदलाव होता है तो क्या आप इसे फिर से हाथ से देखने को तैयार रहते हैं? सबसे शायद नहीं :-(

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

यह हाथ परीक्षण पर यूनिट परीक्षणों का मुख्य लाभ है। लेकिन रुकिए, और भी है:

  • इकाई परीक्षण नाटकीय रूप से विकास प्रतिक्रिया पाश को छोटा करता है: एक अलग परीक्षण विभाग के साथ आपको यह जानने में सप्ताह लग सकते हैं कि आपके कोड में एक बग है, जिस समय तक आप पहले से ही संदर्भ के बहुत कुछ भूल चुके हैं, इस प्रकार आपको घंटों लग सकते हैं बग को ढूंढें और ठीक करें; यूनिट परीक्षणों के साथ OTOH, प्रतिक्रिया चक्र को सेकंड में मापा जाता है, और बग फिक्स प्रक्रिया आमतौर पर "ओह श * टी" की तर्ज पर होती है, मैं यहां उस स्थिति की जांच करना भूल गया हूं ":-)
  • इकाई आपके कोड के व्यवहार को प्रभावी ढंग से दस्तावेज (आपकी समझ) का परीक्षण करती है
  • इकाई परीक्षण आपको अपने डिजाइन विकल्पों का पुनर्मूल्यांकन करने के लिए मजबूर करता है, जिसके परिणामस्वरूप सरल, क्लीनर डिजाइन होता है

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


टेस्ट ड्रिवेन डेवलपमेंट में यूनिट टेस्ट शब्द को लिया गया है। एक पुराने टाइमर के रूप में मैं इसकी अधिक सामान्य परिभाषा का उल्लेख करूंगा।

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

फिर आप सभी अवयवों के एक साथ काम करने के परीक्षण द्वारा एकीकृत या सिस्टम परीक्षण के लिए आगे बढ़ेंगे।


मुझे विश्वविद्यालय में कभी इकाई परीक्षण नहीं सिखाया गया था, और मुझे इसे "प्राप्त" करने में थोड़ा समय लगा। मैंने इसके बारे में पढ़ा, "आह, सही, स्वचालित परीक्षण, जो कि मुझे लगता है कि शांत हो सकता है" चला गया, और फिर मैं इसके बारे में भूल गया।

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

और अब आपको एक समस्या मिल गई है: टूटा हुआ कोड ट्रंक में है और किसी को भी पता नहीं है। सबसे अच्छा मामला एक आंतरिक परीक्षक है जो आपको जहाज से पहले ढूंढता है, लेकिन कोड को ठीक करना जो खेल में देर से महंगा है। और अगर कोई आंतरिक परीक्षक इसे नहीं पाता है ... तो, यह वास्तव में बहुत महंगा हो सकता है।

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


मैं जेरार्ड मेस्सरोस द्वारा xUnit परीक्षण पैटर्न पुस्तक की सिफारिश करना चाहूंगा। यह बड़ा है, लेकिन यूनिट परीक्षण पर एक महान संसाधन है। यहां उसकी वेब साइट का लिंक दिया गया है जहां वह यूनिट टेस्टिंग की मूल बातें पर चर्चा करता है। http://xunitpatterns.com/XUnitBasics.html


मैं डैन से असहमत नहीं हूं (हालांकि एक बेहतर विकल्प सिर्फ जवाब देने के लिए नहीं हो सकता है) ... लेकिन ...

यूनिट परीक्षण आपके सिस्टम के व्यवहार और कार्यक्षमता का परीक्षण करने के लिए कोड लिखने की प्रक्रिया है।

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

  1. यह सुनिश्चित करते हुए कि आप व्यवहार (रिफैक्टिंग) को नहीं बदलते, तकनीकी कार्यान्वयन को बदलना आसान बनाते हैं। उचित रूप से इकाई परीक्षण किए गए कोड को बिना देखे कुछ भी तोड़ने की थोड़ी संभावना के साथ आक्रामक रूप से रिफलेक्ट / क्लीन किया जा सकता है।
  2. व्यवहार को जोड़ने या सुधार करने पर डेवलपर्स को विश्वास दिलाएं।
  3. अपने कोड का दस्तावेज़ दें
  4. अपने कोड के उन क्षेत्रों को इंगित करें जो कसकर युग्मित हैं। यह इकाई परीक्षण कोड के लिए कठिन है जो कसकर युग्मित है
  5. अपने एपीआई का उपयोग करने के लिए एक साधन प्रदान करें और जल्दी से कठिनाइयों की तलाश करें
  6. उन विधियों और वर्गों को इंगित करता है जो बहुत सामंजस्यपूर्ण नहीं हैं

आपको इकाई परीक्षण करना चाहिए क्योंकि आपके हित में अपने ग्राहक के लिए एक रखरखाव योग्य और गुणवत्ता वाले उत्पाद वितरित करना है।

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

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

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


यदि आप कैंट बेक द्वारा लोकप्रिय TDD दृष्टिकोण का उपयोग करके अपनी परियोजनाओं को विकसित करना चाहते हैं, तो NUnit , xUnit या JUnit जैसी लाइब्रेरियां अनिवार्य हैं:

आप टेस्ट ड्रिवेन डेवलपमेंट (TDD) या केंट बेक की पुस्तक टेस्ट ड्रिवेन डेवलपमेंट: बाय उदाहरण के लिए परिचय पढ़ सकते हैं।

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


यह उत्तर देता है कि आपको इकाई परीक्षण क्यों करना चाहिए।

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

इकाई परीक्षण: मिनट अब समय बचाएंगे - एरिक मान - https://www.youtube.com/watch?v=_UmmaPe8Bzc

JS Unit टेस्टिंग (बहुत अच्छा) - https://www.youtube.com/watch?v=-IYqgx8JxlU

टेस्टेबल जावास्क्रिप्ट लिखना - https://www.youtube.com/watch?v=OzjogCFO4Zo

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

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

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

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

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

इसके अलावा, यदि आप नहीं चाहते हैं, तो आपको अपने कोड का परीक्षण करने की आवश्यकता नहीं है, लेकिन यह भुगतान करता है क्योंकि आपकी परियोजना / कोड आधार बड़ा होने लगता है क्योंकि बग को शुरू करने की संभावना बढ़ जाती है।


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

mbUnit , NUnit , mbUnit , आदि ऐसे उपकरण हैं जो परीक्षण लिखने में आपकी सहायता करते हैं।


यूनिट परीक्षण लेखन कोड के बारे में है जो आपके एप्लिकेशन कोड का परीक्षण करता है।

नाम का यूनिट भाग एक समय में कोड की छोटी इकाइयों (उदाहरण के लिए एक विधि) का परीक्षण करने के इरादे के बारे में है।

इस परीक्षण में मदद करने के लिए xUnit है - वे ऐसे ढांचे हैं जो इसके साथ सहायता करते हैं। इसका एक हिस्सा स्वचालित परीक्षण धावक हैं जो आपको बताते हैं कि कौन सी परीक्षा विफल हो जाती है और कौन सी पास हो जाती है।

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

आपके पास यह जांचने के लिए एक परीक्षण हो सकता है कि एक अपेक्षित अपवाद फेंक दिया गया है, बिना पूरे प्रयास को लिखने के लिए अपने आप को ब्लॉक करें।


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

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

इसलिए एक इकाई परीक्षण "फ़ंक्शन" में संलग्न कार्यक्षमता का उपयोग करेगा जो आप डेटाबेस अपडेट के साइड इफेक्ट्स के बिना परीक्षण कर रहे हैं।

मान लें कि आपके फ़ंक्शन ने डेटाबेस से कुछ संख्याओं को पुनर्प्राप्त किया और फिर एक मानक विचलन गणना की। आप यहां क्या परीक्षण करने की कोशिश कर रहे हैं? मानक विचलन की सही गणना की जाती है या डेटा डेटाबेस से वापस किया जाता है?

एक इकाई परीक्षण में आप बस यह परीक्षण करना चाहते हैं कि मानक विचलन की सही गणना की जाती है। एक एकीकरण परीक्षण में आप मानक विचलन गणना और डेटाबेस पुनर्प्राप्ति का परीक्षण करना चाहते हैं।


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


Testivus प्रयोग करें। आपको बस इतना पता होना चाहिए :)


मुझे लगता है कि आपको समझ में नहीं आने वाली बात यह है कि एनयूनाइट (और इस तरह) की इकाई परीक्षण रूपरेखा आपको छोटे से मध्यम आकार के परीक्षणों को स्वचालित करने में मदद करेगी। आमतौर पर आप GUI में परीक्षण चला सकते हैं (उदाहरण के लिए NUnit के मामले में), बस एक बटन पर क्लिक करके और फिर - उम्मीद है - प्रगति बार को हरा रहें। यदि यह लाल हो जाता है, तो रूपरेखा आपको दिखाती है कि कौन सा परीक्षण विफल हुआ और क्या गलत हुआ। एक सामान्य इकाई परीक्षण में, आप अक्सर अभिकथन का उपयोग करते हैं, उदाहरण के लिए Assert.AreEqual(expectedValue, actualValue, "some description") - इसलिए यदि दो मान असमान हैं, तो आपको एक त्रुटि दिखाई देगी, जिसमें "कुछ विवरण" - अपेक्षित <अपेक्षित> होगा, लेकिन था < actualValue> "।

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






glossary