आप इकाई परीक्षण कैसे करते हैं? [बन्द है]


89

मैं MVCStoreFront App पर रोब कॉनरी वेबकास्ट देख रहा था, और मैंने देखा कि वह सबसे अधिक सांसारिक चीजों, चीजों की तरह इकाई परीक्षण कर रहा था:

public Decimal DiscountPrice
{
   get
   {
       return this.Price - this.Discount;
   }
}

जैसे एक परीक्षण होगा:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,80);
}

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

यदि ऐसी स्थिति है, तो आपके यूनिट टेस्ट का मतलब आपके लिए कुछ भी नहीं है।

इसके अतिरिक्त, आपकी इकाई परीक्षण विफलता का एक और बिंदु है:

[TestMethod]
public void Test_DiscountPrice
{
    Product p = new Product();
    p.Price = 100;
    p.Discount = 20;
    Assert.IsEqual(p.DiscountPrice,90);
}

अब परीक्षण त्रुटिपूर्ण है। स्पष्ट रूप से एक साधारण परीक्षण में, यह कोई बड़ी बात नहीं है, लेकिन कहते हैं कि हम एक जटिल व्यावसायिक नियम का परीक्षण कर रहे थे। हम यहाँ क्या हासिल करते हैं?

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

मैं देख रहा हूं कि विफलता के अधिक संभावित बिंदु हैं, कोई वास्तविक लाभकारी रिटर्न के साथ, यदि छूट की कीमत गलत है, तो परीक्षण टीम को अभी भी यह मुद्दा मिलेगा, यूनिट परीक्षण ने किसी भी काम को कैसे बचाया?

मुझे यहां क्या समझ नहीं आ रहा है? कृपया मुझे TDD से प्यार करना सिखाएं, क्योंकि मुझे अब तक इसे उपयोगी मानने में मुश्किल समय आ रहा है। मैं भी चाहता हूं, क्योंकि मैं प्रगतिशील रहना चाहता हूं, लेकिन यह सिर्फ मेरे लिए मायने नहीं रखता है।

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


5
कई मामलों में इकाई परीक्षण है कल्पना, और प्रलेखन, भी!
स्टीवन ए। लोव

32
... और फिर यूनिट यूनिट टेस्ट का यूनिट टेस्ट ... लेकिन यूनिट and 4 टेस्ट और यूनिट ^ ५ टेस्ट के बारे में क्या ... आआआआआआआआह्ह्ह्ह्ह्ह्ह्ह्ह्ह!
डेकरकोट

14
किसी भी प्रकार के परीक्षण की कोई भी राशि आपको गलत विनिर्देशन से नहीं बचाएगी।
छिपकली

4
क्या किसी और ने सिर्फ एक हाथ से ताली बजाने जैसी आवाज़ सुनी?
ग्नोविस

9
मुझे लगता है कि उपयुक्त उद्धरण है "यह सभी तरह से नीचे कछुए है।"
क्विन टेलर

जवाबों:


63

सबसे पहले, परीक्षण सुरक्षा की तरह है - आप कभी भी 100% सुनिश्चित नहीं हो सकते हैं कि आप इसे प्राप्त कर चुके हैं, लेकिन प्रत्येक परत अधिक आत्मविश्वास जोड़ती है और जो समस्याएं बनी रहती हैं उन्हें आसानी से ठीक करने के लिए एक रूपरेखा।

दूसरा, आप सबरूटीन्स में परीक्षणों को तोड़ सकते हैं जो खुद को तब परखा जा सकता है। जब आपके पास 20 समान परीक्षण होते हैं, तो (परीक्षण किया हुआ) सबरूटीन बनाने का मतलब है कि आपका मुख्य परीक्षण सबरूटीन का 20 सरल चालान है, जिसके सही होने की अधिक संभावना है।

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


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

2
यही कारण है कि आप प्रत्येक परत का अलग-अलग परीक्षण करने के लिए नकली वस्तुओं का उपयोग कर रहे हैं।
तून Krijthe

10
महान, इसलिए मेरा परीक्षण IMockedComplexObject का उपयोग करके पास होगा, लेकिन जब मैं वास्तव में एक जटिलObject का उपयोग वास्तविक दुनिया में करता हूं, तो यह विफल हो जाता है ... मुझे फिर से कुछ भी नहीं मिला है।
फ्लाइस्वैट

