दिलचस्प पोस्ट
पीडीएफ जीजीप्लॉट चार्ट को प्रिंट नहीं किया जा सकता महीने के सप्ताह की एनएटी में गणना करें जावा में ArrayList बनाम वेक्टर, अगर धागा सुरक्षा कोई चिंता नहीं है एंड्रॉइड लंबित अतिरिक्त एक्स्ट्रा, ब्रॉडकास्ट रीसेवर द्वारा प्राप्त नहीं हुआ मैं एक <div> जावास्क्रिप्ट का उपयोग कर एक HTML पृष्ठ कैसे लोड करूं? बैच फ़ाइल में कल की तारीख कैसे प्राप्त करें REST नेस्टेड संसाधनों के लिए सर्वोत्तम पद्धतियां क्या हैं जीएसएन से जेसन ने एक जेसन सिंटटाक्स को क्यों फेंक दिया है: कुछ प्रकार की उम्मीद है लेकिन कुछ अन्य प्रकार हैं? PHP में गतिशील रूप से mysqli bind_param तर्क बाध्य करने के लिए कैसे? जावास्क्रिप्ट: location.href बनाम स्थान की स्थापना लंबवत एक div को दूसरे div में केंद्रित कर रहा है अजाक्स अद्यतन / रेंडर एक घटक पर काम नहीं करता है जो विशेषता प्रदान की है गर्म और ठंडे अवलोकन: क्या 'गर्म' और 'ठंडा' ऑपरेटर हैं? एंड्रॉइड एडीबी टूल का इस्तेमाल करते हुए एक आवेदन कैसे शुरू करें? ओब्जेसी लिंकर फ्लैग क्या करता है?

क्या एक अच्छा यूनिट टेस्ट बनाता है?

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

मेरा प्रश्न क्या आप भविष्य में समस्याओं से बचने के लिए परीक्षण लिखने के लिए आचरण के किसी भी नियम का पालन करते हैं? अधिक विशिष्ट होना: अच्छा इकाई परीक्षणों के गुण क्या हैं या आप अपने परीक्षण कैसे लिख सकते हैं?

भाषा अज्ञेय सुझावों को प्रोत्साहित किया जाता है।

Solutions Collecting From Web of "क्या एक अच्छा यूनिट टेस्ट बनाता है?"