16
@ जोनाथन - नहीं, आपको विश्वास है कि आपका कोड काम करता है - यह मानते हुए कि आपने कॉम्प्लेक्सऑब्जेक्ट के इंटरफेस को विकसित किया है और उस इंटरफेस के खिलाफ पर्याप्त रूप से परीक्षण किया है। सबसे खराब रूप से, आपको यह ज्ञान प्राप्त हुआ है कि ComplexObject की आपकी समझ वैसी नहीं है जैसा आपने अनुमान लगाया था।
tvanfosson

9
@FlySwat: IMockedComplexObject के बारे में आपकी टिप्पणी के जवाब में, मैं एक और उत्तर पर Cwash की टिप्पणी उद्धृत करता हूं: "आप जो परीक्षण करने की कोशिश कर रहे हैं, आप उसका मजाक नहीं उड़ाते हैं, आप उसका परीक्षण करने की कोशिश नहीं कर रहे हैं।"
ब्रायन

39

एक परीक्षण गलत होने से आपके उत्पादन कोड को तोड़ने की संभावना नहीं है। कम से कम, कोई भी परीक्षण नहीं होने से भी बदतर। तो यह "विफलता का बिंदु" नहीं है: उत्पाद को वास्तव में काम करने के लिए परीक्षणों को सही नहीं होना चाहिए। कार्य के रूप में हस्ताक्षर करने से पहले उन्हें सही होना पड़ सकता है, लेकिन किसी भी टूटे हुए परीक्षण को ठीक करने की प्रक्रिया आपके कार्यान्वयन कोड को खतरे में नहीं डालती है।

आप इस तरह के परीक्षण, यहां तक ​​कि तुच्छ परीक्षण के बारे में सोच सकते हैं, जैसा कि एक दूसरा विचार है कि कोड क्या करना चाहिए। एक राय परीक्षण है, दूसरा कार्यान्वयन है। यदि वे सहमत नहीं हैं, तो आप जानते हैं कि आपको एक समस्या है और आप करीब हैं।

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

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

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

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


4
एक गलत परीक्षा जंगली में कोड को तोड़ने देगी। Thats जहां विफलता पेश की है। यह आत्मविश्वास की झूठी भावना प्रदान करता है।
फ्लाईस्वात

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

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

2
बहुत दिलचस्प जवाब।
पीटर

22

मैं देख रहा हूं कि विफलता के अधिक संभावित बिंदु हैं, कोई वास्तविक लाभकारी रिटर्न के साथ, यदि छूट की कीमत गलत है, तो परीक्षण टीम को अभी भी यह मुद्दा मिलेगा, यूनिट परीक्षण ने किसी भी काम को कैसे बचाया?

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

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

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


"किसी विशिष्ट इनपुट वाली विधि को कॉल करें और इसकी अपेक्षित आउटपुट से तुलना करें।" लेकिन क्या होगा अगर आउटपुट एक जटिल प्रकार है ... एक XML दस्तावेज़ की तरह। आप सिर्फ "==" नहीं कर सकते, आपको विशिष्ट कोड तुलना लिखना होगा, और फिर शायद आपकी तुलना विधि छोटी हो सकती है ??
एंडी

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

शांत, धन्यवाद बिल। I'v ने एक नए स्थान पर काम करना शुरू किया, और यह यूनिट परीक्षण के साथ मेरा 1 बार है। मुझे लगता है कि सिद्धांत रूप में यह काम करता है, और हम क्रूज़ कंट्रोल का उपयोग कर रहे हैं, जहां यह वास्तव में उपयोगी है, लेकिन परीक्षण के बड़े सेटों को विरासत कोड के समान भाग्य का नुकसान होता है ... मुझे इसके बारे में निश्चित नहीं है ....
एंडी

11

यूनिट परीक्षण वहाँ हैं ताकि आपकी इकाइयाँ (विधियाँ) वही करें जो आप अपेक्षा करते हैं। परीक्षण लिखने से पहले आपको यह सोचने के लिए मजबूर करता है कि आप कोड लिखने से पहले आपसे क्या अपेक्षा रखते हैं । करने से पहले सोचना हमेशा एक अच्छा विचार है।

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

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

[संपादित करें]

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


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

ठीक ऐसा ही आप एक यूनिट टेस्ट में करते हैं। उस एल्गोरिथ्म को टुकड़ों में तोड़ें और प्रत्येक टुकड़े की जाँच करें। आमतौर पर, मुझे पता चलता है कि मेरा कोड खुद लिखता है क्योंकि मैंने पहले ही अपने यूनिट टेस्ट में उम्मीद लिख दी है।
tvanfosson

मॉक परीक्षण स्थान में एक अतिभारित शब्द है। आप जो परीक्षण करने का प्रयास कर रहे हैं, आप उसका मजाक नहीं उड़ाते हैं, आप उसका परीक्षण करने की कोशिश नहीं कर रहे हैं ... जब आप अपने व्यवसाय नियम के लिए परीक्षण लिख रहे हैं तो आप कोड बनाते हैं जो इसे आमंत्रित करता है - यह बिल्कुल भी मज़ाक नहीं कर रहा है। ।
cwash

@ डिस्चार्ज - मुझे यकीन नहीं है कि आपकी टिप्पणी मेरे जवाब पर कैसे लागू होती है। मैंने मजाक नहीं किया ... और मैं आपके अवलोकन से सहमत हूं।
तवान्फोसन

@tvanfosson - मेरी अंतिम टिप्पणी @FlySwat के जवाब में थी ... "नियम को बेमानी बताते हुए।" क्षमा करें, मैं निर्दिष्ट करना भूल गया।
cwash

10

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

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


1
+1 दिलचस्प अवधारणा जो मैंने अभी तक नहीं सुनी थी
विम कॉइनन

9

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

इस प्रक्रिया का कड़ाई से पालन करने पर, सभी 'इकाइयां' सुरक्षा जाल द्वारा सुरक्षित हैं, जो इकाई परीक्षण कर रहे हैं, यहां तक ​​कि सबसे सांसारिक भी।

Assert.IsEqual(p.DiscountPrice,90);

कोई कारण नहीं है कि परीक्षण उस दिशा में विकसित होता है - या मैं आपके तर्क में कुछ याद कर रहा हूं। जब कीमत 100 होती है और छूट 20 होती है, तो छूट की कीमत 80 होती है। यह एक आक्रमणकारी की तरह है।

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


लाल - हरा - रिफ्लेक्टर - यह टीडीडी प्रक्रिया के सार को याद रखना है।

लाल संदर्भित करता है JUnit बार लाल करने के लिए जब एक परीक्षण विफल रहता है।

जब सभी परीक्षण पास हो जाते हैं तो ग्रीन JUnit प्रगति पट्टी का रंग होता है।

Refactor हरी शर्त के तहत: किसी भी dupliation निकालने के लिए, पठनीयता में सुधार।


अब "कोड के ऊपर 3-4 परतों" के बारे में अपनी बात को संबोधित करने के लिए, यह एक पारंपरिक (झरना जैसी) प्रक्रिया में सच है, न कि जब विकास प्रक्रिया चुस्त होती है। और फुर्तीली वह दुनिया है जहां से टीडीडी आ रहा है; TDD eXtreme प्रोग्रामिंग की आधारशिला है ।

फुर्तीली फेंक-की-दीवार आवश्यकता दस्तावेजों के बजाय सीधे संचार के बारे में है।


8

हालांकि, मैं सभी यूनिट परीक्षण के लिए हूं, मुझे कभी-कभी आश्चर्य होता है कि क्या परीक्षण का यह रूप पहले विकास वास्तव में फायदेमंद है ...

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

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

... [I] ना वास्तविक प्रक्रिया, आपके पास अपने कोड (व्यवसाय अनुरोध, आवश्यकताएँ दस्तावेज़, वास्तुकला दस्तावेज़) के ऊपर ३-४ परतें होती हैं, जहाँ वास्तविक परिभाषित व्यापार नियम (डिस्काउंट मूल्य मूल्य - छूट) गलत हो सकता है। यदि ऐसी स्थिति है, तो आपके यूनिट टेस्ट का मतलब आपके लिए कुछ भी नहीं है।

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

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