मुझे सूत्रों को छूने से शुरू करें- जावा में व्यावहारिक यूनिट परीक्षण JUnit के साथ (सी # -नुनिट के साथ एक संस्करण भी है .. लेकिन मेरे पास यह एक है … इसकी सबसे अज्ञानी बात है। अनुशंसित।)

अच्छे टेस्ट होना चाहिए एक TRIP (acronym पर्याप्त चिपचिपा नहीं है – मेरे पास पुस्तक में चीटशीट का एक प्रिंटआउट है जिसे मुझे निकालने के लिए मुझे यह अधिकार मिल गया था ..)

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

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

2010-08 का अद्यतन करें:

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

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

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

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

Womp लेखन टेस्ट के 5 कानून:


1. लंबा, वर्णनात्मक परीक्षण विधि नाम का उपयोग करें।

- Map_DefaultConstructorShouldCreateEmptyGisMap() - ShouldAlwaysDelegateXMLCorrectlyToTheCustomHandlers() - Dog_Object_Should_Eat_Homework_Object_When_Hungry() 

2. एक व्यवस्थित / अधिनियम / आर्टिस्ट शैली में अपने परीक्षण लिखें।

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

3. अपने एहॉट्स के साथ हमेशा एक विफलता संदेश प्रदान करें।

 Assert.That(x == 2 && y == 2, "An incorrect number of begin/end element processing events was raised by the XElementSerializer"); 
  • एक सरल और पुरस्कृत अभ्यास जो आपके धावक एप्लिकेशन में स्पष्ट करता है जो कि विफल हो गया है यदि आप कोई संदेश नहीं देते हैं, तो आप आमतौर पर आपके असफल आउटपुट में "अपेक्षित सत्य, झूठी" जैसी कुछ मिल जाएगी, जो आपको वास्तव में जांचने के लिए पढ़ने के लिए क्या गलत है यह जानने के लिए है।

4. परीक्षा का कारण टिप्पणी करें – व्यापार धारणा क्या है?

  /// A layer cannot be constructed with a null gisLayer, as every function /// in the Layer class assumes that a valid gisLayer is present. [Test] public void ShouldNotAllowConstructionWithANullGisLayer() { } 
  • यह स्पष्ट प्रतीत हो सकता है, लेकिन यह अभ्यास उन लोगों से अपने परीक्षणों की अखंडता की रक्षा करेगा, जो पहली बार परीक्षा के पीछे कारण का कारण नहीं समझते हैं। मैंने देखा है कि कई परीक्षण हटाए गए या संशोधित किए गए थे जो पूरी तरह से ठीक थे, बस इसलिए क्योंकि उस व्यक्ति ने मान्यताओं को नहीं समझा कि परीक्षा का सत्यापन किया गया था।
  • यदि परीक्षण तुच्छ है या विधि का नाम पर्याप्त रूप से वर्णनात्मक है, तो टिप्पणी को छोड़ने के लिए अनुमत हो सकता है।

5. हर परीक्षा में हमेशा किसी भी संसाधन की स्थिति को वापस करना चाहिए जो वह छूता है

  • वास्तविक संसाधनों से निपटने से बचने के लिए जहां संभव हो, का उपयोग करें।
  • सफाई स्तर पर परीक्षण किया जाना चाहिए। निष्पादन के आदेश पर टेस्टों पर कोई निर्भरता नहीं होनी चाहिए।

इन लक्ष्यों को ध्यान में रखें (मेसजारोस द्वारा पुस्तक xUnit टेस्ट पैटर्नों से अनुकूलित)

  • टेस्ट को जोखिम कम करना चाहिए, इसे लागू नहीं करना चाहिए
  • टेस्ट चलाने के लिए आसान होना चाहिए।
  • सिस्टम को बनाए रखने के लिए टेस्ट करना आसान होना चाहिए क्योंकि सिस्टम उनके आस-पास विकसित होता है

कुछ चीज़ों को यह आसान बनाने के लिए:

  • टेस्ट केवल एक कारण के कारण विफल हो जाना चाहिए
  • टेस्ट केवल एक चीज का परीक्षण करना चाहिए
  • परीक्षण निर्भरता को न्यूनतम करें (डेटाबेस, फ़ाइलें, यूआई आदि पर कोई निर्भरता नहीं)

यह मत भूलो कि आप अपने xUnit ढांचे के साथ एकीकरण परीक्षण कर सकते हैं, लेकिन एकीकरण परीक्षण और इकाई परीक्षण अलग रख सकते हैं

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

महान इकाई परीक्षणों के कुछ गुण:

  • जब एक परीक्षण विफल हो जाता है, तो तुरंत यह स्पष्ट होना चाहिए कि समस्या कहाँ है यदि आपको समस्या को ट्रैक करने के लिए डिबगर का उपयोग करना है, तो आपके परीक्षण पर्याप्त नहीं हैं प्रति टेस्ट बिल्कुल एक दावा होने से यहां मदद मिलती है।

  • जब आप रिफैक्टर होते हैं, तो कोई भी परीक्षण विफल नहीं होना चाहिए।

  • टेस्ट इतनी तेज चलनी चाहिए कि आप उन्हें चलाने के लिए संकोच न करें।

  • सभी परीक्षण हमेशा पास होना चाहिए; कोई गैर निर्धारक परिणाम नहीं

  • इकाई परीक्षणों को अच्छी तरह से सकारात्मक होना चाहिए, जैसे आपके उत्पादन कोड

@ एलेरोटर: यदि आप सुझाव दे रहे हैं कि पुस्तकालय में अपने बाह्य एपीआई में यूनिट परीक्षण होना चाहिए, तो मैं असहमत हूं। मुझे प्रत्येक कक्षा के लिए यूनिट परीक्षण चाहिए, जिसमें कक्षाएं शामिल हों जिन्हें मैं बाह्य कॉल करने वालों को नहीं दिखाता। (हालांकि, अगर मुझे निजी तरीकों के लिए परीक्षण लिखने की आवश्यकता महसूस हो रही है, तो मुझे पुनर्विक्रेता की आवश्यकता है। )


संपादित करें: "एक परीक्षण के प्रति एक दावा" के कारण दोहराव के बारे में एक टिप्पणी थी विशेष रूप से, यदि आपके पास एक परिदृश्य सेट करने के लिए कुछ कोड है, और उसके बाद इसके बारे में एकाधिक दावे करना चाहते हैं, लेकिन प्रति परीक्षण केवल एक ही तर्क है, तो आप एकाधिक परीक्षणों में सेटअप को दोहरा सकते हैं।

मैं उस दृष्टिकोण को नहीं लेता इसके बजाय, मैं प्रति परिदृश्य में परीक्षण जुड़नार का उपयोग करता हूं यहाँ एक कठिन उदाहरण है:

 [TestFixture] public class StackTests { [TestFixture] public class EmptyTests { Stack<int> _stack; [TestSetup] public void TestSetup() { _stack = new Stack<int>(); } [TestMethod] [ExpectedException (typeof(Exception))] public void PopFails() { _stack.Pop(); } [TestMethod] public void IsEmpty() { Assert(_stack.IsEmpty()); } } [TestFixture] public class PushedOneTests { Stack<int> _stack; [TestSetup] public void TestSetup() { _stack = new Stack<int>(); _stack.Push(7); } // Tests for one item on the stack... } } 

परीक्षा के तहत कक्षा के व्यवहार के चित्रण के बाद आप क्या कर रहे हैं

  1. अपेक्षित व्यवहारों का सत्यापन
  2. त्रुटि मामलों का सत्यापन
  3. कक्षा में सभी कोड पथ का कवरेज।
  4. कक्षा में सभी सदस्य कार्यों का प्रयोग करना।

मूल आशय वर्ग के व्यवहार में अपना आत्मविश्वास बढ़ाता है।

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

HTH।

चियर्स,

लूटना

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

मुझे उपर्युक्त व्यावहारिक इकाई परीक्षण पुस्तक से सही बीइसप का संक्षिप्त नाम पसंद है:

  • सही : क्या परिणाम सही हैं ?
  • बी : क्या सभी बी की स्थिति सही है?
  • I : क्या हम रिश्तों को उलटे कर सकते हैं?
  • सी : क्या हम दूसरे तरीकों का उपयोग कर परिणामों की जांच कर सकते हैं?
  • : क्या हम आरर स्थितियों को लागू करने के लिए मजबूर कर सकते हैं?
  • पी : क्या सीमा के भीतर पी एक्सफार्मेंस विशेषताओं हैं?

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

अच्छे परीक्षणों को नियत करने योग्य होना चाहिए।

जटिल वातावरण के लिए ऐसा करने के लिए मुझे बिल्कुल नहीं पता है

सभी पाठ्यपुस्तकों को बेतरतीब ढंग से आना शुरू हो जाता है क्योंकि आपका कोड बेस सैकड़ों 1000 या लाखों लाइनों में पहुंचता है।

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

अच्छी वास्तुकला कुछ बातचीत विस्फोट को नियंत्रित कर सकता है, लेकिन अनिवार्य रूप से सिस्टम अधिक जटिल हो जाता है क्योंकि स्वचालित परीक्षण प्रणाली इसके साथ बढ़ती है

यह वह जगह है जहां आप ट्रेड-ऑफ से निपटने के लिए शुरू करते हैं:

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

आपको यह भी तय करना होगा:

आप अपने कोड बेस में परीक्षण के मामलों को कहाँ स्टोर करते हैं?

  • आप अपने परीक्षण के मामले कैसे दर्ज करते हैं?
  • टेस्ट केस रखरखाव को बचाने के लिए जुड़ने के लिए फिर से इस्तेमाल जुड़ने का परीक्षण कर सकते हैं?
  • क्या होता है जब एक रात परीक्षण का मामला निष्पादन विफल हो जाता है? ट्रिएज कौन करता है?
  • आप नकली वस्तुओं को कैसे बनाए रखते हैं? अगर आपके पास 20 मॉड्यूल हैं जो सभी नकली लॉगिंग एपीआई के अपने स्वाद का उपयोग करते हैं, तो एपीआई रिपल्स को जल्दी से बदलते हैं न सिर्फ परीक्षण के मामलों में परिवर्तन होता है, बल्कि 20 नकली वस्तुओं में बदलाव होता है। उन 20 मॉड्यूल कई अलग-अलग टीमों द्वारा कई वर्षों से लिखे गए थे। इसकी क्लासिक पुनः उपयोग वाली समस्या
  • व्यक्तियों और उनकी टीम स्वचालित परीक्षणों के मूल्य को समझते हैं, उन्हें यह बिल्कुल पसंद नहीं है कि दूसरी टीम यह कैसे कर रही है। 🙂

मैं हमेशा के लिए जा सकता था, लेकिन मेरा कहना है कि:

टेस्ट करने योग्य होने की आवश्यकता है

मैंने इन सिद्धांतों को कुछ समय पहले इस एमएसडीएन पत्रिका लेख में शामिल किया था जो मुझे लगता है कि किसी भी डेवलपर को पढ़ने के लिए महत्वपूर्ण है।

जिस तरह से मैं "अच्छा" यूनिट परीक्षणों को परिभाषित करता हूं, वह निम्नलिखित तीन गुणों को प्राप्त कर सकता है:

  • वे पठनीय हैं (नामकरण, दावा, चर, लंबाई, जटिलता ..)
  • वे रखरखाव कर रहे हैं (कोई तर्क नहीं, निर्दिष्ट नहीं, राज्य-आधारित, पुनर्संचित ..)
  • वे भरोसेमंद हैं (सही चीजों का परीक्षण, पृथक, एकीकरण परीक्षण नहीं ..)
  • यूनिट टेस्टिंग आपके यूनिट के बाहरी एपीआई का परीक्षण करता है, आपको आंतरिक व्यवहार का परीक्षण नहीं करना चाहिए।
  • एक TestCase के प्रत्येक परीक्षण को इस एपीआई के भीतर एक (और केवल एक ही) विधि का परीक्षण करना चाहिए।
    • असफल मामलों के लिए अतिरिक्त टेस्ट मामले शामिल किए जाने चाहिए।
  • अपने परीक्षणों की कवरेज का परीक्षण करें: एक बार एक इकाई का परीक्षण हो जाने पर, इस यूनिट के अंदर की 100% पंक्तियां निष्पादित की जानी चाहिए।

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

सधन्यवाद

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

मैं दूसरा "ए ट्रिप" उत्तर देता हूं, सिवाय इसके कि परीक्षण एक-दूसरे पर भरोसा करना चाहिए !!!

क्यूं कर?

सूख – खुद को दोहराएं – परीक्षण के लिए भी लागू होता है! परीक्षण निर्भरता 1) बचत समय बचाने के लिए, 2) स्थिरता संसाधनों को बचा सकते हैं, और 3) विफलताओं को इंगित कर सकते हैं। बेशक, केवल यह कि आपका परीक्षण ढांचा प्रथम श्रेणी के निर्भरता को समर्थन देता है अन्यथा, मैं मानता हूं, वे बुरे हैं

http://www.iam.unibe.ch/~scg/Research/JExample/ का पालन करें

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

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

बिंदु प्रत्येक कार्य को जांचने में सक्षम होने के लिए हर चीज को फिर से चलाने से बचने के लिए है

  • मैं तीसरे प्रकार को अक्सर चलाता हूं क्योंकि सभी नकली वस्तुओं / डेटा पहले से ही मौजूद हैं
  • जब भी मेरा मॉडल बदल जाता है, मैं दूसरी तरह चलाता हूं
  • मैं मूलभूत प्रतिगमन को जांचने के लिए थोड़ी देर में बहुत ही बुनियादी कार्यों की जांच करने के लिए पहले एक चलाता हूं।

परीक्षण के 2 प्रकारों के बारे में सोचें और उन्हें अलग तरह से व्यवहार करें – कार्यात्मक परीक्षण और प्रदर्शन परीक्षण

प्रत्येक के लिए विभिन्न इनपुट और मैट्रिक्स का उपयोग करें आपको प्रत्येक प्रकार के परीक्षण के लिए अलग-अलग सॉफ़्टवेयर का उपयोग करने की आवश्यकता हो सकती है

मैं रॉय ओशेरव के यूनिट टेस्ट नामकरण मानकों के वर्णित एक सुसंगत परीक्षण नामकरण सम्मेलन का उपयोग करता हूं किसी दिए गए परीक्षण केस वर्ग में प्रत्येक विधि निम्नलिखित नामकरण शैली MethodUnderTest_Scenario_ExpectedResult है।

    पहला परीक्षण नाम अनुभाग परीक्षण के तहत सिस्टम में विधि का नाम है।
    अगला विशिष्ट परिदृश्य है जिसे परीक्षण किया जा रहा है
    अंत में उस परिदृश्य के परिणाम हैं

प्रत्येक अनुभाग ऊपरी ऊंट का उपयोग करता है और अंडर स्कोर द्वारा सीमांकित किया जाता है।

मैंने यह उपयोगी पाया है जब मैं परीक्षण चलाता हूँ परीक्षण परीक्षा के तहत विधि के नाम से समूहीकृत किया जाता है। और एक सम्मेलन में अन्य डेवलपर्स को परीक्षण मंशा को समझने की अनुमति मिलती है

मैं विधि नाम के पैरामीटर को भी जोड़ता हूं अगर परीक्षण के तहत विधि ओवरलोड हो गई है।