इसके अतिरिक्त, आपकी इकाई परीक्षण विफलता का एक और बिंदु है ...

एक सफल परीक्षण वह है जो सिस्टम में विफलता को प्रदर्शित करता है। एक असफल परीक्षा आपको परीक्षण के तर्क में त्रुटि या आपके सिस्टम के तर्क में सतर्क कर देगी। आपके परीक्षणों का लक्ष्य आपके कोड को तोड़ना या एक परिदृश्य कार्य को सिद्ध करना है।

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

हम यहाँ क्या हासिल करते हैं?

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

पंखों की बात करते हुए, दो महान संसाधन हैं जिन्हें आपको इस संबंध में जांचना चाहिए:

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

[I] f छूट की कीमत गलत है, परीक्षण टीम अभी भी इस मुद्दे को खोजेगी, यूनिट परीक्षण ने किसी भी काम को कैसे बचाया?

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

मुझे यहां क्या समझ नहीं आ रहा है? कृपया मुझे TDD से प्यार करना सिखाएं, क्योंकि मुझे अब तक इसे उपयोगी मानने में मुश्किल समय आ रहा है। मैं भी चाहता हूं, क्योंकि मैं प्रगतिशील रहना चाहता हूं, लेकिन यह सिर्फ मेरे लिए मायने नहीं रखता है।

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

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

एक युगल लोग उल्लेख करते हैं कि परीक्षण कल्पना को लागू करने में मदद करता है। यह मेरा अनुभव रहा है कि कल्पना गलत भी रही है, अधिक बार नहीं ...

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

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


7

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

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

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

5

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

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

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

जैसन ने कहा, परीक्षण सुरक्षा है। और हाँ, कभी-कभी वे दोषपूर्ण परीक्षणों के कारण अतिरिक्त कार्य का परिचय देते हैं। लेकिन ज्यादातर समय वे विशाल समय बचाने वाले होते हैं। (और आपके पास उस व्यक्ति को दंडित करने का सही मौका है जो परीक्षण को तोड़ता है (हम रबर चिकन बात कर रहे हैं)।


4

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


यह मेरे किसी भी विचार को संबोधित नहीं करता है। मुझे टीडीडी का मूल मंत्र समझ में आता है ... मुझे इसका फायदा नहीं दिखता।
फ्लाईस्वाट

4

मैं सहजीवी संबंध रखने के रूप में यूनिट परीक्षण और उत्पादन कोड देखता हूं। सीधे शब्दों में कहें: एक दूसरे का परीक्षण करता है। और दोनों ही डेवलपर को परखते हैं।


3

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

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

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


3

मैं आपकी बात देख रहा हूं, लेकिन यह स्पष्ट रूप से अतिरंजित है।

आपका तर्क मूल रूप से है: परीक्षण विफलता का परिचय देते हैं। इसलिए परीक्षण खराब / समय की बर्बादी हैं।

हालांकि यह कुछ मामलों में सच हो सकता है, यह शायद ही बहुमत है।

टीडीडी मानता है: अधिक टेस्ट = कम विफलता।

टेस्ट कर रहे हैं और अधिक संभावना उन्हें परिचय से विफलता की पकड़ अंक के लिए।


1

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

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

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


1

मैंने इस प्रश्न का उत्तर देने के एक अच्छे तरीके के बारे में थोड़ा सोचा है, और वैज्ञानिक पद्धति के समानांतर तैयार करना चाहूंगा। IMO, आप इस प्रश्न को फिर से पढ़ सकते हैं, "आप एक प्रयोग कैसे करते हैं?"

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

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

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


1

परीक्षण लिखते समय आपको सही प्रतिमान का उपयोग करने की आवश्यकता है।

  1. पहले अपने परीक्षण लिखना शुरू करें।
  2. सुनिश्चित करें कि वे शुरू करने में विफल रहे।
  3. उन्हें पास करने के लिए।
  4. अपने कोड की जांच करने से पहले कोड की समीक्षा करें (सुनिश्चित करें कि परीक्षण की समीक्षा की गई है।)

आप हमेशा निश्चित नहीं रह सकते हैं लेकिन वे समग्र परीक्षणों में सुधार करते हैं।


0

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

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.